using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Norntastic.Auras;
using Norntastic.Brawler;
using Norntastic.Combat;
using Norntastic.Commands;
using Norntastic.Config;
using Norntastic.Content;
using Norntastic.Core;
using Norntastic.Creatures;
using Norntastic.Data;
using Norntastic.Effects;
using Norntastic.Effects.Handlers;
using Norntastic.Emotes;
using Norntastic.Kitchen;
using Norntastic.Martial;
using Norntastic.Progression;
using Norntastic.Safety;
using Norntastic.Styles;
using Norntastic.UI;
using Norntastic.Util;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Norntastic")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.7.0.0")]
[assembly: AssemblyInformationalVersion("0.7.0")]
[assembly: AssemblyProduct("Norntastic")]
[assembly: AssemblyTitle("Norntastic")]
[assembly: AssemblyVersion("0.7.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Norntastic
{
	[BepInPlugin("dafini.norntastic", "Norntastic", "0.14.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "dafini.norntastic";

		public const string PluginName = "Norntastic";

		public const string PluginVersion = "0.14.2";

		private Harmony _harmony;

		private const float PatchMapDelaySeconds = 8f;

		internal static string ConfigDirectory { get; private set; }

		private void Awake()
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			Log.Init(((BaseUnityPlugin)this).Logger);
			ConfigDirectory = Path.Combine(Paths.ConfigPath, "Norntastic");
			ModConfig.Bind(((BaseUnityPlugin)this).Config);
			Log.Warn("Built without ServerSync: settings are local only and will not be pushed from the server. Fine for testing, not for the group.");
			PerkPanelInput.Bind(((BaseUnityPlugin)this).Config);
			BrawlerInput.Bind(((BaseUnityPlugin)this).Config);
			OffhandPicker.Bind(((BaseUnityPlugin)this).Config);
			MartialInput.Bind(((BaseUnityPlugin)this).Config);
			AbilityInput.Bind(((BaseUnityPlugin)this).Config);
			PerkDatabase.Load(ConfigDirectory);
			CustomSkills.Register();
			Handlers.RegisterAll();
			BrawlerModifiers.DeclareImplemented();
			PerkEffectDriver.Init();
			EffectAggregator.ReportCoverage();
			DatabaseGuard.Arm();
			Norntastic.Emotes.Emotes.Init(ConfigDirectory);
			DerivedSeal.Load(ConfigDirectory);
			Bakery.Arm();
			PieCounter.Arm();
			Pies.Arm();
			Crops.Arm();
			Arsenal.Arm();
			Pantry.Arm();
			SmokeHook.Arm();
			Fryer.Arm();
			Stations.Arm();
			PerkPanel.Init();
			PerkConsole.Register();
			_harmony = new Harmony("dafini.norntastic");
			_harmony.PatchAll();
			((MonoBehaviour)this).Invoke("WritePatchMap", 8f);
			Log.Info("Norntastic 0.14.2 loaded. " + $"Perk interval {PerkDatabase.PointInterval}, " + "prestige " + (ModConfig.PrestigeEnabled.Value ? "on" : "off") + " " + $"(cap {ModConfig.PrestigeCap.Value}), " + "free respec " + (ModConfig.FreeRespec.Value ? "on" : "off") + ". " + $"Press {PerkPanelInput.Hotkey.Value} for the perk panel.");
		}

		private void WritePatchMap()
		{
			string text = PatchMap.WriteToDisk(ConfigDirectory, "dafini.norntastic");
			if (text != null)
			{
				Log.Info("Patch map written to " + text + ". nsg.patches <text> reads the same thing live.");
			}
		}

		private void OnDestroy()
		{
			PerkPanel.Shutdown();
			PerkEffectDriver.Forget();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
}
namespace Norntastic.Util
{
	internal static class Equipment
	{
		private struct Snapshot
		{
			internal bool Unarmored;

			internal bool EmptyHanded;

			internal bool Shield;

			internal bool Torch;

			internal bool TwoHanded;

			internal bool OneHanded;

			internal bool MatchedSet;

			internal bool Trinket;
		}

		private const float CacheSeconds = 0.2f;

		private static Snapshot _snap;

		private static float _takenAt = -1f;

		internal static void Invalidate()
		{
			_takenAt = -1f;
		}

		private static Snapshot Current(Player player)
		{
			float time = Time.time;
			if (_takenAt >= 0f && time - _takenAt < 0.2f)
			{
				return _snap;
			}
			_snap = Compute(player);
			_takenAt = time;
			return _snap;
		}

		internal static bool IsUnarmored(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return Current(player).Unarmored;
			}
			return false;
		}

		internal static bool IsEmptyHanded(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return Current(player).EmptyHanded;
			}
			return false;
		}

		internal static bool HasShield(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return Current(player).Shield;
			}
			return false;
		}

		internal static bool HasTorch(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return Current(player).Torch;
			}
			return false;
		}

		internal static bool IsTwoHanded(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return Current(player).TwoHanded;
			}
			return false;
		}

		internal static bool IsOneHanded(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return Current(player).OneHanded;
			}
			return false;
		}

		internal static bool IsFullMatchedSet(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return Current(player).MatchedSet;
			}
			return false;
		}

		internal static bool HasTrinket(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return Current(player).Trinket;
			}
			return false;
		}

		private static bool TrainsUnarmed(ItemData item)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			if (item?.m_shared != null)
			{
				return (int)item.m_shared.m_skillType == 11;
			}
			return false;
		}

		private static Snapshot Compute(Player player)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected I4, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Invalid comparison between Unknown and I4
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Invalid comparison between Unknown and I4
			Snapshot result = new Snapshot
			{
				Unarmored = true,
				EmptyHanded = true
			};
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return result;
			}
			List<ItemData> allItems = inventory.GetAllItems();
			if (allItems == null)
			{
				return result;
			}
			string helmet = null;
			string chest = null;
			string legs = null;
			foreach (ItemData item in allItems)
			{
				if (item == null || !item.m_equipped || item.m_shared == null)
				{
					continue;
				}
				ItemType itemType = item.m_shared.m_itemType;
				if (IsArmorSlot(itemType))
				{
					result.Unarmored = false;
				}
				if (IsHeldSlot(itemType) && !TrainsUnarmed(item))
				{
					result.EmptyHanded = false;
				}
				switch (itemType - 3)
				{
				default:
					if ((int)itemType != 22)
					{
						if ((int)itemType == 24)
						{
							result.Trinket = true;
						}
						break;
					}
					goto case 1;
				case 2:
					result.Shield = true;
					break;
				case 12:
					result.Torch = true;
					break;
				case 3:
					helmet = item.m_shared.m_name;
					break;
				case 4:
					chest = item.m_shared.m_name;
					break;
				case 8:
					legs = item.m_shared.m_name;
					break;
				case 1:
				case 11:
					result.TwoHanded = true;
					break;
				case 0:
					result.OneHanded = true;
					break;
				case 5:
				case 6:
				case 7:
				case 9:
				case 10:
					break;
				}
			}
			result.MatchedSet = Matched(helmet, chest, legs);
			return result;
		}

		private static bool Matched(string helmet, string chest, string legs)
		{
			if (helmet == null || chest == null || legs == null)
			{
				return false;
			}
			string text = Letters(helmet);
			string text2 = Letters(chest);
			string text3 = Letters(legs);
			if (text.Length < 4 || text2.Length < 4 || text3.Length < 4)
			{
				return false;
			}
			for (int num = Math.Min(text.Length, Math.Min(text2.Length, text3.Length)); num >= 4; num--)
			{
				for (int i = 0; i + num <= text.Length; i++)
				{
					string value = text.Substring(i, num);
					if (text2.IndexOf(value, StringComparison.Ordinal) >= 0 && text3.IndexOf(value, StringComparison.Ordinal) >= 0)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static string Letters(string raw)
		{
			char[] array = new char[raw.Length];
			int length = 0;
			foreach (char c in raw)
			{
				if (char.IsLetter(c))
				{
					array[length++] = char.ToLowerInvariant(c);
				}
			}
			return new string(array, 0, length);
		}

		private static bool IsHeldSlot(ItemType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Invalid comparison between Unknown and I4
			//IL_0006: 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)
			//IL_0033: Expected I4, but got Unknown
			if (type - 3 > 2)
			{
				switch (type - 14)
				{
				case 0:
				case 1:
				case 5:
				case 6:
				case 8:
					break;
				default:
					return false;
				}
			}
			return true;
		}

		private static bool IsArmorSlot(ItemType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Invalid comparison between Unknown and I4
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			if (type - 6 <= 1 || (int)type == 11 || (int)type == 17)
			{
				return true;
			}
			return false;
		}
	}
	internal static class Json
	{
		internal static object Parse(string text)
		{
			int i = 0;
			object result = ParseValue(text, ref i);
			SkipWhitespace(text, ref i);
			if (i < text.Length)
			{
				throw new FormatException("Trailing content at offset " + i);
			}
			return result;
		}

		internal static Dictionary<string, object> Obj(object o)
		{
			return o as Dictionary<string, object>;
		}

		internal static List<object> Arr(object o)
		{
			return o as List<object>;
		}

		internal static object Get(object o, string key)
		{
			if (!(o is Dictionary<string, object> dictionary))
			{
				return null;
			}
			if (!dictionary.TryGetValue(key, out var value))
			{
				return null;
			}
			return value;
		}

		internal static string Str(object o, string key, string fallback = "")
		{
			return (Get(o, key) as string) ?? fallback;
		}

		internal static float Num(object o, string key, float fallback = 0f)
		{
			if (!(Get(o, key) is double num))
			{
				return fallback;
			}
			return (float)num;
		}

		internal static int Int(object o, string key, int fallback = 0)
		{
			if (!(Get(o, key) is double a))
			{
				return fallback;
			}
			return (int)Math.Round(a);
		}

		internal static bool Bool(object o, string key, bool fallback = false)
		{
			object obj = Get(o, key);
			if (obj is bool)
			{
				return (bool)obj;
			}
			return fallback;
		}

		internal static List<string> StrList(object o, string key)
		{
			List<string> list = new List<string>();
			if (!(Get(o, key) is List<object> list2))
			{
				return list;
			}
			foreach (object item2 in list2)
			{
				if (item2 is string item)
				{
					list.Add(item);
				}
			}
			return list;
		}

		private static void SkipWhitespace(string s, ref int i)
		{
			while (i < s.Length && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n' || s[i] == '\r'))
			{
				i++;
			}
		}

		private static object ParseValue(string s, ref int i)
		{
			SkipWhitespace(s, ref i);
			if (i >= s.Length)
			{
				throw new FormatException("Unexpected end of input");
			}
			switch (s[i])
			{
			case '{':
				return ParseObject(s, ref i);
			case '[':
				return ParseArray(s, ref i);
			case '"':
				return ParseString(s, ref i);
			case 't':
				Expect(s, ref i, "true");
				return true;
			case 'f':
				Expect(s, ref i, "false");
				return false;
			case 'n':
				Expect(s, ref i, "null");
				return null;
			default:
				return ParseNumber(s, ref i);
			}
		}

		private static void Expect(string s, ref int i, string literal)
		{
			if (i + literal.Length > s.Length || string.CompareOrdinal(s, i, literal, 0, literal.Length) != 0)
			{
				throw new FormatException("Expected '" + literal + "' at offset " + i);
			}
			i += literal.Length;
		}

		private static Dictionary<string, object> ParseObject(string s, ref int i)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			i++;
			SkipWhitespace(s, ref i);
			if (i < s.Length && s[i] == '}')
			{
				i++;
				return dictionary;
			}
			while (true)
			{
				SkipWhitespace(s, ref i);
				if (i >= s.Length || s[i] != '"')
				{
					throw new FormatException("Expected object key at offset " + i);
				}
				string key = ParseString(s, ref i);
				SkipWhitespace(s, ref i);
				if (i >= s.Length || s[i] != ':')
				{
					throw new FormatException("Expected ':' at offset " + i);
				}
				i++;
				dictionary[key] = ParseValue(s, ref i);
				SkipWhitespace(s, ref i);
				if (i >= s.Length)
				{
					throw new FormatException("Unterminated object");
				}
				if (s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (s[i] == '}')
			{
				i++;
				return dictionary;
			}
			throw new FormatException("Expected ',' or '}' at offset " + i);
		}

		private static List<object> ParseArray(string s, ref int i)
		{
			List<object> list = new List<object>();
			i++;
			SkipWhitespace(s, ref i);
			if (i < s.Length && s[i] == ']')
			{
				i++;
				return list;
			}
			while (true)
			{
				list.Add(ParseValue(s, ref i));
				SkipWhitespace(s, ref i);
				if (i >= s.Length)
				{
					throw new FormatException("Unterminated array");
				}
				if (s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (s[i] == ']')
			{
				i++;
				return list;
			}
			throw new FormatException("Expected ',' or ']' at offset " + i);
		}

		private static string ParseString(string s, ref int i)
		{
			StringBuilder stringBuilder = new StringBuilder();
			i++;
			while (i < s.Length)
			{
				char c = s[i++];
				switch (c)
				{
				case '"':
					return stringBuilder.ToString();
				default:
					stringBuilder.Append(c);
					continue;
				case '\\':
					break;
				}
				if (i >= s.Length)
				{
					break;
				}
				char c2 = s[i++];
				switch (c2)
				{
				case '"':
					stringBuilder.Append('"');
					break;
				case '\\':
					stringBuilder.Append('\\');
					break;
				case '/':
					stringBuilder.Append('/');
					break;
				case 'b':
					stringBuilder.Append('\b');
					break;
				case 'f':
					stringBuilder.Append('\f');
					break;
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 'r':
					stringBuilder.Append('\r');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case 'u':
					if (i + 4 > s.Length)
					{
						throw new FormatException("Bad \\u escape");
					}
					stringBuilder.Append((char)Convert.ToInt32(s.Substring(i, 4), 16));
					i += 4;
					break;
				default:
					throw new FormatException("Unknown escape '\\" + c2 + "'");
				}
			}
			throw new FormatException("Unterminated string");
		}

		private static object ParseNumber(string s, ref int i)
		{
			int num = i;
			if (i < s.Length && (s[i] == '-' || s[i] == '+'))
			{
				i++;
			}
			while (i < s.Length && (char.IsDigit(s[i]) || s[i] == '.' || s[i] == 'e' || s[i] == 'E' || s[i] == '+' || s[i] == '-'))
			{
				i++;
			}
			string text = s.Substring(num, i - num);
			if (double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			throw new FormatException("Bad number '" + text + "' at offset " + num);
		}
	}
	internal static class Log
	{
		private static ManualLogSource _log;

		internal static void Init(ManualLogSource source)
		{
			_log = source;
		}

		internal static void Info(string msg)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogInfo((object)msg);
			}
		}

		internal static void Warn(string msg)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogWarning((object)msg);
			}
		}

		internal static void Error(string msg)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogError((object)msg);
			}
		}

		internal static void Debug(string msg)
		{
			if (ModConfig.Verbose != null && ModConfig.Verbose.Value)
			{
				ManualLogSource log = _log;
				if (log != null)
				{
					log.LogInfo((object)("[dbg] " + msg));
				}
			}
		}
	}
	internal static class PatchMap
	{
		internal sealed class Entry
		{
			internal string Type = "?";

			internal string Method = "?";

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

			internal int Prefixes;

			internal int Postfixes;

			internal int Transpilers;

			internal int Finalizers;

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

			internal string Where => Type + "." + Method;

			internal bool Shared => Owners.Count > 1;

			internal string Counts => $"pre {Prefixes}  post {Postfixes}  trans {Transpilers}  fin {Finalizers}";

			internal bool OwnedBy(string id)
			{
				if (id != null)
				{
					return Owners.Contains(id);
				}
				return false;
			}
		}

		internal const string FileName = "patchmap.txt";

		internal static List<Entry> Collect()
		{
			List<Entry> list = new List<Entry>();
			IEnumerable<MethodBase> allPatchedMethods;
			try
			{
				allPatchedMethods = Harmony.GetAllPatchedMethods();
			}
			catch (Exception ex)
			{
				Log.Warn("Patch map unavailable: " + ex.Message);
				return list;
			}
			if (allPatchedMethods == null)
			{
				return list;
			}
			foreach (MethodBase item in allPatchedMethods)
			{
				if (item == null)
				{
					continue;
				}
				Patches patchInfo;
				try
				{
					patchInfo = Harmony.GetPatchInfo(item);
				}
				catch
				{
					continue;
				}
				if (patchInfo == null)
				{
					continue;
				}
				Entry entry = new Entry
				{
					Type = ((item.DeclaringType != null) ? item.DeclaringType.Name : "?"),
					Method = (item.Name ?? "?")
				};
				if (patchInfo.Owners != null)
				{
					foreach (string owner in patchInfo.Owners)
					{
						if (!string.IsNullOrEmpty(owner) && !entry.Owners.Contains(owner))
						{
							entry.Owners.Add(owner);
						}
					}
				}
				entry.Prefixes = Count(patchInfo.Prefixes);
				entry.Postfixes = Count(patchInfo.Postfixes);
				entry.Transpilers = Count(patchInfo.Transpilers);
				entry.Finalizers = Count(patchInfo.Finalizers);
				AddDetail(patchInfo, entry);
				list.Add(entry);
			}
			list.Sort((Entry a, Entry b) => string.Compare(a.Where, b.Where, StringComparison.Ordinal));
			return list;
		}

		private static int Count<T>(ICollection<T> patches)
		{
			return patches?.Count ?? 0;
		}

		private static void AddDetail(Patches info, Entry entry)
		{
			try
			{
				Describe(info.Prefixes, "prefix", entry);
				Describe(info.Postfixes, "postfix", entry);
				Describe(info.Transpilers, "TRANSPILER", entry);
				Describe(info.Finalizers, "finalizer", entry);
			}
			catch
			{
				entry.Detail.Clear();
			}
		}

		private static void Describe(IEnumerable<Patch> patches, string kind, Entry entry)
		{
			if (patches == null)
			{
				return;
			}
			foreach (Patch patch in patches)
			{
				if (patch != null)
				{
					entry.Detail.Add(patch.owner + " (" + kind + ")");
				}
			}
		}

		internal static List<string> Report(string ourId, string filter)
		{
			List<string> list = new List<string>();
			List<Entry> list2 = Collect();
			if (list2.Count == 0)
			{
				list.Add("No patches visible. Either Harmony has not run yet or it is not the Harmony this mod is talking to.");
				return list;
			}
			string text = (string.IsNullOrEmpty(filter) ? null : filter.ToLowerInvariant());
			List<Entry> list3 = new List<Entry>();
			foreach (Entry item in list2)
			{
				if (text == null || Matches(item, text))
				{
					list3.Add(item);
				}
			}
			int num = 0;
			foreach (Entry item2 in list2)
			{
				if (item2.Shared && item2.OwnedBy(ourId))
				{
					num++;
				}
			}
			list.Add($"--- patch map --- {list2.Count} patched method(s), " + $"{num} of them shared with Norntastic" + ((text == null) ? "" : $"   filter '{filter}' -> {list3.Count}"));
			if (list3.Count == 0)
			{
				list.Add("Nothing matches '" + filter + "'. Nobody has patched it, which for a crash in that method means the cause is somewhere else.");
				return list;
			}
			foreach (Entry item3 in list3)
			{
				string text2 = (item3.Shared ? ">>" : "  ");
				string text3 = (item3.OwnedBy(ourId) ? " [us]" : "");
				list.Add(text2 + " " + item3.Where + text3);
				list.Add("     " + item3.Counts);
				if (item3.Detail.Count > 0)
				{
					foreach (string item4 in item3.Detail)
					{
						list.Add("     " + item4);
					}
					continue;
				}
				foreach (string owner in item3.Owners)
				{
					list.Add("     " + owner);
				}
			}
			return list;
		}

		private static bool Matches(Entry entry, string needle)
		{
			if (entry.Where.ToLowerInvariant().Contains(needle))
			{
				return true;
			}
			foreach (string owner in entry.Owners)
			{
				if (owner != null && owner.ToLowerInvariant().Contains(needle))
				{
					return true;
				}
			}
			return false;
		}

		internal static string WriteToDisk(string directory, string ourId)
		{
			try
			{
				if (string.IsNullOrEmpty(directory))
				{
					return null;
				}
				Directory.CreateDirectory(directory);
				string text = Path.Combine(directory, "patchmap.txt");
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Norntastic patch map");
				stringBuilder.AppendLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("Every method Harmony has patched this session and which mod did it.");
				stringBuilder.AppendLine(">> marks a method more than one mod touches. [us] marks ours.");
				stringBuilder.AppendLine("A crash inside a patched method names neither the mod nor the patch;");
				stringBuilder.AppendLine("this file is how you get from the method in the stack trace to a GUID.");
				stringBuilder.AppendLine();
				foreach (string item in Report(ourId, null))
				{
					stringBuilder.AppendLine(item);
				}
				File.WriteAllText(text, stringBuilder.ToString());
				return text;
			}
			catch (Exception ex)
			{
				Log.Warn("Could not write the patch map: " + ex.Message);
				return null;
			}
		}
	}
	internal static class SkillKeys
	{
		private static readonly Dictionary<SkillType, string> ToKey;

		private static readonly Dictionary<string, SkillType> FromKey;

		private static readonly Dictionary<SkillType, string> Custom;

		static SkillKeys()
		{
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			ToKey = new Dictionary<SkillType, string>
			{
				{
					(SkillType)1,
					"swords"
				},
				{
					(SkillType)2,
					"knives"
				},
				{
					(SkillType)3,
					"clubs"
				},
				{
					(SkillType)4,
					"polearms"
				},
				{
					(SkillType)5,
					"spears"
				},
				{
					(SkillType)6,
					"blocking"
				},
				{
					(SkillType)7,
					"axes"
				},
				{
					(SkillType)8,
					"bows"
				},
				{
					(SkillType)9,
					"elemental"
				},
				{
					(SkillType)10,
					"bloodmagic"
				},
				{
					(SkillType)11,
					"unarmed"
				},
				{
					(SkillType)12,
					"pickaxes"
				},
				{
					(SkillType)13,
					"woodcutting"
				},
				{
					(SkillType)14,
					"crossbows"
				},
				{
					(SkillType)100,
					"jump"
				},
				{
					(SkillType)101,
					"sneak"
				},
				{
					(SkillType)102,
					"run"
				},
				{
					(SkillType)103,
					"swim"
				},
				{
					(SkillType)104,
					"fishing"
				},
				{
					(SkillType)105,
					"cooking"
				},
				{
					(SkillType)106,
					"farming"
				},
				{
					(SkillType)107,
					"crafting"
				},
				{
					(SkillType)108,
					"dodge"
				},
				{
					(SkillType)110,
					"riding"
				}
			};
			FromKey = new Dictionary<string, SkillType>(StringComparer.OrdinalIgnoreCase);
			Custom = new Dictionary<SkillType, string>();
			foreach (KeyValuePair<SkillType, string> item in ToKey)
			{
				FromKey[item.Value] = item.Key;
			}
		}

		internal static bool IsRealSkill(SkillType t)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			if ((int)t != 0)
			{
				return (int)t != 999;
			}
			return false;
		}

		internal static string Key(SkillType t)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected I4, but got Unknown
			if (ToKey.TryGetValue(t, out var value))
			{
				return value;
			}
			if (Custom.TryGetValue(t, out var value2))
			{
				return value2;
			}
			return "skill_" + (int)t;
		}

		internal static bool TryResolve(string key, out SkillType type)
		{
			return FromKey.TryGetValue(key, out type);
		}

		internal static void RegisterCustomKey(SkillType type, string key)
		{
			//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)
			Custom[type] = key;
			FromKey[key] = type;
		}

		internal static void RegisterCustom(SkillType type, string readableName)
		{
			//IL_0005: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!ToKey.ContainsKey(type))
			{
				string text = "x_" + Sanitise(readableName);
				Custom[type] = text;
				FromKey[text] = type;
			}
		}

		private static string Sanitise(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "unknown";
			}
			StringBuilder stringBuilder = new StringBuilder(s.Length);
			string text = s.Trim().ToLowerInvariant();
			foreach (char c in text)
			{
				if (char.IsLetterOrDigit(c))
				{
					stringBuilder.Append(c);
				}
				else if (c == ' ' || c == '_' || c == '-')
				{
					stringBuilder.Append('_');
				}
			}
			if (stringBuilder.Length != 0)
			{
				return stringBuilder.ToString();
			}
			return "unknown";
		}
	}
}
namespace Norntastic.UI
{
	internal static class Favourites
	{
		private static readonly List<string> Pinned = new List<string>();

		private static bool _loaded;

		internal static IReadOnlyList<string> All
		{
			get
			{
				Load();
				return Pinned;
			}
		}

		internal static int Count
		{
			get
			{
				Load();
				return Pinned.Count;
			}
		}

		internal static bool Has(string key)
		{
			Load();
			if (!string.IsNullOrEmpty(key))
			{
				return Pinned.Contains(key);
			}
			return false;
		}

		internal static bool Toggle(string key)
		{
			Load();
			if (string.IsNullOrEmpty(key))
			{
				return false;
			}
			if (Pinned.Contains(key))
			{
				Pinned.Remove(key);
			}
			else
			{
				Pinned.Add(key);
			}
			Save();
			return Pinned.Contains(key);
		}

		private static void Load()
		{
			if (_loaded)
			{
				return;
			}
			_loaded = true;
			Pinned.Clear();
			string text = ModConfig.FavouriteTrees?.Value;
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			string[] array = text.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length > 0 && !Pinned.Contains(text2) && PerkDatabase.Trees.ContainsKey(text2))
				{
					Pinned.Add(text2);
				}
			}
		}

		private static void Save()
		{
			if (ModConfig.FavouriteTrees != null)
			{
				ModConfig.FavouriteTrees.Value = string.Join(",", Pinned.ToArray());
			}
		}

		internal static void ResetForTests()
		{
			Pinned.Clear();
			_loaded = false;
		}
	}
	internal static class Palette
	{
		internal static readonly Color Ground = Color32.op_Implicit(new Color32((byte)11, (byte)14, (byte)18, (byte)242));

		internal static readonly Color Panel = Color32.op_Implicit(new Color32((byte)20, (byte)26, (byte)33, byte.MaxValue));

		internal static readonly Color Panel2 = Color32.op_Implicit(new Color32((byte)27, (byte)35, (byte)44, byte.MaxValue));

		internal static readonly Color Panel3 = Color32.op_Implicit(new Color32((byte)34, (byte)44, (byte)55, byte.MaxValue));

		internal static readonly Color Line = Color32.op_Implicit(new Color32((byte)42, (byte)54, (byte)65, byte.MaxValue));

		internal static readonly Color Ink = Color32.op_Implicit(new Color32((byte)216, (byte)224, (byte)232, byte.MaxValue));

		internal static readonly Color Ink2 = Color32.op_Implicit(new Color32((byte)168, (byte)182, (byte)194, byte.MaxValue));

		internal static readonly Color InkDim = Color32.op_Implicit(new Color32((byte)117, (byte)133, (byte)143, byte.MaxValue));

		internal static readonly Color Ember = Color32.op_Implicit(new Color32((byte)222, (byte)116, (byte)48, byte.MaxValue));

		internal static readonly Color Gold = Color32.op_Implicit(new Color32((byte)233, (byte)180, (byte)95, byte.MaxValue));

		internal static readonly Color Frost = Color32.op_Implicit(new Color32((byte)111, (byte)169, (byte)196, byte.MaxValue));

		internal static readonly Color Blood = Color32.op_Implicit(new Color32((byte)168, (byte)65, (byte)63, byte.MaxValue));

		internal static Color NodeFill(NodeVisualState state)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_002d: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(state switch
			{
				NodeVisualState.Max => Color32.op_Implicit(new Color32((byte)168, (byte)114, (byte)31, byte.MaxValue)), 
				NodeVisualState.Taken => Color32.op_Implicit(new Color32((byte)200, (byte)98, (byte)31, byte.MaxValue)), 
				NodeVisualState.Held => Color32.op_Implicit(new Color32((byte)200, (byte)98, (byte)31, byte.MaxValue)), 
				NodeVisualState.Available => Panel3, 
				_ => Panel2, 
			});
		}

		internal static Color NodeBorder(NodeVisualState state)
		{
			//IL_002c: 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_001a: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(state switch
			{
				NodeVisualState.Max => Gold, 
				NodeVisualState.Taken => Ember, 
				NodeVisualState.Held => Gold, 
				NodeVisualState.Available => Frost, 
				_ => Line, 
			});
		}

		internal static Color NodeLabel(NodeVisualState state)
		{
			//IL_0010: 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_000a: Unknown result type (might be due to invalid IL or missing references)
			switch (state)
			{
			case NodeVisualState.Taken:
			case NodeVisualState.Max:
			case NodeVisualState.Held:
				return Gold;
			case NodeVisualState.Available:
				return Ink;
			default:
				return new Color(InkDim.r, InkDim.g, InkDim.b, 0.5f);
			}
		}
	}
	internal enum NodeVisualState
	{
		Locked,
		Available,
		Taken,
		Max,
		Held
	}
	internal sealed class PerkDetailPane
	{
		private readonly RectTransform _root;

		private readonly Text _title;

		private readonly Text _meta;

		private readonly Text _flavour;

		private readonly Text _ranks;

		private readonly Text _gate;

		private readonly Button _buy;

		private readonly Text _buyLabel;

		private readonly Button _refund;

		private readonly Text _refundLabel;

		private PerkNode _node;

		internal event Action Changed;

		internal PerkDetailPane(Transform parent)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0059: 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)
			//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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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_00f5: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: 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_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: 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_022d: 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_0260: 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_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: 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_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: 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_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Expected O, but got Unknown
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Expected O, but got Unknown
			_root = UiFactory.Rect("detail", parent, new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(-330f, 12f), new Vector2(-12f, -12f));
			UiFactory.Fill(_root, Palette.Panel);
			_title = UiFactory.Label("title", (Transform)(object)_root, "", 22, Palette.Ink, (TextAnchor)0, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(16f, -50f), new Vector2(-16f, -14f));
			_meta = UiFactory.Label("meta", (Transform)(object)_root, "", 11, Palette.InkDim, (TextAnchor)0, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(16f, -70f), new Vector2(-16f, -50f));
			_flavour = UiFactory.Label("flavour", (Transform)(object)_root, "", 13, Palette.Ink2, (TextAnchor)0, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(18f, -118f), new Vector2(-16f, -74f));
			_flavour.fontStyle = (FontStyle)2;
			_ranks = UiFactory.Label("ranks", (Transform)(object)_root, "", 13, Palette.Ink2, (TextAnchor)0, new Vector2(0f, 0f), new Vector2(1f, 1f), new Vector2(16f, 108f), new Vector2(-16f, -122f));
			_gate = UiFactory.Label("gate", (Transform)(object)_root, "", 12, Palette.Blood, (TextAnchor)6, new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(16f, 60f), new Vector2(-16f, 104f));
			RectTransform val = UiFactory.Rect("buy", (Transform)(object)_root, new Vector2(0f, 0f), new Vector2(0.62f, 0f), new Vector2(16f, 16f), new Vector2(-4f, 52f));
			_buy = UiFactory.Clickable(val, Color32.op_Implicit(new Color32((byte)90, (byte)46, (byte)20, byte.MaxValue)));
			_buyLabel = UiFactory.Label("t", (Transform)(object)val, "TAKE PERK", 13, Palette.Gold, (TextAnchor)4, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			((UnityEvent)_buy.onClick).AddListener(new UnityAction(Buy));
			RectTransform val2 = UiFactory.Rect("refund", (Transform)(object)_root, new Vector2(0.62f, 0f), new Vector2(1f, 0f), new Vector2(4f, 16f), new Vector2(-16f, 52f));
			_refund = UiFactory.Clickable(val2, Palette.Panel3);
			_refundLabel = UiFactory.Label("t", (Transform)(object)val2, "REFUND", 13, Palette.InkDim, (TextAnchor)4, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			((UnityEvent)_refund.onClick).AddListener(new UnityAction(Refund));
		}

		internal void Show(PerkNode node)
		{
			_node = node;
			Refresh();
		}

		private void Buy()
		{
			if (_node != null)
			{
				if (PointMath.TryBuy(PerkState.Current, _node, out var message))
				{
					Toast(message);
				}
				Refresh();
				this.Changed?.Invoke();
			}
		}

		private void Refund()
		{
			if (_node != null)
			{
				if (Respec.TryRefund(PerkState.Current, _node, out var message))
				{
					Toast(message);
				}
				Refresh();
				this.Changed?.Invoke();
			}
		}

		private static void Toast(string message)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				((Character)localPlayer).Message((MessageType)1, message, 0, (Sprite)null, false);
			}
		}

		internal void Refresh()
		{
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			if (_node == null)
			{
				_title.text = "";
				_meta.text = "Pick a perk.";
				Text flavour = _flavour;
				Text ranks = _ranks;
				string text = (_gate.text = "");
				string text3 = (ranks.text = text);
				flavour.text = text3;
				Button buy = _buy;
				bool interactable = (((Selectable)_refund).interactable = false);
				((Selectable)buy).interactable = interactable;
				return;
			}
			PerkState current = PerkState.Current;
			PerkTree perkTree = PerkDatabase.Tree(_node.TreeKey);
			int rank = current.GetRank(_node.Id);
			NodeVisualState nodeVisualState = PerkTreeView.Visual(current, _node);
			_title.text = _node.Name;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append((perkTree != null) ? perkTree.Name : _node.TreeKey);
			stringBuilder.Append("   lv ").Append(_node.RequiresLevel).Append("+");
			stringBuilder.Append("   ").Append(rank).Append(" / ")
				.Append(_node.MaxRank)
				.Append(" ranks");
			if (_node.Requires.Count > 0 && perkTree != null)
			{
				List<string> list = new List<string>();
				foreach (string require in _node.Requires)
				{
					PerkNode perkNode = perkTree.Node(require);
					if (perkNode != null)
					{
						list.Add(perkNode.Name);
					}
				}
				if (list.Count > 0)
				{
					stringBuilder.Append("   after ").Append(string.Join(", ", list.ToArray()));
				}
			}
			_meta.text = stringBuilder.ToString();
			_flavour.text = (string.IsNullOrEmpty(_node.Flavour) ? "" : ("“" + _node.Flavour + "”"));
			StringBuilder stringBuilder2 = new StringBuilder();
			for (int i = 1; i <= _node.MaxRank; i++)
			{
				bool flag2 = i <= rank;
				stringBuilder2.Append(flag2 ? "<color=#DE7430>" : "<color=#75858F>").Append(i).Append("</color>   ")
					.Append(flag2 ? "<color=#D8E0E8>" : "<color=#75858F>")
					.Append(_node.RankText(i))
					.Append("</color>\n\n");
			}
			_ranks.supportRichText = true;
			_ranks.text = stringBuilder2.ToString();
			List<string> list2 = new List<string>();
			if (nodeVisualState == NodeVisualState.Held)
			{
				list2.Add("<color=#E9B45F>Held. Bought above this level and still applying — gates are checked at purchase only.</color>");
			}
			if (_node.IsExclusive)
			{
				PerkNode perkNode2 = PointMath.ExclusiveBlocker(current, perkTree, _node);
				list2.Add((perkNode2 == null) ? "<color=#6FA9C4>An exclusive fork. Taking it locks the others until refunded.</color>" : ("<color=#A8413F>Locked: you committed to " + perkNode2.Name + ".</color>"));
			}
			if (!_node.IsImplemented)
			{
				list2.Add("<color=#A8413F>Not yet implemented: " + _node.PendingNote + "</color>");
			}
			else if (_node.IsPartial)
			{
				list2.Add("<color=#E9B45F>Partly implemented. What is missing: " + _node.PendingNote + "</color>");
			}
			else if (!string.IsNullOrEmpty(_node.ImplementedNote))
			{
				list2.Add("<color=#8FA8B8>" + _node.ImplementedNote + "</color>");
			}
			string reason;
			PointMath.Gate gate = PointMath.CanBuy(current, _node, out reason);
			if (gate != PointMath.Gate.Ok && nodeVisualState != NodeVisualState.Held)
			{
				list2.Add("<color=#E2A3A1>" + reason + "</color>");
			}
			_gate.supportRichText = true;
			_gate.text = string.Join("\n", list2.ToArray());
			((Selectable)_buy).interactable = gate == PointMath.Gate.Ok;
			_buyLabel.text = ((rank > 0) ? "NEXT RANK" : "TAKE PERK");
			((Graphic)_buyLabel).color = (((Selectable)_buy).interactable ? Palette.Gold : Palette.InkDim);
			bool flag3 = ModConfig.FreeRespec != null && ModConfig.FreeRespec.Value;
			((Selectable)_refund).interactable = rank > 0 && (flag3 || current.RespecPoints > 0);
			_refundLabel.text = (flag3 ? "REFUND" : "REFUND · 1 RP");
		}
	}
	internal static class PerkPanel
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__Build;

			public static Action <1>__OnAllocationChanged;

			public static UnityAction <2>__Close;

			public static Action<PerkTree> <3>__ShowTree;

			public static UnityAction <4>__DoPrestige;

			public static Action <5>__RefreshAll;
		}

		private static GameObject _root;

		private static RectTransform _rootRect;

		private static SkillRail _rail;

		private static TreeSubRail _subRail;

		private static PerkTreeView _treeView;

		private static PerkDetailPane _detail;

		private static Text _ledger;

		private static Text _treeTitle;

		private static Text _treeBlurb;

		private static Text _treeFormula;

		private static Text _empty;

		private static Button _prestige;

		private static Text _prestigeLabel;

		private static PerkTree _current;

		private static float _sizedForScale;

		private static Vector2 _sizedForScreen;

		private const float HeaderHeight = 70f;

		internal static bool IsOpen
		{
			get
			{
				if ((Object)(object)_root != (Object)null)
				{
					return _root.activeSelf;
				}
				return false;
			}
		}

		internal static void Init()
		{
			GUIManager.OnCustomGUIAvailable += Build;
			PerkEvents.AllocationChanged += OnAllocationChanged;
			Log.Debug("Perk panel subscribed to OnCustomGUIAvailable.");
		}

		internal static void Shutdown()
		{
			GUIManager.OnCustomGUIAvailable -= Build;
			PerkEvents.AllocationChanged -= OnAllocationChanged;
			Destroy();
		}

		private static void Destroy()
		{
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
			_root = null;
			_rootRect = null;
			_rail = null;
			_subRail = null;
			_treeView = null;
			_detail = null;
			_current = null;
		}

		internal static void Toggle()
		{
			if (IsOpen)
			{
				Close();
			}
			else
			{
				Open();
			}
		}

		internal static void Open()
		{
			if ((Object)(object)_root == (Object)null)
			{
				Build();
			}
			if ((Object)(object)_root == (Object)null)
			{
				Log.Warn("Perk panel could not be built - custom GUI is not available yet.");
				return;
			}
			_root.SetActive(true);
			GUIManager.BlockInput(true);
			ApplyScale();
			_rail.Build();
			if (_current == null || !_rail.TrySelect(_current.Key))
			{
				_current = null;
				_rail.SelectFirst();
			}
			((Behaviour)_empty).enabled = _rail.IsEmpty;
			RefreshAll();
		}

		internal static void Close()
		{
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(false);
			}
			GUIManager.BlockInput(false);
		}

		private static void ApplyScale()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rootRect == (Object)null))
			{
				float num = Mathf.Clamp(ModConfig.UiScale.Value, 0.8f, 2.5f);
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor((float)Screen.width, (float)Screen.height);
				((Transform)_rootRect).localScale = new Vector3(num, num, 1f);
				_rootRect.sizeDelta = val / num;
				_sizedForScale = num;
				_sizedForScreen = val;
			}
		}

		private static void Build()
		{
			//IL_002e: 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_0060: 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_0093: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00f7: 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_0114: 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_0133: 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_0147: 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_0175: 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_0193: 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_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: 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_022d: 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_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_0289: 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)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: 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_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: 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_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: 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_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: 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_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: 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_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04df: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_050e: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: 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_0554: Unknown result type (might be due to invalid IL or missing references)
			//IL_0559: Unknown result type (might be due to invalid IL or missing references)
			//IL_0576: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_0586: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05df: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bf: Expected O, but got Unknown
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_064d: 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_066b: Unknown result type (might be due to invalid IL or missing references)
			//IL_067a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)GUIManager.CustomGUIFront == (Object)null))
			{
				Destroy();
				Transform transform = GUIManager.CustomGUIFront.transform;
				_rootRect = UiFactory.Point("NorntasticPanel", transform, new Vector2(0.5f, 0.5f), new Vector2(1920f, 1080f));
				_root = ((Component)_rootRect).gameObject;
				((Graphic)UiFactory.Fill(_rootRect, Palette.Ground)).raycastTarget = true;
				RectTransform parent = UiFactory.Rect("header", (Transform)(object)_rootRect, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(16f, -70f), new Vector2(-16f, 0f));
				UiFactory.Label("brand", (Transform)(object)parent, "NORNTASTIC SKILL GROWTH", 26, Palette.Ember, (TextAnchor)3, new Vector2(0f, 0f), new Vector2(0.38f, 1f), new Vector2(6f, 0f), Vector2.zero);
				_ledger = UiFactory.Label("ledger", (Transform)(object)parent, "", 15, Palette.Ink, (TextAnchor)5, new Vector2(0.38f, 0f), new Vector2(1f, 1f), Vector2.zero, new Vector2(-104f, 0f));
				RectTransform val = UiFactory.Rect("close", (Transform)(object)parent, new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(-92f, 14f), new Vector2(-6f, -14f));
				Button obj = UiFactory.Clickable(val, Palette.Panel3);
				UiFactory.Label("t", (Transform)(object)val, "CLOSE", 14, Palette.Ink2, (TextAnchor)4, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
				ButtonClickedEvent onClick = obj.onClick;
				object obj2 = <>O.<2>__Close;
				if (obj2 == null)
				{
					UnityAction val2 = Close;
					<>O.<2>__Close = val2;
					obj2 = (object)val2;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj2);
				_rail = new SkillRail((Transform)(object)UiFactory.Rect("railhost", (Transform)(object)_rootRect, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, -128f), new Vector2(0f, -70f)));
				_rail.TreeSelected += ShowTree;
				_subRail = new TreeSubRail((Transform)(object)UiFactory.Rect("subrailhost", (Transform)(object)_rootRect, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, -162f), new Vector2(0f, -128f)));
				_subRail.TreeSelected += ShowTree;
				RectTransform parent2 = UiFactory.Rect("body", (Transform)(object)_rootRect, Vector2.zero, Vector2.one, new Vector2(0f, 0f), new Vector2(0f, -162f));
				_empty = UiFactory.Label("empty", (Transform)(object)parent2, "No skill has been levelled yet.\nSwing something, and its tree appears here.", 18, Palette.InkDim, (TextAnchor)4, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
				((Behaviour)_empty).enabled = false;
				RectTransform parent3 = UiFactory.Rect("stage", (Transform)(object)parent2, Vector2.zero, Vector2.one, new Vector2(14f, 12f), new Vector2(-394f, -12f));
				RectTransform val3 = UiFactory.Rect("stagehead", (Transform)(object)parent3, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, -116f), new Vector2(0f, 0f));
				UiFactory.Fill(val3, Palette.Panel);
				_treeTitle = UiFactory.Label("title", (Transform)(object)val3, "", 26, Palette.Ink, (TextAnchor)0, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(18f, -46f), new Vector2(-176f, -10f));
				_treeBlurb = UiFactory.Label("blurb", (Transform)(object)val3, "", 14, Palette.Ink2, (TextAnchor)0, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(18f, -92f), new Vector2(-176f, -48f));
				_treeFormula = UiFactory.Label("formula", (Transform)(object)val3, "", 12, Palette.InkDim, (TextAnchor)6, new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(18f, 6f), new Vector2(-18f, 26f));
				RectTransform val4 = UiFactory.Rect("prestige", (Transform)(object)val3, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-166f, -48f), new Vector2(-14f, -14f));
				_prestige = UiFactory.Clickable(val4, Color32.op_Implicit(new Color32((byte)70, (byte)28, (byte)27, byte.MaxValue)));
				_prestigeLabel = UiFactory.Label("t", (Transform)(object)val4, "PRESTIGE", 13, Palette.Blood, (TextAnchor)4, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
				ButtonClickedEvent onClick2 = _prestige.onClick;
				object obj3 = <>O.<4>__DoPrestige;
				if (obj3 == null)
				{
					UnityAction val5 = DoPrestige;
					<>O.<4>__DoPrestige = val5;
					obj3 = (object)val5;
				}
				((UnityEvent)onClick2).AddListener((UnityAction)obj3);
				RectTransform parent4 = UiFactory.Rect("graph", (Transform)(object)parent3, Vector2.zero, Vector2.one, new Vector2(0f, 0f), new Vector2(0f, -120f));
				_treeView = new PerkTreeView((Transform)(object)parent4);
				_treeView.NodeSelected += delegate(PerkNode node)
				{
					_detail.Show(node);
				};
				UiFactory.Label("hint", (Transform)(object)parent4, "drag to pan  ·  wheel to zoom  ·  click a connector to travel  ·  right-click a tab to pin it", 12, Palette.InkDim, (TextAnchor)6, new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(22f, 18f), new Vector2(-22f, 38f));
				_detail = new PerkDetailPane((Transform)(object)parent2);
				_detail.Changed += RefreshAll;
				ApplyScale();
				_root.SetActive(false);
				Log.Debug("Perk panel built.");
			}
		}

		internal static void Tick()
		{
			//IL_0054: 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)
			//IL_0076: 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_00c2: 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)
			if (!IsOpen || (Object)(object)_rootRect == (Object)null)
			{
				return;
			}
			if (!Mathf.Approximately(_sizedForScale, ModConfig.UiScale.Value) || _sizedForScreen.x != (float)Screen.width || _sizedForScreen.y != (float)Screen.height)
			{
				ApplyScale();
			}
			Vector2 val = Vector2.op_Implicit(Input.mousePosition);
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (_rail != null && _rail.ContainsScreenPoint(val))
			{
				if (!Mathf.Approximately(axis, 0f))
				{
					_rail.Wheel(axis);
				}
				_treeView?.Tick(val, pointerOverViewport: false, 0f, _sizedForScale);
			}
			else
			{
				_treeView?.Tick(val, _treeView.ContainsScreenPoint(val), axis, _sizedForScale);
			}
		}

		private static void ShowTree(PerkTree tree)
		{
			_current = tree;
			_subRail?.Show(tree);
			_rail?.Refresh();
			_treeView.Show(tree);
			_detail.Show(tree?.Node(_treeView.Selected));
			RefreshAll();
		}

		private static void DoPrestige()
		{
			if (_current == null)
			{
				return;
			}
			if (Prestige.TryPrestige(PerkState.Current, _current, out var message))
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					((Character)localPlayer).Message((MessageType)2, message, 0, (Sprite)null, false);
				}
				_treeView.Show(_current);
			}
			RefreshAll();
		}

		private static void OnAllocationChanged()
		{
			if (IsOpen)
			{
				RefreshAll();
			}
		}

		internal static void RefreshAll()
		{
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_root == (Object)null) && _current != null)
			{
				PerkState current = PerkState.Current;
				int num = PointMath.Earned(current);
				int num2 = PointMath.Spent(current);
				int num3 = PointMath.SpentIn(current, _current);
				_ledger.text = $"{num} earned    {num2} spent    " + $"<color=#E9B45F>{num - num2} to spend anywhere</color>    " + $"<color=#6FA9C4>{current.RespecPoints} RP</color>" + ((num3 > 0) ? $"     <color=#75858F>{num3} in {_current.Name}</color>" : "");
				_ledger.supportRichText = true;
				int prestige = current.GetPrestige(_current.Key);
				_treeTitle.text = ((prestige > 0) ? (_current.Name + "  ✦" + prestige) : _current.Name);
				_treeBlurb.text = _current.Blurb;
				float num4 = PointMath.LevelFor(current, _current);
				if (_current.IsSector)
				{
					_treeFormula.text = $"average member level {num4:0}  →  {num} points   " + $"({_current.Members.Count} members)";
				}
				else if (_current.IsForeign)
				{
					bool flag = ForeignSkills.IsPresent(_current.Key);
					_treeFormula.text = (flag ? ($"from the {_current.ForeignSkill} mod  ·  high-water {num4:0} " + $"/ interval {PerkDatabase.PointInterval}") : ("needs the " + _current.ForeignSkill + " mod, which is not installed"));
				}
				else if (_current.RidesAnotherSkill)
				{
					PerkTree perkTree = PerkDatabase.Tree(_current.RidesKey);
					_treeFormula.text = "follows " + ((perkTree != null) ? perkTree.Name : _current.RidesKey) + " " + $"at level {num4:0}  ·  earns no points of its own";
				}
				else
				{
					_treeFormula.text = $"high-water {num4:0} / interval {PerkDatabase.PointInterval}" + $"  →  {num} points";
				}
				string reason;
				bool flag2 = Prestige.CanPrestige(current, _current, out reason);
				((Selectable)_prestige).interactable = flag2;
				_prestigeLabel.text = ((_current.IsSector || _current.RidesAnotherSkill) ? "INHERITED" : $"PRESTIGE ✦{prestige}/{ModConfig.PrestigeCap.Value}");
				((Graphic)_prestigeLabel).color = (flag2 ? Palette.Gold : Palette.InkDim);
				_rail.Refresh();
				_subRail?.Refresh();
				_treeView.Refresh();
				_detail.Refresh();
			}
		}
	}
	internal static class PerkPanelInput
	{
		internal static ConfigEntry<KeyboardShortcut> Hotkey;

		internal static void Bind(ConfigFile config)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Hotkey = config.Bind<KeyboardShortcut>("UI", "Hotkey", new KeyboardShortcut((KeyCode)112, Array.Empty<KeyCode>()), "Opens the perk panel.");
		}

		internal static void Tick(Player __instance)
		{
			//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 (Hotkey == null)
			{
				return;
			}
			if (PerkPanel.IsOpen && Input.GetKeyDown((KeyCode)27))
			{
				PerkPanel.Close();
				return;
			}
			PerkPanel.Tick();
			if (Console.IsVisible() || TextInput.IsVisible())
			{
				return;
			}
			Chat instance = Chat.instance;
			if (instance == null || !instance.HasFocus())
			{
				KeyboardShortcut value = Hotkey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					PerkPanel.Toggle();
				}
			}
		}
	}
	internal sealed class PerkTreeView
	{
		private sealed class NodeWidget
		{
			internal PerkNode Node;

			internal RectTransform Holder;

			internal Image Border;

			internal Image Fill;

			internal Text Rank;

			internal Text Label;

			internal Text Req;

			internal Button Button;
		}

		private readonly RectTransform _root;

		private readonly RectTransform _viewport;

		private readonly RectTransform _world;

		private readonly RectTransform _edges;

		private readonly RectTransform _nodes;

		private readonly CanvasGroup _worldGroup;

		private readonly Dictionary<string, NodeWidget> _widgets = new Dictionary<string, NodeWidget>();

		private readonly Dictionary<string, string> _focusByTree = new Dictionary<string, string>();

		private PerkTree _tree;

		private string _selected;

		private float _zoom = 1f;

		private Vector2 _pan;

		private Vector2 _panTarget;

		private bool _dragging;

		private bool _dragArmed;

		private Vector2 _dragOrigin;

		private Vector2 _panAtDragStart;

		private const float NodeSize = 54f;

		private const float LabelWidth = 168f;

		private const float SpreadX = 2600f;

		private const float SpreadY = 1700f;

		private const float MinZoom = 0.45f;

		private const float MaxZoom = 2.5f;

		private const float EdgeHitThickness = 26f;

		internal string Selected => _selected;

		internal event Action<PerkNode> NodeSelected;

		internal PerkTreeView(Transform parent)
		{
			//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_0042: 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_0066: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00e5: 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_0120: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			_root = UiFactory.Rect("tree", parent, Vector2.zero, Vector2.one, new Vector2(12f, 12f), new Vector2(-12f, -12f));
			UiFactory.Fill(_root, Palette.Panel);
			_viewport = UiFactory.Rect("viewport", (Transform)(object)_root, Vector2.zero, Vector2.one, new Vector2(2f, 2f), new Vector2(-2f, -2f));
			((Component)_viewport).gameObject.AddComponent<RectMask2D>();
			_world = UiFactory.Point("world", (Transform)(object)_viewport, new Vector2(0.5f, 0.5f), new Vector2(5200f, 3400f));
			_worldGroup = ((Component)_world).gameObject.AddComponent<CanvasGroup>();
			_edges = UiFactory.Rect("edges", (Transform)(object)_world, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			_nodes = UiFactory.Rect("nodes", (Transform)(object)_world, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
		}

		internal void Show(PerkTree tree)
		{
			_tree = tree;
			_zoom = Mathf.Clamp(ModConfig.TreeZoom.Value, 0.45f, 2.5f);
			Build();
			string text = null;
			if (tree != null && _focusByTree.TryGetValue(tree.Key, out var value) && tree.Node(value) != null)
			{
				text = value;
			}
			text = text ?? DefaultFocus(tree);
			SetFocus(text, animate: false);
		}

		private static string DefaultFocus(PerkTree tree)
		{
			if (tree == null || tree.Nodes.Count == 0)
			{
				return null;
			}
			PerkState current = PerkState.Current;
			PerkNode perkNode = null;
			foreach (PerkNode node in tree.Nodes)
			{
				if (current.GetRank(node.Id) > 0 && (perkNode == null || node.Y > perkNode.Y))
				{
					perkNode = node;
				}
			}
			return (perkNode ?? tree.Nodes[0]).Id;
		}

		private static Vector2 Place(PerkNode node)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2((node.X / 100f - 0.5f) * 2600f, (0.5f - node.Y / 100f) * 1700f);
		}

		private void Build()
		{
			UiFactory.Clear((Transform)(object)_edges);
			UiFactory.Clear((Transform)(object)_nodes);
			_widgets.Clear();
			if (_tree == null)
			{
				return;
			}
			foreach (PerkNode node in _tree.Nodes)
			{
				_widgets[node.Id] = BuildNode(node);
			}
			Refresh();
		}

		private NodeWidget BuildNode(PerkNode node)
		{
			//IL_002d: 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_0049: 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_0088: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//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_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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			//IL_0116: 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_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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: 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_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = UiFactory.Point("node_" + node.Id, (Transform)(object)_nodes, new Vector2(0.5f, 0.5f), new Vector2(168f, 106f));
			val.anchoredPosition = Place(node);
			RectTransform val2 = UiFactory.Point("gem", (Transform)(object)val, new Vector2(0.5f, 1f), new Vector2(54f, 54f));
			val2.anchoredPosition = new Vector2(0f, -27f);
			Image border = UiFactory.Fill(val2, Palette.Line);
			Image fill = UiFactory.Fill(UiFactory.Rect("fill", (Transform)(object)val2, Vector2.zero, Vector2.one, new Vector2(2f, 2f), new Vector2(-2f, -2f)), Palette.Panel2);
			Button val3 = UiFactory.Clickable(val2, Palette.Line);
			PerkNode captured = node;
			((UnityEvent)val3.onClick).AddListener((UnityAction)delegate
			{
				Select(captured);
			});
			Text rank = UiFactory.Label("rank", (Transform)(object)val2, "", 15, Palette.InkDim, (TextAnchor)4, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			RectTransform val4 = UiFactory.Rect("plate", (Transform)(object)val, new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(14f, 22f), new Vector2(-14f, 44f));
			UiFactory.Fill(val4, Palette.Panel);
			Text val5 = UiFactory.Label("label", (Transform)(object)val4, node.Name, 15, Palette.InkDim, (TextAnchor)4, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			val5.horizontalOverflow = (HorizontalWrapMode)1;
			RectTransform val6 = UiFactory.Rect("reqplate", (Transform)(object)val, new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(24f, 4f), new Vector2(-24f, 20f));
			UiFactory.Fill(val6, Palette.Panel);
			Text val7 = UiFactory.Label("req", (Transform)(object)val6, "lv " + node.RequiresLevel, 12, Palette.InkDim, (TextAnchor)4, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			val7.horizontalOverflow = (HorizontalWrapMode)1;
			return new NodeWidget
			{
				Node = node,
				Holder = val,
				Border = border,
				Fill = fill,
				Rank = rank,
				Label = val5,
				Req = val7,
				Button = val3
			};
		}

		private void Select(PerkNode node)
		{
			SetFocus(node.Id, animate: true);
			this.NodeSelected?.Invoke(node);
		}

		internal void SetFocus(string nodeId, bool animate)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0066: Unknown result type (might be due to invalid IL or missing references)
			_selected = nodeId;
			if (_tree != null && nodeId != null)
			{
				_focusByTree[_tree.Key] = nodeId;
			}
			PerkNode perkNode = _tree?.Node(nodeId);
			if (perkNode != null)
			{
				_panTarget = -Place(perkNode) * _zoom;
				if (!animate)
				{
					_pan = _panTarget;
				}
			}
			ApplyTransform();
			Refresh();
		}

		private void Travel(string fromId, string toId)
		{
			string text = ((_selected == toId) ? fromId : toId);
			PerkNode perkNode = _tree?.Node(text);
			if (perkNode != null)
			{
				SetFocus(text, animate: true);
				this.NodeSelected?.Invoke(perkNode);
			}
		}

		private void ApplyTransform()
		{
			//IL_0017: 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)
			((Transform)_world).localScale = new Vector3(_zoom, _zoom, 1f);
			_world.anchoredPosition = _pan;
		}

		internal void Tick(Vector2 mouse, bool pointerOverViewport, float wheel, float uiScale)
		{
			//IL_000a: 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_001a: 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_0050: 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_005b: 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_0108: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: 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_017b: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: 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)
			if (_tree == null)
			{
				return;
			}
			Vector2 val = _pan - _panTarget;
			if (((Vector2)(ref val)).sqrMagnitude > 0.5f && !_dragging)
			{
				float num = 1f - Mathf.Exp(-14f * Time.unscaledDeltaTime);
				_pan = Vector2.Lerp(_pan, _panTarget, num);
				ApplyTransform();
			}
			if (!pointerOverViewport && !_dragging)
			{
				_dragArmed = false;
				return;
			}
			if (!Mathf.Approximately(wheel, 0f))
			{
				float zoom = _zoom;
				_zoom = Mathf.Clamp(_zoom * (1f + wheel * 0.18f), 0.45f, 2.5f);
				if (!Mathf.Approximately(zoom, _zoom))
				{
					float num2 = _zoom / zoom;
					_pan *= num2;
					_panTarget *= num2;
					ApplyTransform();
				}
			}
			if (Input.GetMouseButtonDown(0))
			{
				_dragArmed = true;
				_dragOrigin = mouse;
				_panAtDragStart = _pan;
			}
			if (_dragArmed && Input.GetMouseButton(0))
			{
				Vector2 val2 = (mouse - _dragOrigin) / Mathf.Max(0.01f, uiScale);
				if (!_dragging && ((Vector2)(ref val2)).sqrMagnitude > 30f)
				{
					_dragging = true;
					_worldGroup.blocksRaycasts = false;
				}
				if (_dragging)
				{
					_pan = _panAtDragStart + val2;
					_panTarget = _pan;
					ApplyTransform();
				}
			}
			if (Input.GetMouseButtonUp(0))
			{
				_dragArmed = false;
				if (_dragging)
				{
					_dragging = false;
					_worldGroup.blocksRaycasts = true;
				}
			}
		}

		internal bool ContainsScreenPoint(Vector2 screen)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return UiFactory.ContainsScreenPoint(_viewport, screen);
		}

		internal void Refresh()
		{
			//IL_0045: 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_0069: 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_00cd: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: 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_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: 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_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: 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_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Expected O, but got Unknown
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			if (_tree == null)
			{
				return;
			}
			PerkState current = PerkState.Current;
			foreach (NodeWidget value in _widgets.Values)
			{
				PerkNode node = value.Node;
				NodeVisualState nodeVisualState = Visual(current, node);
				((Graphic)value.Border).color = Palette.NodeBorder(nodeVisualState);
				((Graphic)value.Fill).color = Palette.NodeFill(nodeVisualState);
				((Graphic)value.Label).color = Palette.NodeLabel(nodeVisualState);
				value.Rank.text = current.GetRank(node.Id) + "/" + node.MaxRank;
				((Graphic)value.Rank).color = (Color)(nodeVisualState switch
				{
					NodeVisualState.Available => Palette.Frost, 
					NodeVisualState.Locked => Palette.InkDim, 
					_ => Color32.op_Implicit(new Color32((byte)21, (byte)11, (byte)5, byte.MaxValue)), 
				});
				if (!node.IsImplemented)
				{
					value.Req.text = "lv " + node.RequiresLevel + "  ·  pending";
					((Graphic)value.Req).color = Palette.Blood;
				}
				else if (node.IsPartial)
				{
					value.Req.text = "lv " + node.RequiresLevel + "  ·  partial";
					((Graphic)value.Req).color = Palette.Gold;
				}
				else
				{
					value.Req.text = "lv " + node.RequiresLevel;
					((Graphic)value.Req).color = Palette.InkDim;
				}
				((Transform)((Graphic)value.Border).rectTransform).localScale = (Vector3)((node.Id == _selected) ? new Vector3(1.18f, 1.18f, 1f) : Vector3.one);
			}
			UiFactory.Clear((Transform)(object)_edges);
			foreach (PerkNode node2 in _tree.Nodes)
			{
				foreach (string require in node2.Requires)
				{
					PerkNode perkNode = _tree.Node(require);
					if (perkNode != null)
					{
						int rank = current.GetRank(require);
						int rank2 = current.GetRank(node2.Id);
						Color colour = ((rank > 0 && rank2 > 0) ? Palette.Ember : ((rank > 0) ? Palette.Frost : Palette.Line));
						Vector2 val = Place(perkNode);
						Vector2 to = Place(node2);
						string from = require;
						string to2 = node2.Id;
						((UnityEvent)UiFactory.HitLine((Transform)(object)_edges, val, to, 26f).onClick).AddListener((UnityAction)delegate
						{
							Travel(from, to2);
						});
						UiFactory.Connector((Transform)(object)_edges, val, to, (rank > 0 && rank2 > 0) ? 4f : 2.5f, colour);
					}
				}
			}
		}

		internal static NodeVisualState Visual(PerkState state, PerkNode node)
		{
			int rank = state.GetRank(node.Id);
			PerkTree perkTree = PerkDatabase.Tree(node.TreeKey);
			float num = ((perkTree != null) ? PointMath.LevelFor(state, perkTree) : 0f);
			if (rank > 0 && num < (float)node.RequiresLevel)
			{
				return NodeVisualState.Held;
			}
			if (rank >= node.MaxRank && rank > 0)
			{
				return NodeVisualState.Max;
			}
			if (rank > 0)
			{
				return NodeVisualState.Taken;
			}
			if (PointMath.CanBuy(state, node, out var _) != PointMath.Gate.Ok)
			{
				return NodeVisualState.Locked;
			}
			return NodeVisualState.Available;
		}
	}
	internal sealed class RightClick : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		internal Action Clicked;

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			if (eventData != null && (int)eventData.button == 1)
			{
				Clicked?.Invoke();
			}
		}

		internal static RightClick On(GameObject host, Action action)
		{
			RightClick rightClick = host.AddComponent<RightClick>();
			rightClick.Clicked = action;
			return rightClick;
		}
	}
	internal sealed class SkillRail
	{
		private sealed class Row
		{
			internal bool IsPinnedCopy;

			internal PerkTree Tree;

			internal RectTransform Root;

			internal Image Background;

			internal Image Accent;

			internal Text Name;

			internal Text Tally;
		}

		private readonly RectTransform _root;

		private readonly RectTransform _viewport;

		private readonly RectTransform _content;

		private readonly ScrollRect _scroll;

		private readonly List<Row> _rows = new List<Row>();

		private string _selected;

		internal const float RailHeight = 58f;

		private const float TabPadding = 18f;

		private const float GroupGap = 26f;

		private const float FadeWidth = 54f;

		private const int NameSize = 17;

		internal bool IsEmpty => _rows.Count == 0;

		internal event Action<PerkTree> TreeSelected;

		internal SkillRail(Transform parent)
		{
			//IL_0022: 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_0040: 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_0064: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: 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_0240: 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_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			_root = UiFactory.Rect("rail", parent, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, -58f), new Vector2(0f, 0f));
			UiFactory.Fill(_root, Palette.Panel);
			_viewport = UiFactory.Rect("viewport", (Transform)(object)_root, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			((Component)_viewport).gameObject.AddComponent<RectMask2D>();
			_content = UiFactory.Rect("content", (Transform)(object)_viewport, new Vector2(0f, 0f), new Vector2(0f, 1f), Vector2.zero, Vector2.zero);
			_content.pivot = new Vector2(0f, 0.5f);
			((Graphic)UiFactory.Fill(_viewport, new Color(0f, 0f, 0f, 0f))).raycastTarget = true;
			_scroll = ((Component)_root).gameObject.AddComponent<ScrollRect>();
			_scroll.content = _content;
			_scroll.viewport = _viewport;
			_scroll.horizontal = true;
			_scroll.vertical = false;
			_scroll.movementType = (MovementType)2;
			_scroll.scrollSensitivity = 42f;
			_scroll.inertia = true;
			_scroll.decelerationRate = ModConfig.RailGlide?.Value ?? 0.16f;
			UiFactory.EdgeFade(UiFactory.Rect("fade_l", (Transform)(object)_root, new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(0f, 0f), new Vector2(54f, 0f)), Palette.Ground, opaqueAtLeft: true);
			UiFactory.EdgeFade(UiFactory.Rect("fade_r", (Transform)(object)_root, new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(-54f, 0f), new Vector2(0f, 0f)), Palette.Ground, opaqueAtLeft: false);
		}

		private static TreeKind GroupOf(PerkTree tree)
		{
			if (!tree.IsForeign)
			{
				return tree.Kind;
			}
			return TreeKind.Stub;
		}

		internal static bool Visible(PerkTree tree, PerkState state)
		{
			if (tree.IsForeign && !ForeignSkills.IsPresent(tree.Key))
			{
				return false;
			}
			if (!ModConfig.HideUnlearnedSkills.Value)
			{
				return true;
			}
			if (tree.AlwaysShown)
			{
				return true;
			}
			foreach (PerkNode node in tree.Nodes)
			{
				if (state.GetRank(node.Id) > 0)
				{
					return true;
				}
			}
			if (tree.IsSector)
			{
				foreach (string member in tree.Members)
				{
					if (state.GetHighWater(member) > 0f)
					{
						return true;
					}
				}
				return false;
			}
			foreach (string item in tree.RevealWith)
			{
				if (state.GetHighWater(item) > 0f)
				{
					return true;
				}
			}
			if (tree.RidesAnotherSkill)
			{
				return state.GetHighWater(tree.RidesKey) > 0f;
			}
			return state.GetHighWater(tree.Key) > 0f;
		}

		internal void Build()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			UiFactory.Clear((Transform)(object)_content);
			_rows.Clear();
			PerkState current = PerkState.Current;
			float x = 27f;
			x = Pinned(current, x);
			x = Group("SKILLS", TreeKind.Skill, current, x);
			x = Group("NEW", TreeKind.New, current, x);
			x = Group("SECTORS", TreeKind.Sector, current, x);
			x = Group("MODDED", TreeKind.Stub, current, x);
			_content.sizeDelta = new Vector2(x + 27f, 0f);
			Refresh();
		}

		private float Pinned(PerkState state, float x)
		{
			List<string> list = new List<string>();
			foreach (string item in Favourites.All)
			{
				if (PerkDatabase.Trees.TryGetValue(item, out var value) && Visible(value, state))
				{
					list.Add(item);
				}
			}
			if (list.Count == 0)
			{
				return x;
			}
			x = Tag("PINNED", x);
			foreach (string item2 in list)
			{
				PerkTree tree = PerkDatabase.Trees[item2];
				float num = TabWidth(tree);
				_rows.Add(BuildTab(tree, x, num, pinnedCopy: true));
				x += num;
			}
			return x + 26f;
		}

		private float Tag(string title, float x)
		{
			//IL_001b: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_00ad: 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)
			RectTransform parent = UiFactory.Rect("g_" + title, (Transform)(object)_content, new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(x, 6f), new Vector2(x + 16f, -6f));
			Text obj = UiFactory.Label("t", (Transform)(object)parent, title, 10, Palette.InkDim, (TextAnchor)4, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, Vector2.zero);
			((Graphic)obj).rectTransform.sizeDelta = new Vector2(44f, 16f);
			((Graphic)obj).rectTransform.anchoredPosition = Vector2.zero;
			obj.horizontalOverflow = (HorizontalWrapMode)1;
			((Transform)((Graphic)obj).rectTransform).localRotation = Quaternion.Euler(0f, 0f, 90f);
			return x + 16f + 10f;
		}

		private float Group(string title, TreeKind kind, PerkState state, float x)
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, PerkTree> tree2 in PerkDatabase.Trees)
			{
				if (GroupOf(tree2.Value) == kind && Visible(tree2.Value, state))
				{
					list.Add(tree2.Key);
				}
			}
			if (list.Count == 0)
			{
				return x;
			}
			if (x > 54f)
			{
				x += 26f;
			}
			x = Tag(title, x);
			foreach (string item in list)
			{
				PerkTree tree = PerkDatabase.Trees[item];
				float num = TabWidth(tree);
				_rows.Add(BuildTab(tree, x, num, pinnedCopy: false));
				x += num;
			}
			return x;
		}

		private static float TabWidth(PerkTree tree)
		{
			return Mathf.Max(84f, (float)tree.Name.Length * 9.2f + 36f);
		}

		private Row BuildTab(PerkTree tree, float x, float width, bool pinnedCopy)
		{
			//IL_0039: 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_0053: 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_0089: 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_00b0: Expected O, but got Unknown
			//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)
			//IL_00eb: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			RectTransform rt = UiFactory.Rect((pinnedCopy ? "pin_" : "tab_") + tree.Key, (Transform)(object)_content, new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(x, 4f), new Vector2(x + width, -4f));
			Button obj = UiFactory.Clickable(rt, new Color(0f, 0f, 0f, 0f));
			PerkTree captured = tree;
			((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
			{
				Select(captured, rt);
			});
			RightClick.On(((Component)rt).gameObject, delegate
			{
				Favourites.Toggle(captured.Key);
				Build();
				TrySelect(_selected);
			});
			Text val = UiFactory.Label("name", (Transform)(object)rt, tree.Name, 17, Palette.Ink2, (TextAnchor)4, Vector2.zero, Vector2.one, new Vector2(6f, 0f), new Vector2(-6f, 4f));
			val.horizontalOverflow = (HorizontalWrapMode)1;
			Image accent = UiFactory.Fill(UiFactory.Rect("accent", (Transform)(object)rt, new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(9f, 0f), new Vector2(-9f, 3f)), new Color(0f, 0f, 0f, 0f));
			Text tally = UiFactory.Label("tally", (Transform)(object)rt, "", 11, Palette.Gold, (TextAnchor)2, new Vector2(0f, 0f), new Vector2(1f, 1f), new Vector2(0f, 0f), new Vector2(-5f, -4f));
			return new Row
			{
				Tree = tree,
				Root = rt,
				Background = ((Component)rt).GetComponent<Image>(),
				Accent = accent,
				Name = val,
				Tally = tally,
				IsPinnedCopy = pinnedCopy
			};
		}

		private void Select(PerkTree tree, RectTransform clicked)
		{
			_selected = tree.Key;
			Refresh();
			ScrollInto(clicked);
			this.TreeSelected?.Invoke(tree);
		}

		internal void SelectFirst()
		{
			if (_rows.Count > 0)
			{
				Select(_rows[0].Tree, _rows[0].Root);
			}
		}

		internal bool TrySelect(string key)
		{
			foreach (Row row in _rows)
			{
				if (!(row.Tree.Key != key))
				{
					Select(row.Tree, row.Root);
					return true;
				}
			}
			return false;
		}

		private void ScrollInto(RectTransform tab)
		{
			//IL_0010: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!((Object)(object)tab == (Object)null))
			{
				float x = _content.sizeDelta.x;
				Rect rect = _viewport.rect;
				float width = ((Rect)(ref rect)).width;
				if (!(x <= width))
				{
					_scroll.velocity = Vector2.zero;
					float x2 = tab.offsetMin.x;
					rect = tab.rect;
					float num = (x2 + ((Rect)(ref rect)).width * 0.5f - width * 0.5f) / (x - width);
					_scroll.horizontalNormalizedPosition = Mathf.Clamp01(num);
				}
			}
		}

		internal void Wheel(float delta)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			float x = _content.sizeDelta.x;
			Rect rect = _viewport.rect;
			float width = ((Rect)(ref rect)).width;
			if (!(x <= width))
			{
				float num = ModConfig.RailScrollSpeed?.Value ?? 2600f;
				ScrollRect scroll = _scroll;
				scroll.velocity += new Vector2(delta * num, 0f);
			}
		}

		internal bool ContainsScreenPoint(Vector2 screen)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return UiFactory.ContainsScreenPoint(_root, screen);
		}

		internal void Refresh()
		{
			//IL_007b: 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_00b4: 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_012c: 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)
			PerkState current = PerkState.Current;
			foreach (Row row in _rows)
			{
				bool flag = row.Tree.Key == _selected;
				int num = PointMath.SpentIn(current, row.Tree);
				int prestige = current.GetPrestige(row.Tree.Key);
				((Graphic)row.Background).color = (Color)(flag ? Palette.Panel2 : new Color(0f, 0f, 0f, 0f));
				((Graphic)row.Accent).color = (Color)(flag ? AccentFor(row.Tree.Kind) : new Color(0f, 0f, 0f, 0f));
				string text = ((prestige > 0) ? (row.Tree.Name + " ✦" + prestige) : row.Tree.Name);
				row.Name.text = (row.IsPinnedCopy ? ("★ " + text) : text);
				((Graphic)row.Name).color = (flag ? Palette.Ink : TintFor(row.Tree.Kind));
				row.Tally.text = ((num > 0) ? num.ToString() : "");
			}
		}

		private static Color AccentFor(TreeKind kind)
		{
			//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_0036: 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_0030: 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)
			return (Color)(kind switch
			{
				TreeKind.Sector => Palette.Frost, 
				TreeKind.New => Palette.Blood, 
				TreeKind.Style => Palette.Gold, 
				TreeKind.Fork => Palette.Gold, 
				TreeKind.Stub => Palette.InkDim, 
				_ => Palette.Ember, 
			});
		}

		private static Color TintFor(TreeKind kind)
		{
			//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_0030: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			switch (kind)
			{
			case TreeKind.Sector:
				return Palette.Frost;
			case TreeKind.New:
				return Palette.Gold;
			case TreeKind.Style:
			case TreeKind.Fork:
				return Palette.Ink2;
			case TreeKind.Stub:
				return Palette.InkDim;
			default:
				return Palette.Ink2;
			}
		}
	}
	internal static class TreeRelations
	{
		internal enum Relation
		{
			Self,
			Parent,
			Child,
			Overlap
		}

		internal struct Entry
		{
			internal PerkTree Tree;

			internal Relation Relation;
		}

		internal static List<Entry> FamilyOf(PerkTree tree, Func<PerkTree, bool> visible)
		{
			List<Entry> list = new List<Entry>();
			if (tree == null)
			{
				return list;
			}
			list.Add(new Entry
			{
				Tree = tree,
				Relation = Relation.Self
			});
			if (tree.RidesAnotherSkill && !string.IsNullOrEmpty(tree.RidesKey) && PerkDatabase.Trees.TryGetValue(tree.RidesKey, out var value))
			{
				Add(list, value, Relation.Parent, visible);
			}
			foreach (KeyValuePair<string, PerkTree> tree2 in PerkDatabase.Trees)
			{
				PerkTree value2 = tree2.Value;
				if (value2.RidesAnotherSkill && !(value2.RidesKey != tree.Key))
				{
					Add(list, value2, Relation.Child, visible);
				}
			}
			foreach (KeyValuePair<string, PerkTree> tree3 in PerkDatabase.Trees)
			{
				PerkTree value3 = tree3.Value;
				if (value3.IsSector && value3.Members.Contains(tree.Key))
				{
					Add(list, value3, Relation.Overlap, visible);
				}
			}
			if (tree.IsSector)
			{
				foreach (string member in tree.Members)
				{
					if (PerkDatabase.Trees.TryGetValue(member, out var value4))
					{
						Add(list, value4, Relation.Overlap, visible);
					}
				}
			}
			return list;
		}

		internal static bool HasFamily(PerkTree tree, Func<PerkTree, bool> visible)
		{
			return FamilyOf(tree, visible).Count > 1;
		}

		private static void Add(List<Entry> family, PerkTree tree, Relation relation, Func<PerkTree, bool> visible)
		{
			if (tree == null || (visible != null && !visible(tree)))
			{
				return;
			}
			foreach (Entry item in family)
			{
				if (item.Tree.Key == tree.Key)
				{
					return;
				}
			}
			family.Add(new Entry
			{
				Tree = tree,
				Relation = relation
			});
		}
	}
	internal sealed class TreeSubRail
	{
		private sealed class Row
		{
			internal TreeRelations.Entry Entry;

			internal RectTransform Root;

			internal Image Background;

			internal Text Name;
		}

		internal const float SubRailHeight = 34f;

		private const float TabPadding = 14f;

		private const int NameSize = 14;

		private readonly RectTransform _root;

		private readonly RectTransform _content;

		private readonly List<Row> _rows = new List<Row>();

		private string _selected;

		internal RectTransform Root => _root;

		internal event Action<PerkTree> TreeSelected;

		internal TreeSubRail(Transform parent)
		{
			//IL_0022: 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_0040: 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_0064: 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_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_00bd: Unknown result type (might be due to invalid IL or missing references)
			_root = UiFactory.Rect("subrail", parent, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, -34f), new Vector2(0f, 0f));
			UiFactory.Fill(_root, Palette.Ground);
			_content = UiFactory.Rect("content", (Transform)(object)_root, new Vector2(0f, 0f), new Vector2(0f, 1f), Vector2.zero, Vector2.zero);
			_content.pivot = new Vector2(0f, 0.5f);
		}

		internal void Show(PerkTree tree)
		{
			UiFactory.Clear((Transform)(object)_content);
			_rows.Clear();
			_selected = tree?.Key;
			if (tree == null)
			{
				return;
			}
			PerkState state = PerkState.Current;
			List<TreeRelations.Entry> list = TreeRelations.FamilyOf(tree, (PerkTree t) => SkillRail.Visible(t, state));
			float num = 14f;
			foreach (TreeRelations.Entry item in list)
			{
				float num2 = Mathf.Max(70f, (float)item.Tree.Name.Length * 7.6f + 28f);
				_rows.Add(BuildTab(item, num, num2));
				num += num2 + 4f;
			}
			Refresh();
		}

		private Row BuildTab(TreeRelations.Entry entry, float x, float width)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = UiFactory.Rect("sub_" + entry.Tree.Key, (Transform)(object)_content, new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(x, 4f), new Vector2(x + width, -4f));
			Button obj = UiFactory.Clickable(val, new Color(0f, 0f, 0f, 0f));
			PerkTree captured = entry.Tree;
			((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
			{
				this.TreeSelected?.Invoke(captured);
			});
			Text val2 = UiFactory.Label("name", (Transform)(object)val, Label(entry), 14, Palette.Ink2, (TextAnchor)4, Vector2.zero, Vector2.one, new Vector2(4f, 0f), new Vector2(-4f, 0f));
			val2.horizontalOverflow = (HorizontalWrapMode)1;
			return new Row
			{
				Entry = entry,
				Root = val,
				Name = val2,
				Background = ((Component)val).GetComponent<Image>()
			};
		}

		private static string Label(TreeRelations.Entry entry)
		{
			return entry.Relation switch
			{
				TreeRelations.Relation.Parent => "↰ " + entry.Tree.Name, 
				TreeRelations.Relation.Child => "· " + entry.Tree.Name, 
				TreeRelations.Relation.Overlap => "⇄ " + entry.Tree.Name, 
				_ => entry.Tree.Name, 
			};
		}

		internal void Refresh()
		{
			//IL_0056: 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_007b: 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)
			foreach (Row row in _rows)
			{
				bool flag = row.Entry.Tree.Key == _selected;
				((Graphic)row.Background).color = (Color)(flag ? Palette.Panel2 : new Color(0f, 0f, 0f, 0f));
				((Graphic)row.Name).color = (flag ? Palette.Ink : TintFor(row.Entry.Relation));
			}
		}

		private static Color TintFor(TreeRelations.Relation relation)
		{
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(relation switch
			{
				TreeRelations.Relation.Overlap => Palette.Frost, 
				TreeRelations.Relation.Parent => Palette.Gold, 
				_ => Palette.InkDim, 
			});
		}
	}
	internal static class UiFactory
	{
		internal const int UiLayer = 5;

		private static Sprite _fadeLeft;

		private static Sprite _fadeRight;

		internal static Font Font
		{
			get
			{
				GUIManager instance = GUIManager.Instance;
				if (instance == null)
				{
					return null;
				}
				return instance.AveriaSerifBold;
			}
		}

		internal static RectTransform Rect(string name, Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax)
		{
			//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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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)
			RectTransform component = new GameObject(name, new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			}.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = anchorMin;
			component.anchorMax = anchorMax;
			component.offsetMin = offsetMin;
			component.offsetMax = offsetMax;
			return component;
		}

		internal static RectTransform Point(string name, Transform parent, Vector2 anchor, Vector2 size)
		{
			//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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = new GameObject(name, new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			}.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = anchor;
			component.anchorMax = anchor;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = size;
			component.anchoredPosition = Vector2.zero;
			return component;
		}

		internal static Image Fill(RectTransform rt, Color colour)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Image obj = ((Component)rt).gameObject.AddComponent<Image>();
			((Graphic)obj).color = colour;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		internal static Text Label(string name, Transform parent, string content, int size, Color colour, TextAnchor align, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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_0008: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			Text obj = ((Component)Rect(name, parent, anchorMin, anchorMax, offsetMin, offsetMax)).gameObject.AddComponent<Text>();
			obj.font = Font;
			obj.fontSize = size;
			((Graphic)obj).color = colour;
			obj.alignment = align;
			obj.text = content;
			((Graphic)obj).raycastTarget = false;
			obj.horizontalOverflow = (HorizontalWrapMode)0;
			obj.verticalOverflow = (VerticalWrapMode)1;
			return obj;
		}

		internal static Button Clickable(RectTransform rt, Color idle)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			Image val = ((Component)rt).gameObject.GetComponent<Image>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)rt).gameObject.AddComponent<Image>();
			}
			((Graphic)val).color = idle;
			((Graphic)val).raycastTarget = true;
			Button obj = ((Component)rt).gameObject.AddComponent<Button>();
			((Selectable)obj).targetGraphic = (Graphic)(object)val;
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1.25f, 1.25f, 1.25f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.85f, 0.85f, 0.85f, 1f);
			((ColorBlock)(ref colors)).disabledColor = new Color(1f, 1f, 1f, 0.35f);
			((ColorBlock)(ref colors)).fadeDuration = 0.08f;
			((Selectable)obj).colors = colors;
			return obj;
		}

		internal static RectTransform Connector(Transform parent, Vector2 from, Vector2 to, float thickness, Color colour)
		{
			//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_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_004c: 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_0063: 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_0081: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = to - from;
			RectTransform component = new GameObject("edge", new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			}.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.pivot = new Vector2(0f, 0.5f);
			component.sizeDelta = new Vector2(((Vector2)(ref val)).magnitude, thickness);
			component.anchoredPosition = from;
			((Transform)component).localRotation = Quaternion.Euler(0f, 0f, Mathf.Atan2(val.y, val.x) * 57.29578f);
			Fill(component, colour);
			return component;
		}

		internal static Image EdgeFade(RectTransform rt, Color colour, bool opaqueAtLeft)
		{
			//IL_000c: 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)
			Image obj = ((Component)rt).gameObject.AddComponent<Image>();
			obj.sprite = FadeSprite(colour, opaqueAtLeft);
			((Graphic)obj).color = Color.white;
			obj.type = (Type)0;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		private static Sprite FadeSprite(Color colour, bool opaqueAtLeft)
		{
			//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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Sprite val = (opaqueAtLeft ? _fadeLeft : _fadeRight);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Texture2D val2 = new Texture2D(64, 1, (TextureFormat)4, false)
			{
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1
			};
			for (int i = 0; i < 64; i++)
			{
				float num = (float)i / 63f;
				float num2 = (opaqueAtLeft ? (1f - num) : num);
				num2 *= num2;
				val2.SetPixel(i, 0, new Color(colour.r, colour.g, colour.b, num2));
			}
			val2.Apply();
			Sprite val3 = Sprite.Create(val2, new Rect(0f, 0f, 64f, 1f), new Vector2(0.5f, 0.5f), 100f);
			if (opaqueAtLeft)
			{
				_fadeLeft = val3;
			}
			else
			{
				_fadeRight = val3;
			}
			return val3;
		}

		internal static Button HitLine(Transform parent, Vector2 from, Vector2 to, float thickness)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: 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)
			RectTransform obj = Connector(parent, from, to, thickness, new Color(0f, 0f, 0f, 0f));
			Image component = ((Component)obj).GetComponent<Image>();
			((Graphic)component).raycastTarget = true;
			Button obj2 = ((Component)obj).gameObject.AddComponent<Button>();
			((Selectable)obj2).targetGraphic = (Graphic)(object)component;
			((Selectable)obj2).transition = (Transition)0;
			return obj2;
		}

		internal static bool ContainsScreenPoint(RectTransform rt, Vector2 screen)
		{
			//IL_001c: 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)
			if ((Object)(object)rt == (Object)null)
			{
				return false;
			}
			Canvas componentInParent = ((Component)rt).GetComponentInParent<Canvas>();
			Camera val = (((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0) ? componentInParent.worldCamera : null);
			return RectTransformUtility.RectangleContainsScreenPoint(rt, screen, val);
		}

		internal static void Clear(Transform parent)
		{
			if (!((Object)(object)parent == (Object)null))
			{
				for (int num = parent.childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)parent.GetChild(num)).gameObject);
				}
			}
		}
	}
}
namespace Norntastic.Styles
{
	internal enum AttackStyle
	{
		Balanced,
		Wide,
		Narrow
	}
	internal struct StyleProfile
	{
		internal float PrimaryDamage;

		internal float SplashShare;

		internal float SplashRadius;

		internal float StaggerBonus;

		internal bool HasSplash
		{
			get
			{
				if (SplashShare > 0f)
				{
					return SplashRadius > 0f;
				}
				return false;
			}
		}

		internal static StyleProfile For(AttackStyle style, float skillLevel)
		{
			float num = Mathf.Clamp01(skillLevel / 100f);
			return style switch
			{
				AttackStyle.Wide => new StyleProfile
				{
					PrimaryDamage = 1f - 0.18f * num,
					SplashShare = 0.55f * num,
					SplashRadius = 1.2f + 2.3f * num,
					StaggerBonus = 0.35f * num
				}, 
				AttackStyle.Narrow => new StyleProfile
				{
					PrimaryDamage = 1f + 0.3f * num,
					SplashShare = 0f,
					SplashRadius = 0f,
					StaggerBonus = 0f
				}, 
				_ => new StyleProfile
				{
					PrimaryDamage = 1f + 0.1f * num,
					SplashShare = 0.2f * num,
					SplashRadius = 1.2f * num,
					StaggerBonus = 0.15f * num
				}, 
			};
		}
	}
	internal static class StyleDirector
	{
		internal static readonly string[] StyleableSkills = new string[9] { "swords", "knives", "clubs", "polearms", "spears", "axes", "unarmed", "bows", "crossbows" };

		internal static AttackStyle StyleFor(SkillType skill)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string skillKey = SkillKeys.Key(skill);
			AttackStyle style = PerkState.Current.GetStyle(skillKey);
			if (style != AttackStyle.Balanced)
			{
				return style;
			}
			return StyleTrees.StyleFrom(PerkState.Current, skillKey);
		}

		internal static void SetStyle(string skillKey, AttackStyle style)
		{
			PerkState.Current.SetStyle(skillKey, style);
			Log.Debug($"Style for {skillKey} set to {style} (override; the style tree still " + "decides when this is Balanced).");
		}

		internal static void Apply(Character target, HitData hit)
		{
			//IL_001a: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)target == (Object)null))
			{
				AttackStyle num = StyleFor(hit.m_skill);
				string skillKey = SkillKeys.Key(hit.m_skill);
				float skillLevel = ((Character)localPlayer).GetSkills().GetSkillLevel(hit.m_skill);
				float num2 = StyleTrees.CommitmentIn(PerkState.Current, skillKey);
				float num3 = ((num == AttackStyle.Balanced) ? 1f : Mathf.Max(0.25f, num2));
				StyleProfile profile = StyleProfile.For(num, skillLevel * num3);
				if (profile.PrimaryDamage != 1f)
				{
					hit.ApplyModifier(profile.PrimaryDamage);
				}
				if (profile.StaggerBonus > 0f)
				{
					hit.m_staggerMultiplier += profile.StaggerBonus;
				}
				if (profile.HasSplash)
				{
					Splash(target, hit, profile, localPlayer);
				}
			}
		}

		private static void Splash(Character target, HitData hit, StyleProfile profile, Player player)
		{
			//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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00ed: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: 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_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			float num = hit.GetTotalDamage() * profile.SplashShare;
			if (num <= 0f)
			{
				return;
			}
			List<Character> allCharacters = Character.GetAllCharacters();
			if (allCharacters == null)
			{
				return;
			}
			Vector3 position = ((Component)target).transform.position;
			float num2 = profile.SplashRadius * profile.SplashRadius;
			foreach (Character item in allCharacters)
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item == (Object)(object)target) && !item.IsPlayer() && !item.IsDead())
				{
					Vector3 val = ((Component)item).transform.position - position;
					if (!(((Vector3)(ref val)).sqrMagnitude > num2))
					{
						HitData val2 = new HitData();
						val2.m_damage.m_blunt = num * 0.34f;
						val2.m_damage.m_slash = num * 0.33f;
						val2.m_damage.m_pierce = num * 0.33f;
						val2.m_point = ((Component)item).transform.position;
						val = ((Component)item).transform.position - position;
						val2.m_dir = ((Vector3)(ref val)).normalized;
						val2.m_blockable = false;
						val2.m_dodgeable = false;
						val2.m_skill = (SkillType)0;
						val2.SetAttacker((Character)(object)player);
						item.Damage(val2);
					}
				}
			}
		}

		internal static bool IsStyleable(string skillKey)
		{
			string[] styleableSkills = StyleableSkills;
			for (int i = 0; i < styleableSkills.Length; i++)
			{
				if (string.Equals(styleableSkills[i], skillKey, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool TryParse(string text, out AttackStyle style)
		{
			switch ((text ?? "").ToLowerInvariant())
			{
			case "wide":
				style = AttackStyle.Wide;
				return true;
			case "narrow":
				style = AttackStyle.Narrow;
				return true;
			case "balanced":
				style = AttackStyle.Balanced;
				return true;
			default:
				style = AttackStyle.Balanced;
				return false;
			}
		}
	}
	internal static class StyleTrees
	{
		private static readonly Dictionary<string, string> TreeFor = new Dictionary<string, string>
		{
			{ "swords", "ysw" },
			{ "knives", "ykn" },
			{ "clubs", "ycl" },
			{ "polearms", "ypa" },
			{ "spears", "ysp" },
			{ "axes", "yax" },
			{ "unarmed", "yuw" },
			{ "bows", "ybw" },
			{ "crossbows", "ycb" }
		};

		private static readonly int[] WideNodes = new int[3] { 2, 3, 4 };

		private static readonly int[] NarrowNodes = new int[3] { 5, 6, 7 };

		internal static bool HasTree(string skillKey)
		{
			if (skillKey != null)
			{
				return TreeFor.ContainsKey(skillKey);
			}
			return false;
		}

		internal static string KeyFor(string skillKey)
		{
			if (skillKey == null || !TreeFor.TryGetValue(skillKey, out var value))
			{
				return null;
			}
			return value;
		}

		internal static AttackStyle StyleFrom(PerkState state, string skillKey)
		{
			string text = KeyFor(skillKey);
			if (text == null || state == null)
			{
				return AttackStyle.Balanced;
			}
			if (RanksIn(state, text, WideNodes) > 0)
			{
				return AttackStyle.Wide;
			}
			if (RanksIn(state, text, NarrowNodes) > 0)
			{
				return AttackStyle.Narrow;
			}
			return AttackStyle.Balanced;
		}

		internal static float CommitmentIn(PerkState state, string skillKey)
		{
			string text = KeyFor(skillKey);
			if (text == null || state == null)
			{
				return 0f;
			}
			int num = RanksIn(state, text, WideNodes);
			int num2 = RanksIn(state, text, NarrowNodes);
			int num3 = ((num > num2) ? num : num2);
			if (num3 <= 0)
			{
				return 0f;
			}
			float num4 = (float)num3 / 6f;
			if (!(num4 > 1f))
			{
				return num4;
			}
			return 1f;
		}

		private static int RanksIn(PerkState state, string prefix, int[] numbers)
		{
			int num = 0;
			foreach (int num2 in numbers)
			{
				num += state.GetRank(prefix + num2);
			}
			return num;
		}

		internal static IEnumerable<string> AllNodeIds()
		{
			foreach (KeyValuePair<string, string> pair in TreeFor)
			{
				for (int n = 1; n <= 8; n++)
				{
					yield return pair.Value + n;
				}
			}
		}
	}
}
namespace Norntastic.Safety
{
	internal static class DerivedSeal
	{
		private const string FileName = "dafini.norntastic.prefabs.txt";

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

		private static string _path;

		private static bool _loaded;

		private static bool _dirty;

		internal static readonly List<string> Missing = new List<string>();

		internal static int CountForTests => Known.Count;

		internal static void Load(string configDirectory)
		{
			if (_loaded)
			{
				return;
			}
			_loaded = true;
			try
			{
				_path = Path.Combine(configDirectory ?? ".", "dafini.norntastic.prefabs.txt");
				if (!File.Exists(_path))
				{
					return;
				}
				string[] array = File.ReadAllLines(_path);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (text.Length == 0 || text[0] == '#')
					{
						continue;
					}
					int num = text.LastIndexOf(' ');
					if (num > 0)
					{
						string key = text.Substring(0, num).Trim();
						if (int.TryParse(text.Substring(num + 1).Trim(), out var result))
						{
							Known[key] = result;
						}
					}
				}
				Log.Debug("Derived seal: " + Known.Count + " name(s) remembered.");
			}
			catch (Exception ex)
			{
				Log.Warn("Could not read the derived prefab seal: " + ex.Message);
			}
		}

		internal static bool WasMadeBefore(string name)
		{
			if (!string.IsNullOrEmpty(name))
			{
				return Known.ContainsKey(name);
			}
			return false;
		}

		internal static bool Record(string name, int hash)
		{
			if (string.IsNullOrEmpty(name))
			{
				return true;
			}
			if (Known.TryGetValue(name, out var value))
			{
				return value == hash;
			}
			Known[name] = hash;
			_dirty = true;
			return true;
		}

		internal static void Settle(ICollection<string> forgedThisSession)
		{
			Missing.Clear();
			if (forgedThisSession == null)
			{
				return;
			}
			foreach (string key in Known.Keys)
			{
				if (!forgedThisSession.Contains(key))
				{
					Missing.Add(key);
				}
			}
			if (Missing.Count > 0)
			{
				Log.Warn(Missing.Count + " prefab(s) this install has made before are not being made now: " + string.Join(", ", Missing.ToArray()));
				Log.Warn("Anything made from them is dormant, not destroyed - Valheim keeps world objects with unknown prefabs. They come back if whatever they were derived from comes back. Items in inventories and chests are the exception and do not survive a save.");
			}
			Write();
		}

		private static void Write()
		{
			if (!_dirty || string.IsNullOrEmpty(_path))
			{
				return;
			}
			try
			{
				List<string> list = new List<string> { "# Prefab names this install has generated, and their hashes.", "# Append-only. Written by Norntastic; deleting it only loses the warning." };
				List<string> list2 = new List<string>(Known.Keys);
				list2.Sort(StringComparer.Ordinal);
				foreach (string item in list2)
				{
					list.Add(item + " " + Known[item]);
				}
				File.WriteAllLines(_path, list.ToArray());
				_dirty = false;
			}
			catch (Exception ex)
			{
				Log.Warn("Could not write the derived prefab seal: " + ex.Message);
			}
		}

		internal static void ResetForTests()
		{
			Known.Clear();
			Missing.Clear();
			_loaded = false;
			_dirty = false;
			_path = null;
		}
	}
	internal static class PrefabRegistry
	{
		internal static readonly IReadOnlyDictionary<string, int> Sealed = new Dictionary<string, int>
		{
			{ "nsg_bakery_counter", 1615177184 },
			{ "nsg_raspberry_pie", -1178076178 },
			{ "nsg_wheat", 1295845642 },
			{ "nsg_sapling_wheat", 1219832243 },
			{ "nsg_pickable_wheat", -548530506 },
			{ "nsg_wild_wheat", -1375403029 },
			{ "nsg_sugarcane", 1240372990 },
			{ "nsg_sapling_sugarcane", -2034885825 },
			{ "nsg_pickable_sugarcane", 864553594 },
			{ "nsg_wild_sugarcane", 368389679 },
			{ "nsg_boarvine", -1943912369 },
			{ "nsg_sapling_boarvine", -1448417170 },
			{ "nsg_pickable_boarvine", -1776789649 },
			{ "nsg_wild_boarvine", -1138842508 },
			{ "nsg_beet", 790531171 },
			{ "nsg_beet_seed", 1265411611 },
			{ "nsg_sapling_beet", 264412282 },
			{ "nsg_pickable_beet", -1477530029 },
			{ "nsg_wild_beet", -1034093112 },
			{ "nsg_cucumber", 643349953 },
			{ "nsg_cucumber_seed", -212989403 },
			{ "nsg_sapling_cucumber", -1649228702 },
			{ "nsg_pickable_cucumber", -1039055215 },
			{ "nsg_wild_cucumber", -1724751020 },
			{ "nsg_cabbage", -2092085398 },
			{ "nsg_cabbage_seed", -134995586 },
			{ "nsg_sapling_cabbage", -64253191 },
			{ "nsg_pickable_cabbage", 351371414 },
			{ "nsg_wild_cabbage", 2016977073 },
			{ "nsg_pearl", -310387129 },
			{ "nsg_pearl_seed", 298584679 },
			{ "nsg_sapling_pearl", 1945577830 },
			{ "nsg_pickable_pearl", 136562287 },
			{ "nsg_wild_pearl", 1860622012 },
			{ "nsg_eggplant", 490147459 },
			{ "nsg_eggplant_seed", 520699875 },
			{ "nsg_sapling_eggplant", 703131508 },
			{ "nsg_pickable_eggplant", 151410155 },
			{ "nsg_wild_eggplant", -1282188386 },
			{ "nsg_station_deepfryer_stone", -619363646 },
			{ "nsg_station_deepfryer_bronze", 1312460595 },
			{ "nsg_station_deepfryer_iron", 149758315 },
			{ "nsg_station_deepfryer_nordicsteel", -789918229 },
			{ "nsg_station_cookingchute_stone", -576781569 },
			{ "nsg_station_cookingchute_bronze", -963729708 },
			{ "nsg_station_cookingchute_iron", 1740061666 },
			{ "nsg_station_cookingchute_nordicsteel", -898825876 },
			{ "nsg_station_cauldronsloop_stone", 1215800759 },
			{ "nsg_station_cauldronsloop_bronze", -727234112 },
			{ "nsg_station_cauldronsloop_iron", 999002486 },
			{ "nsg_station_cauldronsloop_nordicsteel", 665151656 },
			{ "nsg_station_meadmasher_stone", -985680979 },
			{ "nsg_station_meadmasher_bronze", 1619526924 },
			{ "nsg_station_meadmasher_iron", 1605777958 },
			{ "nsg_station_meadmasher_nordicsteel", -1528691388 },
			{ "nsg_station_hydroponics_stone", -247512120 },
			{ "nsg_station_hydroponics_bronze", -679666683 },
			{ "nsg_station_hydroponics_iron", 1076008389 },
			{ "nsg_station_hydroponics_nordicsteel", -844867507 },
			{ "nsg_station_fishfarm_stone", -435243522 },
			{ "nsg_station_fishfarm_bronze", 338280205 },
			{ "nsg_station_fishfarm_iron", 564982357 },
			{ "nsg_station_fishfarm_nordicsteel", 644672581 },
			{ "nsg_station_animalhovel_stone", 861772152 },
			{ "nsg_station_animalhovel_bronze", -341219625 },
			{ "nsg_station_animalhovel_iron", -943796641 },
			{ "nsg_station_animalhovel_nordicsteel", 351774671 },
			{ "nsg_salami", 416697630 },
			{ "nsg_baguette", -1586020524 },
			{ "nsg_carving_fork", -1645866242 },
			{ "nsg_chainmail_apron", -484975604 },
			{ "nsg_chainmail_spaghetti", 288079891 },
			{ "nsg_clown_boots", 1194448798 },
			{ "nsg_pie_counter", -268842416 },
			{ "nsg_nordic_steel", -64664674 },
			{ "nsg_smoke_hook", 1263951638 },
			{ "nsg_flour", -821358617 },
			{ "nsg_bread", 2075801041 },
			{ "nsg_sugar", 1094594779 },
			{ "nsg_pearl_oil", 34443386 },
			{ "nsg_red_brew_base", 1062572809 },
			{ "nsg_red_brew", 1818933387 },
			{ "nsg_gore_brew_base", 1642702925 },
			{ "nsg_gore_brew", 537374583 }
		};

		internal static readonly int[] Poison = new int[2] { 1332933305, -1334479845 };

		internal static bool IsPoison(int hash)
		{
			for (int i = 0; i < Poison.Length; i++)
			{
				if (Poison[i] == hash)
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class SafeMode
	{
		private static readonly List<string> Reasons = new List<string>();

		internal static bool Active { get; private set; }

		internal static IReadOnlyList<string> Why => Reasons;

		internal static void Trip(string reason)
		{
			if (!string.IsNullOrEmpty(reason) && !Reasons.Contains(reason))
			{
				Reasons.Add(reason);
			}
			if (!Active)
			{
				Active = true;
				Log.Error("=================================================================");
				Log.Error(" Norntastic has entered SAFE MODE.");
				Log.Error(" Perks and skills still work. Nothing will be built, converted,");
				Log.Error(" migrated or removed, and no custom item or station will be");
				Log.Error(" touched, until this is fixed.");
				Log.Error("=================================================================");
			}
		}

		internal static bool Allow(string operation)
		{
			if (!Active)
			{
				return true;
			}
			Log.Warn("Safe mode: refusing to " + operation + ".");
			return false;
		}

		internal static void ResetForTests()
		{
			Active = false;
			Reasons.Clear();
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	internal static class SafetyPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ZNetScene __instance)
		{
			try
			{
				WorldSafety.Verify((string name) => (Object)(object)__instance != (Object)null && (Object)(object)__instance.GetPrefab(name) != (Object)null, (string name) => StringExtensionMethods.GetStableHashCode(name), (string name) => PrefabForge.Has(name));
			}
			catch (Exception ex)
			{
				SafeMode.Trip("the world safety check threw: " + ex.Message);
				Log.Error("World safety check failed to complete: " + ex);
			}
		}
	}
	internal static class WorldSafety
	{
		private static bool _ran;

		internal static readonly List<string> Absent = new List<string>();

		internal static void Verify(Func<string, bool> isRegistered, Func<string, int> hashOf, Func<string, bool> wasForged = null)
		{
			if (_ran)
			{
				return;
			}
			_ran = true;
			Absent.Clear();
			if (isRegistered == null || hashOf == null)
			{
				SafeMode.Trip("world safety check could not run");
				return;
			}
			foreach (KeyValuePair<string, int> item in PrefabRegistry.Sealed)
			{
				int num = hashOf(item.Key);
				if (num != item.Value)
				{
					SafeMode.Trip("prefab '" + item.Key + "' hashes to " + num + " but " + item.Value + " was recorded - either the name changed (worlds holding the old one are now orphaned) or the offline hash function does not match the game's");
				}
				else if (PrefabRegistry.IsPoison(num))
				{
					SafeMode.Trip("prefab '" + item.Key + "' hashes to " + num + ", which Valheim deletes on sight - it must be renamed before it ever reaches a world");
				}
				else if ((wasForged == null || wasForged(item.Key)) && !isRegistered(item.Key))
				{
					Absent.Add(item.Key);
				}
			}
			if (Absent.Count > 0)
			{
				SafeMode.Trip(Absent.Count + " prefab(s) failed to register: " + string.Join(", ", Absent.ToArray()));
				Log.Error("Anything already built from these is dormant, not lost - Valheim keeps ZDOs with unknown prefabs and reloads them when the prefab comes back. Do not remove the mod to 'clean up'.");
			}
			if (!SafeMode.Active)
			{
				Log.Info("World safety: " + PrefabRegistry.Sealed.Count + " prefab(s) verified, hashes stable.");
			}
		}

		internal static void ResetForTests()
		{
			_ran = false;
			Absent.Clear();
		}
	}
}
namespace Norntastic.Progression
{
	internal static class Brewing
	{
		[HarmonyPatch(typeof(Fermenter), "AddItem")]
		internal static class AddItemPatch
		{
			[HarmonyPostfix]
			private static void Postfix(Humanoid user, bool __result)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				if (__result && IsLocal(user) && CustomSkills.Registered)
				{
					Player val = (Player)(object)((user is Player) ? user : null);
					if (!((Object)(object)val == (Object)null))
					{
						((Character)val).RaiseSkill(CustomSkills.Brewing, 1.5f);
						TriggerBus.Fire(TriggerKind.Brewed);
						Log.Debug("Brewing raised: fermenter loaded.");
					}
				}
			}
		}

		[HarmonyPatch(typeof(Fermenter), "Interact")]
		internal static class InteractPatch
		{
			[HarmonyPrefix]
			private static void Prefix(Fermenter __instance, out bool __state)
			{
				__state = HasContent(__instance);
			}

			[HarmonyPostfix]
			private static void Postfix(Fermenter __instance, Humanoid user, bool __result, bool __state)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				if (__result && IsLocal(user) && CustomSkills.Registered && __state && !HasContent(__instance))
				{
					Player val = (Player)(object)((user is Player) ? user : null);
					if (!((Object)(object)val == (Object)null))
					{
						((Character)val).RaiseSkill(CustomSkills.Brewing, 5f);
						TriggerBus.Fire(TriggerKind.Brewed);
						Log.Debug("Brewing raised: fermenter tapped.");
					}
				}
			}

			private static bool HasContent(Fermenter fermenter)
			{
				if ((Object)(object)fermenter == (Object)null)
				{
					return false;
				}
				return !string.IsNullOrEmpty(Traverse.Create((object)fermenter).Method("GetContentName", Array.Empty<object>()).GetValue<string>());
			}
		}

		[HarmonyPatch(typeof(Player), "ConsumeItem")]
		internal static class ConsumePatch
		{
			[HarmonyPostfix]
			private static void Postfix(Player __instance, ItemData item, bool __result)
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				if (__result && !((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && CustomSkills.Registered && item?.m_shared != null && ModConfig.IsIntoxicantName(item.m_shared.m_name))
				{
					((Character)__instance).RaiseSkill(CustomSkills.Brewing, 0.8f);
					TriggerBus.Fire(TriggerKind.Drank);
				}
			}
		}

		internal const float LoadGain = 1.5f;

		internal const float TapGain = 5f;

		internal const float DrinkGain = 0.8f;

		private static bool IsLocal(Humanoid user)
		{
			if ((Object)(object)user != (Object)null)
			{
				return (Object)(object)user == (Object)(object)Player.m_localPlayer;
			}
			return false;
		}
	}
	internal static class CustomSkills
	{
		internal const string ArmorId = "dafini.norntastic.armor";

		internal const string UnarmoredId = "dafini.norntastic.unarmored";

		internal const string BrawlerId = "dafini.norntastic.tavernbrawler";

		internal const string TorchId = "dafini.norntastic.torch";

		internal const string ShieldId = "dafini.norntastic.shield";

		internal const string DualWieldId = "dafini.norntastic.dualwield";

		internal const string IdolUsageId = "dafini.norntastic.idolusage";

		internal const string BrewingId = "dafini.norntastic.brewing";

		internal const string HusbandryId = "dafini.norntastic.husbandry";

		internal const string AutomationistId = "dafini.norntastic.automationist";

		internal const string DeepFryId = "dafini.norntastic.deepfry";

		internal const string SmokemasterId = "dafini.norntastic.smokemaster";

		internal const string OneHandId = "dafini.norntastic.onehand";

		internal const string TwoHandedId = "dafini.norntastic.twohanded";

		internal const string SwordAndBoardId = "dafini.norntastic.swordandboard";

		internal static SkillType Armor { get; private set; }

		internal static SkillType Unarmored { get; private set; }

		internal static SkillType Brawler { get; private set; }

		internal static SkillType Torch { get; private set; }

		internal static SkillType Shield { get; private set; }

		internal static SkillType DualWield { get; private set; }

		internal static SkillType IdolUsage { get; private set; }

		internal static SkillType Brewing { get; private set; }

		internal static SkillType Husbandry { get; private set; }

		internal static SkillType Automationist { get; private set; }

		internal static SkillType DeepFry { get; private set; }

		internal static SkillType Smokemaster { get; private set; }

		internal static SkillType OneHand { get; private set; }

		internal static SkillType TwoHanded { get; private set; }

		internal static SkillType SwordAndBoard { get; private set; }

		internal static bool Registered { get; private set; }

		internal static SkillType TypeOf(string identifier)
		{
			return (SkillType)Math.Abs(StringExtensionMethods.GetStableHashCode(identifier));
		}

		internal static void Register()
		{
			//IL_0005: 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_0023: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_008c: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: 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_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			Armor = TypeOf("dafini.norntastic.armor");
			Unarmored = TypeOf("dafini.norntastic.unarmored");
			Brawler = TypeOf("dafini.norntastic.tavernbrawler");
			Torch = TypeOf("dafini.norntastic.torch");
			Shield = TypeOf("dafini.norntastic.shield");
			DualWield = TypeOf("dafini.norntastic.dualwield");
			IdolUsage = TypeOf("dafini.norntastic.idolusage");
			Brewing = TypeOf("dafini.norntastic.brewing");
			Husbandry = TypeOf("dafini.norntastic.husbandry");
			Automationist = TypeOf("dafini.norntastic.automationist");
			DeepFry = TypeOf("dafini.norntastic.deepfry");
			Smokemaster = TypeOf("dafini.norntastic.smokemaster");
			OneHand = TypeOf("dafini.norntastic.onehand");
			TwoHanded = TypeOf("dafini.norntastic.twohanded");
			SwordAndBoard = TypeOf("dafini.norntastic.swordandboard");
			SkillKeys.RegisterCustomKey(Armor, "armor");
			SkillKeys.RegisterCustomKey(Unarmored, "unarmored");
			SkillKeys.RegisterCustomKey(Brawler, "brawler");
			SkillKeys.RegisterCustomKey(Torch, "torch");
			SkillKeys.RegisterCustomKey(Shield, "shield");
			SkillKeys.RegisterCustomKey(DualWield, "dualwield");
			SkillKeys.RegisterCustomKey(IdolUsage, "idolusage");
			SkillKeys.RegisterCustomKey(Brewing, "brewing");
			SkillKeys.RegisterCustomKey(Husbandry, "husbandry");
			SkillKeys.RegisterCustomKey(Automationist, "automationist");
			SkillKeys.RegisterCustomKey(DeepFry, "deepfry");
			SkillKeys.RegisterCustomKey(Smokemaster, "smokemaster");
			SkillKeys.RegisterCustomKey(OneHand, "onehand");
			SkillKeys.RegisterCustomKey(TwoHanded, "twohanded");
			SkillKeys.RegisterCustomKey(SwordAndBoard, "swordandboard");
			try
			{
				Add("dafini.norntastic.armor", "Armor", "Rises when armour absorbs a blow. The straightforward half of the pair.");
				Add("dafini.norntastic.unarmored", "Unarmored", "Rises only when you take a hit with every armour slot empty. Brutal to start, and it accelerates the further you get.");
				Add("dafini.norntastic.tavernbrawler", "Tavern Brawler", "Improvised weapons out of your own inventory.");
				Add("dafini.norntastic.automationist", "Automationist", "Rises every time a station you built finishes a batch - including the batches it finished while you were somewhere else.");
				Add("dafini.norntastic.deepfry", "Deep Fry Tactician", "Rises on frying. What comes out of a fryer is always the next kind of the thing that went in.");
				Add("dafini.norntastic.smokemaster", "Smokemaster", "Rises on smoking meat. Patience, applied to preservation.");
				Add("dafini.norntastic.torch", "Torch", "Fighting with fire in your hand, and what the flame does to what it touches.");
				Add("dafini.norntastic.shield", "Shield", "The shield as a weapon as much as a wall. Blocking still trains Blocking; this trains what you do next.");
				Add("dafini.norntastic.dualwield", "Dual Wield", "Making the offhand earn its keep - a second weapon, a shield swung like one, or a torch. Rises every time the offhand contributes to a blow.");
				Add("dafini.norntastic.idolusage", "Idol Usage", "The powers you attune to at a shrine, and getting better at spending them. Rises when you use one, and slowly while one is running.");
				Add("dafini.norntastic.brewing", "Brewing", "The fermenter and what comes out of it. Rises a little for loading a barrel and more for tapping one days later. The meadery - bulk, cellars, recipe priority - is the outer wing of this tree, not a second skill competing for the same taps.");
				Add("dafini.norntastic.husbandry", "Husbandry", "Taming and breeding. Rises when a creature finally trusts you, and more when two of them make a third.");
				Add("dafini.norntastic.onehand", "One Hand", "One weapon, nothing in the other hand. The fast, mobile grip - it gives up a shield and a two-hander's reach for the freedom to move.");
				Add("dafini.norntastic.twohanded", "Two Handed", "Both hands on the haft. Reach, stagger and commitment: the swing you start is the swing you finish.");
				Add("dafini.norntastic.swordandboard", "Sword and Board", "A weapon and a shield. Blocking still trains Blocking; this trains fighting from behind one.");
				Registered = true;
				Log.Info("Registered 12 custom skills: Armor, Unarmored, Tavern Brawler, Torch, Shield, Dual Wield, Idol Usage, Brewing, Husbandry, One Hand, Two Handed, Sword and Board.");
			}
			catch (Exception ex)
			{
				Log.Error("Could not register custom skills: " + ex.Message);
				Log.Error("The custom skills will not appear. Everything else still works.");
			}
		}

		private static void Add(string identifier, string name, string description)
		{
			//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_0011: 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_002f: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			SkillManager.Instance.AddSkill(new SkillConfig
			{
				Identifier = identifier,
				Name = name,
				Description = description,
				IncreaseStep = 1f
			});
		}
	}
	[HarmonyPatch(typeof(Player), "OnDamaged", new Type[] { typeof(HitData) })]
	internal static class DamageTakenPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Player __instance, HitData hit)
		{
			//IL_0040: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || hit == null || !CustomSkills.Registered)
			{
				return;
			}
			float totalDamage = hit.GetTotalDamage();
			if (totalDamage <= 0f)
			{
				return;
			}
			if (IsUnarmored(__instance))
			{
				float skillLevel = ((Character)__instance).GetSkills().GetSkillLevel(CustomSkills.Unarmored);
				float num = SkillCurves.UnarmoredGain(totalDamage, skillLevel);
				if (num > 0f)
				{
					((Character)__instance).RaiseSkill(CustomSkills.Unarmored, num);
					Log.Debug($"Unarmored +{num:0.00} from {totalDamage:0.0} damage at level {skillLevel:0}.");
				}
				return;
			}
			float bodyArmor = ((Character)__instance).GetBodyArmor();
			if (!(bodyArmor <= 0f))
			{
				float num2 = Mathf.Min(bodyArmor, totalDamage + bodyArmor);
				float num3 = SkillCurves.ArmorGain(num2);
				if (num3 > 0f)
				{
					((Character)__instance).RaiseSkill(CustomSkills.Armor, num3);
					Log.Debug($"Armor +{num3:0.00} from {num2:0.0} absorbed.");
				}
			}
		}

		private static bool IsUnarmored(Player player)
		{
			return Equipment.IsUnarmored(player);
		}
	}
	internal static class GuardianPowers
	{
		[HarmonyPatch(typeof(Player), "ActivateGuardianPower")]
		internal static class ActivatePatch
		{
			[HarmonyPostfix]
			private static void Postfix(Player __instance, bool __result)
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				if (__result && !((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					PerkState current = PerkState.Current;
					if (CustomSkills.Registered)
					{
						((Character)__instance).RaiseSkill(CustomSkills.IdolUsage, 3f);
					}
					ExtendDuration(__instance, current);
					ShortenCooldown(__instance, current);
					TriggerBus.Fire(TriggerKind.PowerUsed);
					Log.Debug("Guardian power used; Idol Usage raised.");
				}
			}
		}

		private static float _activeFor;

		internal static void Reset()
		{
			_activeFor = 0f;
		}

		internal static bool IsActive(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			return (Object)(object)Traverse.Create((object)player).Field<StatusEffect>("m_guardianSE").Value != (Object)null;
		}

		internal static void Tick(Player player, float dt)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || !CustomSkills.Registered)
			{
				return;
			}
			if (!IsActive(player))
			{
				_activeFor = 0f;
				return;
			}
			_activeFor += dt;
			if (!(_activeFor < 1f))
			{
				_activeFor = 0f;
				((Character)player).RaiseSkill(CustomSkills.IdolUsage, 0.08f);
			}
		}

		private static void ExtendDuration(Player player, PerkState state)
		{
			float num = DurationBonus(state);
			if (!(num <= 0f))
			{
				StatusEffect value = Traverse.Create((object)player).Field<StatusEffect>("m_guardianSE").Value;
				if (!((Object)(object)value == (Object)null) && !(value.m_ttl <= 0f))
				{
					value.m_ttl *= 1f + num / 100f;
				}
			}
		}

		private static void ShortenCooldown(Player player, PerkState state)
		{
			float num = CooldownBonus(state);
			if (!(num <= 0f))
			{
				float num2 = Mathf.Clamp01(1f - num / 100f);
				player.m_guardianPowerCooldown *= num2;
			}
		}

		internal static float DurationBonus(PerkState state)
		{
			if (state == null)
			{
				return 0f;
			}
			return 12f * (float)state.GetRank("id3") + 20f * (float)state.GetRank("id7");
		}

		internal static float CooldownBonus(PerkState state)
		{
			if (state == null)
			{
				return 0f;
			}
			float num = 8f * (float)state.GetRank("id2") + 12f * (float)state.GetRank("id6");
			float num2 = ((ModConfig.IdolCooldownCap != null) ? ModConfig.IdolCooldownCap.Value : 45f);
			return Mathf.Min(num, num2);
		}
	}
	internal static class Husbandry
	{
		[HarmonyPatch(typeof(Tameable), "Tame")]
		internal static class TamePatch
		{
			[HarmonyPostfix]
			private static void Postfix(Tameable __instance)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				if (CustomSkills.Registered)
				{
					Player val = Credited((Component)(object)__instance);
					if (!((Object)(object)val == (Object)null))
					{
						((Character)val).RaiseSkill(CustomSkills.Husbandry, 12f);
						TriggerBus.Fire(TriggerKind.Tamed);
						Log.Debug("Husbandry: something was tamed nearby.");
					}
				}
			}
		}

		[HarmonyPatch(typeof(Procreation), "ResetPregnancy")]
		internal static class BreedPatch
		{
			[HarmonyPostfix]
			private static void Postfix(Procreation __instance)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				if (CustomSkills.Registered)
				{
					Player val = Credited((Component)(object)__instance);
					if (!((Object)(object)val == (Object)null))
					{
						((Character)val).RaiseSkill(CustomSkills.Husbandry, 3f);
						TriggerBus.Fire(TriggerKind.Bred);
						Log.Debug("Husbandry: something was born nearby.");
					}
				}
			}
		}

		internal const float TameGain = 12f;

		internal const float BreedGain = 3f;

		internal const float CreditRange = 30f;

		private static Player Credited(Component thing)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)thing == (Object)null)
			{
				return null;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return null;
			}
			if (!((Object)(object)Player.GetClosestPlayer(thing.transform.position, 30f) == (Object)(object)localPlayer))
			{
				return null;
			}
			return localPlayer;
		}
	}
	[HarmonyPatch(typeof(Character), "Damage")]
	internal static class OnHitDispatcher
	{
		[HarmonyPrefix]
		[HarmonyPriority(400)]
		private static void Prefix(Character __instance, HitData hit)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			if (hit == null || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			PerkState current = PerkState.Current;
			if (!current.Ready)
			{
				return;
			}
			if ((Object)(object)__instance == (Object)(object)localPlayer)
			{
				if (!IncomingDamage.ForgiveShortFall(hit))
				{
					IncomingDamage.Apply(localPlayer, hit);
					StrikeRiders.Incoming(hit);
				}
			}
			else if (!((Object)(object)hit.GetAttacker() != (Object)(object)localPlayer) && (int)hit.m_skill != 0)
			{
				int position = ComboCounter.Advance(hit.m_skill);
				StyleDirector.Apply(__instance, hit);
				AttackStringDriver.Apply(localPlayer, hit, position);
				float extraUnblockableChance = HitModifierDriver.Apply(__instance, hit, current);
				StrikeRiders.Outgoing(hit, extraUnblockableChance);
				GripTraining.OnHit(localPlayer, hit);
				TriggerBus.Fire(TriggerKind.Hit, new TriggerContext
				{
					Target = __instance,
					Hit = hit,
					Skill = hit.m_skill
				});
				if (__instance.IsStaggering())
				{
					TriggerBus.Fire(TriggerKind.Stagger, new TriggerContext
					{
						Target = __instance,
						Hit = hit,
						Skill = hit.m_skill
					});
				}
				TorchAndShieldSkills.OnHitWith(localPlayer, ((Humanoid)localPlayer).GetCurrentWeapon(), hit.GetTotalDamage());
				OffhandStrike.OnMainHandHit(localPlayer, __instance, hit);
				Afflictions.FromHit(__instance, hit, current);
				PerkHandlerRegistry.Hit(__instance, hit, current);
				Splash.FromHit(localPlayer, __instance, hit, current);
			}
		}
	}
	internal static class SkillCurves
	{
		internal static float UnarmoredRate(float level)
		{
			if (level < 25f)
			{
				return 0.25f;
			}
			if (level < 50f)
			{
				return 1f;
			}
			if (level < 75f)
			{
				return 1.5f;
			}
			return 2.5f;
		}

		internal static float ArmorGain(float absorbed)
		{
			if (absorbed <= 0f)
			{
				return 0f;
			}
			return Mathf.Clamp(Mathf.Sqrt(absorbed) * 0.12f, 0.02f, 1.5f);
		}

		internal static float UnarmoredGain(float damageTaken, float level)
		{
			if (damageTaken <= 0f)
			{
				return 0f;
			}
			return Mathf.Clamp(Mathf.Sqrt(damageTaken) * 0.14f, 0.02f, 1.5f) * UnarmoredRate(level);
		}
	}
	internal static class TorchAndShieldSkills
	{
		[HarmonyPatch(typeof(Humanoid), "BlockAttack", new Type[]
		{
			typeof(HitData),
			typeof(Character)
		})]
		internal static class BlockAttackPatch
		{
			[HarmonyPostfix]
			private static void Postfix(Humanoid __instance, HitData hit, bool __result)
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				if (!__result || hit == null || !CustomSkills.Registered)
				{
					return;
				}
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val != (Object)(object)Player.m_localPlayer))
				{
					float totalDamage = hit.GetTotalDamage();
					if (!(totalDamage <= 0f))
					{
						((Character)val).RaiseSkill(CustomSkills.Shield, Mathf.Clamp(Mathf.Sqrt(totalDamage) * 0.1f, 0.02f, 1.5f));
						Log.Debug($"Shield skill from blocking {totalDamage:0.0}.");
					}
				}
			}
		}

		internal static void OnHitWith(Player player, ItemData weapon, float damage)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null) && weapon?.m_shared != null && CustomSkills.Registered && (int)weapon.m_shared.m_itemType == 15)
			{
				((Character)player).RaiseSkill(CustomSkills.Torch, Mathf.Clamp(damage * 0.04f, 0.05f, 1.2f));
			}
		}
	}
	internal static class TriggerSources
	{
		[HarmonyPatch(typeof(Humanoid), "BlockAttack", new Type[]
		{
			typeof(HitData),
			typeof(Character)
		})]
		private static class BlockPatch
		{
			private static void Postfix(Humanoid __instance, HitData hit)
			{
				if (IsLocal((Character)(object)__instance) && hit != null)
				{
					TriggerBus.Fire(TriggerKind.Blocked);
					Player val = (Player)(object)((__instance is Player) ? __instance : null);
					if ((Object)(object)val != (Object)null && ((Character)val).IsBlocking() && IsTimedBlock(val))
					{
						TriggerBus.Fire(TriggerKind.Parried);
					}
				}
			}

			private static bool IsTimedBlock(Player player)
			{
				float value = Traverse.Create((object)player).Field<float>("m_blockTimer").Value;
				if (value >= 0f)
				{
					return value <= 0.25f;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Player), "OnDamaged", new Type[] { typeof(HitData) })]
		private static class TookDamagePatch
		{
			private static void Postfix(Player __instance, HitData hit)
			{
				if (IsLocal((Character)(object)__instance) && hit != null && !(hit.GetTotalDamage() <= 0f))
				{
					TriggerBus.Fire(TriggerKind.TookDamage);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Dodge")]
		private static class DodgePatch
		{
			private static void Postfix(Player __instance)
			{
				if (IsLocal((Character)(object)__instance))
				{
					TriggerBus.Fire(TriggerKind.Dodged);
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Jump")]
		private static class JumpPatch
		{
			private static void Postfix(Character __instance)
			{
				if (IsLocal(__instance))
				{
					TriggerBus.Fire(TriggerKind.Jumped);
				}
			}
		}

		[HarmonyPatch(typeof(TreeBase), "Damage")]
		private static class TreeBasePatch
		{
			private static void Prefix(TreeBase __instance, HitData hit, out float __state)
			{
				__state = (((Object)(object)__instance != (Object)null) ? __instance.m_health : 0f);
				if (hit != null && (Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
				{
					Yields.Open(Yields.Source.Tree);
				}
			}

			private static void Postfix(TreeBase __instance, HitData hit, float __state)
			{
				Yields.Close();
				if (!((Object)(object)__instance == (Object)null) && hit != null && !((Object)(object)hit.GetAttacker() != (Object)(object)Player.m_localPlayer) && __state > 0f && __instance.m_health <= 0f)
				{
					TriggerBus.Fire(TriggerKind.TreeFelled);
				}
			}
		}

		[HarmonyPatch(typeof(TreeLog), "Damage")]
		private static class TreeLogPatch
		{
			private static void Prefix(TreeLog __instance, HitData hit, out float __state)
			{
				__state = (((Object)(object)__instance != (Object)null) ? __instance.m_health : 0f);
				if (hit != null && (Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
				{
					Yields.Open(Yields.Source.Tree);
				}
			}

			private static void Postfix(TreeLog __instance, HitData hit, float __state)
			{
				Yields.Close();
				if (!((Object)(object)__instance == (Object)null) && hit != null && !((Object)(object)hit.GetAttacker() != (Object)(object)Player.m_localPlayer) && __state > 0f && __instance.m_health <= 0f)
				{
					TriggerBus.Fire(TriggerKind.TreeFelled);
				}
			}
		}

		[HarmonyPatch(typeof(MineRock5), "Damage")]
		private static class MineRockPatch
		{
			private static void Prefix(HitData hit)
			{
				if (hit != null && (Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
				{
					Yields.Open(Yields.Source.Ore);
				}
			}

			private static void Postfix(MineRock5 __instance, HitData hit)
			{
				Yields.Close();
				if (!((Object)(object)__instance == (Object)null) && hit != null && !((Object)(object)hit.GetAttacker() != (Object)(object)Player.m_localPlayer) && Traverse.Create((object)__instance).Method("AllDestroyed", Array.Empty<object>()).GetValue<bool>())
				{
					TriggerBus.Fire(TriggerKind.VeinMined);
				}
			}
		}

		[HarmonyPatch(typeof(Pickable), "Interact")]
		private static class HarvestPatch
		{
			private static void Prefix(Humanoid character)
			{
				if (IsLocal((Character)(object)character))
				{
					Yields.Open(Yields.Source.Forage);
				}
			}

			private static void Postfix(Pickable __instance, Humanoid character, bool __result)
			{
				Yields.Close();
				if (__result && IsLocal((Character)(object)character))
				{
					TriggerBus.Fire(TriggerKind.Harvested);
					Yields.OnPicked((Player)(object)((character is Player) ? character : null), __instance);
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		private static class CraftPatch
		{
			private static void Postfix(Player player)
			{
				if (IsLocal((Character)(object)player))
				{
					TriggerBus.Fire(TriggerKind.Crafted);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "PlacePiece")]
		private static class BuildPatch
		{
			private static void Postfix(Player __instance)
			{
				if (IsLocal((Character)(object)__instance))
				{
					TriggerBus.Fire(TriggerKind.Built);
				}
			}
		}

		[HarmonyPatch(typeof(Character), "OnDeath")]
		private static class DeathPatch
		{
			private static void Prefix(Character __instance)
			{
				//IL_0066: 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)
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)__instance == (Object)null) && !((Object)(object)localPlayer == (Object)null) && !((Object)(object)__instance == (Object)(object)localPlayer))
				{
					HitData value = Traverse.Create((object)__instance).Field<HitData>("m_lastHit").Value;
					if (value != null && !((Object)(object)value.GetAttacker() != (Object)(object)localPlayer))
					{
						TriggerBus.Fire(TriggerKind.Kill, new TriggerContext
						{
							Target = __instance,
							Hit = value,
							Skill = value.m_skill
						});
					}
				}
			}
		}

		private const float BlockingWindowSeconds = 0.25f;

		private static bool IsLocal(Character character)
		{
			if ((Object)(object)character != (Object)null)
			{
				return (Object)(object)character == (Object)(object)Player.m_localPlayer;
			}
			return false;
		}
	}
	internal static class Yields
	{
		internal enum Source
		{
			None,
			Tree,
			Ore,
			Forage,
			Kill
		}

		[HarmonyPatch(typeof(DropTable), "GetDropList", new Type[] { })]
		internal static class DropListPatch
		{
			[HarmonyPostfix]
			private static void Postfix(List<GameObject> __result)
			{
				if (__result == null || __result.Count == 0 || Active == Source.None)
				{
					return;
				}
				float num = ChanceFor(Active);
				if (num <= 0f)
				{
					return;
				}
				int count = __result.Count;
				for (int i = 0; i < count; i++)
				{
					int num2 = ExtraFor(num);
					for (int j = 0; j < num2; j++)
					{
						__result.Add(__result[i]);
						GrantedThisSession++;
					}
				}
			}
		}

		[HarmonyPatch(typeof(CharacterDrop), "GenerateDropList")]
		internal static class KillDropPatch
		{
			[HarmonyPostfix]
			private static void Postfix(List<KeyValuePair<GameObject, int>> __result)
			{
				if (__result == null || __result.Count == 0 || !TriggerBus.Within(TriggerKind.Kill, 1f))
				{
					return;
				}
				float num = EffectAggregator.Pct(EffectKind.YieldKillPct);
				if (num <= 0f)
				{
					return;
				}
				for (int i = 0; i < __result.Count; i++)
				{
					KeyValuePair<GameObject, int> keyValuePair = __result[i];
					if (!((Object)(object)keyValuePair.Key == (Object)null) && keyValuePair.Value > 0)
					{
						int num2 = 0;
						for (int j = 0; j < keyValuePair.Value; j++)
						{
							num2 += ExtraFor(num);
						}
						if (num2 != 0)
						{
							__result[i] = new KeyValuePair<GameObject, int>(keyValuePair.Key, keyValuePair.Value + num2);
							GrantedThisSession += num2;
						}
					}
				}
			}
		}

		private static Source _open;

		private static int _openedOnFrame = -1;

		internal static Source Active
		{
			get
			{
				if (_openedOnFrame != Time.frameCount)
				{
					return Source.None;
				}
				return _open;
			}
		}

		internal static int GrantedThisSession { get; private set; }

		internal static void Open(Source source)
		{
			_open = source;
			_openedOnFrame = Time.frameCount;
		}

		internal static void Close()
		{
			_open = Source.None;
			_openedOnFrame = -1;
		}

		private static float ChanceFor(Source source)
		{
			return source switch
			{
				Source.Tree => EffectAggregator.Pct(EffectKind.YieldTreePct), 
				Source.Ore => EffectAggregator.Pct(EffectKind.YieldOrePct), 
				Source.Forage => EffectAggregator.Pct(EffectKind.YieldForagePct), 
				Source.Kill => EffectAggregator.Pct(EffectKind.YieldKillPct), 
				_ => 0f, 
			};
		}

		internal static int ExtraFor(float chance)
		{
			if (chance <= 0f)
			{
				return 0;
			}
			int num = (int)(chance / 100f);
			float num2 = chance - (float)num * 100f;
			if (num2 > 0f && Random.Range(0f, 100f) < num2)
			{
				num++;
			}
			return num;
		}

		internal static void OnPicked(Player player, Pickable pickable)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)pickable == (Object)null || (Object)(object)pickable.m_itemPrefab == (Object)null)
			{
				return;
			}
			float num = EffectAggregator.Pct(EffectKind.YieldForagePct);
			if (num <= 0f)
			{
				return;
			}
			int num2 = ((pickable.m_amount <= 0) ? 1 : pickable.m_amount);
			int num3 = 0;
			for (int i = 0; i < num2; i++)
			{
				num3 += ExtraFor(num);
			}
			if (num3 != 0)
			{
				Inventory inventory = ((Humanoid)player).GetInventory();
				if (inventory != null && inventory.AddItem(pickable.m_itemPrefab, num3))
				{
					GrantedThisSession += num3;
					Log.Debug($"Forage yield: {num3} extra from {((Object)pickable.m_itemPrefab).name}.");
				}
			}
		}
	}
}
namespace Norntastic.Patches
{
	internal static class PlayerPersistencePatch
	{
		[HarmonyPatch(typeof(Player), "Save")]
		internal static class SavePatch
		{
			[HarmonyPrefix]
			[HarmonyPriority(0)]
			private static void Prefix(Player __instance)
			{
				if ((Object)(object)__instance == (Object)null)
				{
					return;
				}
				if (IsCharacterPreview())
				{
					Log.Debug("Skipping perk save: character preview, not a live player.");
				}
				else if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					PerkState current = PerkState.Current;
					if (!current.Ready)
					{
						Log.Debug("Skipping perk save: state not initialised yet.");
						return;
					}
					current.RatchetAll(((Character)__instance).GetSkills());
					PerkStateStore.SaveInto(__instance, current);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		internal static class LoadPatch
		{
			[HarmonyPostfix]
			private static void Postfix(Player __instance)
			{
				if (!((Object)(object)__instance == (Object)null) && !IsCharacterPreview())
				{
					PerkEffectDriver.OnCharacterChanged();
					if (PerkStateStore.TryLoadInto(__instance, out var state))
					{
						PerkState.Replace(state);
						state.RatchetAll(((Character)__instance).GetSkills());
						Log.Info($"Loaded perks: {state.Allocated.Count} allocated node(s), " + $"{PointMath.Earned(state)} points earned, " + $"{state.RespecPoints} respec point(s).");
						PerkEvents.RaiseAllocationChanged();
					}
					else
					{
						PerkState perkState = new PerkState();
						perkState.SeedFrom(((Character)__instance).GetSkills());
						PerkState.Replace(perkState);
						PerkEvents.RaiseAllocationChanged();
					}
				}
			}
		}

		private static bool IsCharacterPreview()
		{
			if ((Object)(object)FejdStartup.instance != (Object)null)
			{
				return (Object)(object)Player.m_localPlayer == (Object)null;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "Update")]
	internal static class PlayerUpdatePatch
	{
		[HarmonyPostfix]
		private static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				PerkEffectDriver.Tick(__instance);
				PerkPanelInput.Tick(__instance);
				BrawlerInput.Tick(__instance);
				OffhandPicker.Tick(__instance);
				KataRunner.Tick(__instance);
				MartialInput.Tick(__instance);
				AbilityInput.Tick(__instance);
				Immunities.Tick(__instance);
				PlayerTuning.Tick(__instance);
				Awareness.Tick(__instance);
				ClownBoots.Tick(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnSkillLevelup")]
	internal static class SkillLevelupPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Player __instance, SkillType skill, float level)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || !SkillKeys.IsRealSkill(skill))
			{
				return;
			}
			PerkState current = PerkState.Current;
			string text = SkillKeys.Key(skill);
			int num = PointMath.Earned(current);
			if (current.RaiseHighWater(text, level))
			{
				int num2 = PointMath.Earned(current);
				if (num2 > num)
				{
					int num3 = num2 - num;
					((Character)__instance).Message((MessageType)2, string.Format("{0} perk point{1} - spend anywhere", num3, (num3 == 1) ? "" : "s"), 0, (Sprite)null, false);
					Log.Debug($"{text} reached {level:0}; pool now {num2}.");
				}
			}
		}
	}
	[HarmonyPatch(typeof(Skills), "Awake")]
	internal static class SkillsAwakePatch
	{
		private static bool _reported;

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(Skills __instance)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0064: Expected I4, but got Unknown
			//IL_0078: 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_01c7: 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_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			if (__instance?.m_skills == null)
			{
				return;
			}
			List<string> list = new List<string>();
			List<SkillType> list2 = new List<SkillType>();
			foreach (SkillDef skill2 in __instance.m_skills)
			{
				if (skill2 == null)
				{
					continue;
				}
				SkillType skill = skill2.m_skill;
				if (SkillKeys.IsRealSkill(skill))
				{
					ForeignSkills.NoteRegistered(skill);
					string text = SkillKeys.Key(skill);
					list.Add($"{text} ({(int)skill})");
					if (PerkDatabase.Tree(text) == null)
					{
						list2.Add(skill);
					}
				}
			}
			if (!_reported)
			{
				Log.Info($"Skills registered at Awake: {list.Count}");
				Log.Debug("  " + string.Join(", ", list));
				if (ForeignSkills.DeclaredCount > 0)
				{
					Log.Info("Authored trees for other mods' skills: " + $"{ForeignSkills.PresentCount} of {ForeignSkills.DeclaredCount} " + "installed.");
					foreach (KeyValuePair<string, string> item in ForeignSkills.All)
					{
						Log.Debug("  " + item.Value + " -> " + (ForeignSkills.IsPresent(item.Key) ? "found" : "not installed"));
					}
				}
				_reported = true;
			}
			if (list2.Count == 0)
			{
				return;
			}
			if (!ModConfig.GenerateStubTrees.Value)
			{
				Log.Info($"{list2.Count} skill(s) have no authored tree and stub generation " + "is off. They will not appear in the perk panel.");
				return;
			}
			foreach (SkillType item2 in list2)
			{
				string text2 = DisplayName(__instance, item2);
				SkillKeys.RegisterCustom(item2, text2);
				string text3 = SkillKeys.Key(item2);
				if (PerkDatabase.Tree(text3) == null)
				{
					PerkDatabase.AddTree(StubTreeGenerator.Build(item2, text2));
					Log.Info("Generated a stub tree for '" + text2 + "' (" + text3 + ").");
				}
			}
		}

		private unsafe static string DisplayName(Skills skills, SkillType type)
		{
			string text = ((object)(*(SkillType*)(&type))/*cast due to .constrained prefix*/).ToString();
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return "Unknown skill";
		}
	}
}
namespace Norntastic.Martial
{
	internal static class AbilityInput
	{
		internal static ConfigEntry<KeyboardShortcut> UseKey;

		internal static ConfigEntry<KeyboardShortcut> CycleKey;

		private static readonly Dictionary<string, float> ReadyAt = new Dictionary<string, float>(StringComparer.Ordinal);

		private static int _selected;

		internal static void Bind(ConfigFile config)
		{
			//IL_0012: 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)
			UseKey = config.Bind<KeyboardShortcut>("Martial Arts", "AbilityKey", new KeyboardShortcut((KeyCode)118, Array.Empty<KeyCode>()), "Uses your selected active ability. Which abilities you have depends on which perks you bought.");
			CycleKey = config.Bind<KeyboardShortcut>("Martial Arts", "AbilityCycleKey", new KeyboardShortcut((KeyCode)98, Array.Empty<KeyCode>()), "Selects the next active ability you own.");
		}

		internal static void Reset()
		{
			ReadyAt.Clear();
			_selected = 0;
		}

		internal static float Remaining(Kata ability)
		{
			if (ability == null)
			{
				return 0f;
			}
			if (!ReadyAt.TryGetValue(ability.Id, out var value))
			{
				return 0f;
			}
			float num = value - Time.time;
			if (!(num > 0f))
			{
				return 0f;
			}
			return num;
		}

		internal static Kata Selected(Player player)
		{
			List<Kata> list = AbilityLibrary.Available(Unlocked);
			if (list.Count == 0)
			{
				return null;
			}
			if (_selected >= list.Count)
			{
				_selected = 0;
			}
			return list[_selected];
		}

		internal static void Tick(Player player)
		{
			//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_008b: 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)
			if (UseKey == null || CycleKey == null || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer || MartialInput.Enabled == null || !MartialInput.Enabled.Value || PerkPanel.IsOpen || Console.IsVisible() || TextInput.IsVisible() || ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus()))
			{
				return;
			}
			KeyboardShortcut value = CycleKey.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				Cycle(player);
				return;
			}
			value = UseKey.Value;
			if (!((KeyboardShortcut)(ref value)).IsDown())
			{
				return;
			}
			Kata kata = Selected(player);
			if (kata == null)
			{
				((Character)player).Message((MessageType)2, "No active abilities yet - they come from perks", 0, (Sprite)null, false);
				return;
			}
			float num = Remaining(kata);
			if (num > 0f)
			{
				((Character)player).Message((MessageType)2, kata.Name + " in " + num.ToString("0.0") + "s", 0, (Sprite)null, false);
				return;
			}
			KataStep kataStep = KataRunner.Advance(player, kata);
			if (kataStep != null)
			{
				MartialStrike.Resolve(player, kata, kataStep);
				if (KataRunner.Active == null)
				{
					ReadyAt[kata.Id] = Time.time + kata.Cooldown;
				}
			}
		}

		private static void Cycle(Player player)
		{
			List<Kata> list = AbilityLibrary.Available(Unlocked);
			if (list.Count == 0)
			{
				((Character)player).Message((MessageType)2, "No active abilities yet", 0, (Sprite)null, false);
				return;
			}
			_selected = (_selected + 1) % list.Count;
			((Character)player).Message((MessageType)2, "Ready: " + list[_selected].Name, 0, (Sprite)null, false);
		}

		private static bool Unlocked(string perkId)
		{
			if (!string.IsNullOrEmpty(perkId))
			{
				return PerkState.Current.GetRank(perkId) > 0;
			}
			return false;
		}
	}
	internal static class AbilityLibrary
	{
		private static readonly List<Kata> Abilities;

		internal static IEnumerable<Kata> All => Abilities;

		internal static int Count => Abilities.Count;

		internal static List<Kata> Available(Func<string, bool> unlocked)
		{
			List<Kata> list = new List<Kata>();
			if (unlocked == null)
			{
				return list;
			}
			foreach (Kata ability in Abilities)
			{
				if (unlocked(ability.RequiresPerk))
				{
					list.Add(ability);
				}
			}
			return list;
		}

		private static Kata Add(string id, string name, string perk, float cooldown, Grip grip, string blurb)
		{
			Kata kata = new Kata
			{
				Id = id,
				Name = name,
				RequiresPerk = perk,
				Cooldown = cooldown,
				Grip = grip,
				Blurb = blurb
			};
			Abilities.Add(kata);
			return kata;
		}

		private static Kata Beat(this Kata kata, string name, StepKind kind, string[] animations, float damage, float stamina, float lunge, float window, float stagger = 1f, float range = 2.4f, float radius = 0f, float fear = 0f)
		{
			kata.Steps.Add(new KataStep
			{
				Name = name,
				Kind = kind,
				Animations = animations,
				Damage = damage,
				Stamina = stamina,
				Lunge = lunge,
				Window = window,
				Stagger = stagger,
				Range = range,
				Radius = radius,
				Fear = fear
			});
			return kata;
		}

		static AbilityLibrary()
		{
			Abilities = new List<Kata>();
			Add("whirlwind", "Whirlwind", "ax13", 18f, Grip.TwoHanded, "Everything within the arc, at once, and then you are somewhere else.").Beat("Whirlwind", StepKind.Strike, new string[3] { "AtgeirIron_secondary", "Battleaxe", "swing" }, 2.2f, 25f, 0f, 0f, 2f, 3f, 4f);
			Add("thunderfoot", "Thunderfoot", "jp11", 20f, Grip.Empty, "You arrive before the sound does.").Beat("Slam", StepKind.Strike, new string[3] { "jump", "Battleaxe", "swing" }, 2f, 22f, 0f, 0f, 2.5f, 3f, 5f);
			Add("himinfall", "Himinfall", "jp12", 30f, Grip.Empty, "The drop does the work. You only have to aim it.").Beat("Himinfall", StepKind.Finisher, new string[3] { "jump", "AtgeirIron_secondary", "stagger" }, 3f, 18f, 0f, 0f, 4f, 3.5f, 6.5f);
			Add("warcry", "War Cry", "wf9", 45f, Grip.Empty, "Not a threat. An announcement.").Beat("War Cry", StepKind.Guard, new string[2] { "gpower", "shake" }, 0f, 20f, 0f, 0f, 3f, 3f, 10f, 4f);
			Add("shieldcharge", "Shield Charge", "sh8", 16f, Grip.SwordAndBoard, "The wall, at speed, with you behind it.").Beat("Charge", StepKind.Move, new string[2] { "ShieldBanded", "interact" }, 0f, 10f, 12f, 0.6f).Beat("Impact", StepKind.Strike, new string[2] { "SwordIron", "stagger" }, 1.8f, 12f, 0f, 0f, 3f, 3f);
			Add("grapple", "Grapple", "uw9", 22f, Grip.Empty, "You have decided where they are going to be.").Beat("Seize", StepKind.Move, new string[2] { "interact", "dodge" }, 0f, 12f, 4f, 0.8f).Beat("Throw", StepKind.Finisher, new string[2] { "Club_secondary", "stagger" }, 2f, 16f, 0f, 0f, 4f, 2.2f);
			Add("twofisted", "Two Fisted", "tb10", 12f, Grip.Empty, "Both hands, both directions, no plan beyond that.").Beat("Two Fisted", StepKind.Strike, new string[2] { "Club", "swing" }, 1.2f, 14f, 0f, 0f, 1.5f, 2.6f, 2.6f);
		}
	}
	internal static class AnimationVocabulary
	{
		internal static readonly string[] KnownTriggers = new string[13]
		{
			"attach", "attack_abort", "consume", "detach", "dive", "dodge", "eat", "equip_hip", "gpower", "interact",
			"jump", "shake", "stagger"
		};

		internal static readonly string[] KnownBools = new string[5] { "alert", "grappling", "intro", "repell", "wakeup" };

		private static readonly Dictionary<string, string> Harvested = new Dictionary<string, string>(StringComparer.Ordinal);

		internal static int HarvestedCount => Harvested.Count;

		internal static IEnumerable<KeyValuePair<string, string>> All => Harvested;

		internal static bool IsLiteralTrigger(string name)
		{
			string[] knownTriggers = KnownTriggers;
			for (int i = 0; i < knownTriggers.Length; i++)
			{
				if (string.Equals(knownTriggers[i], name, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		internal static void Harvest(ObjectDB db)
		{
			if ((Object)(object)db == (Object)null || db.m_items == null)
			{
				return;
			}
			Harvested.Clear();
			foreach (GameObject item in db.m_items)
			{
				if (!((Object)(object)item == (Object)null))
				{
					ItemDrop component = item.GetComponent<ItemDrop>();
					SharedData val = (((Object)(object)component == (Object)null || component.m_itemData == null) ? null : component.m_itemData.m_shared);
					if (val != null)
					{
						Record(((Object)item).name, val.m_attack);
						Record(((Object)item).name + "_secondary", val.m_secondaryAttack);
					}
				}
			}
			Log.Info("Animation vocabulary: " + KnownTriggers.Length + " literal trigger(s), " + Harvested.Count + " attack animation(s) harvested from items.");
		}

		private static void Record(string key, Attack attack)
		{
			string value = attack?.m_attackAnimation;
			if (!string.IsNullOrEmpty(value) && !Harvested.ContainsKey(key))
			{
				Harvested[key] = value;
			}
		}

		internal static string ForItem(string itemName)
		{
			if (string.IsNullOrEmpty(itemName))
			{
				return null;
			}
			if (!Harvested.TryGetValue(itemName, out var value))
			{
				return null;
			}
			return value;
		}

		internal static string Resolve(ZSyncAnimation anim, string[] preferences)
		{
			if ((Object)(object)anim == (Object)null || preferences == null)
			{
				return null;
			}
			foreach (string text in preferences)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				string text2 = text;
				if (!IsLiteralTrigger(text2))
				{
					string text3 = ForItem(text2);
					if (text3 != null)
					{
						text2 = text3;
					}
				}
				if (anim.HasParameter(text2, (AnimatorControllerParameterType)9))
				{
					return text2;
				}
			}
			return null;
		}

		internal static ZSyncAnimation Of(Component character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				return character.GetComponent<ZSyncAnimation>();
			}
			return null;
		}
	}
	internal static class Grips
	{
		internal static Grip Of(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return Grip.Empty;
			}
			if (Offhand.IsDualWielding(player))
			{
				return Grip.DualWield;
			}
			if (Equipment.IsTwoHanded(player))
			{
				return Grip.TwoHanded;
			}
			if (Equipment.HasShield(player))
			{
				return Grip.SwordAndBoard;
			}
			if (Equipment.IsEmptyHanded(player))
			{
				return Grip.Empty;
			}
			return Grip.OneHand;
		}

		internal static SkillType SkillFor(Grip grip)
		{
			//IL_0016: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			return (SkillType)(grip switch
			{
				Grip.OneHand => CustomSkills.OneHand, 
				Grip.TwoHanded => CustomSkills.TwoHanded, 
				Grip.SwordAndBoard => CustomSkills.SwordAndBoard, 
				_ => 0, 
			});
		}

		internal static string Describe(Grip grip)
		{
			return grip switch
			{
				Grip.Empty => "empty-handed", 
				Grip.OneHand => "one hand", 
				Grip.SwordAndBoard => "sword and board", 
				Grip.TwoHanded => "two handed", 
				Grip.DualWield => "dual wielding", 
				_ => "?", 
			};
		}
	}
	internal static class GripTraining
	{
		private const float PerDamage = 0.03f;

		private const float Floor = 0.05f;

		private const float Ceiling = 1.2f;

		internal static void OnHit(Player player, HitData hit)
		{
			//IL_0016: 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_0029: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null) && hit != null && CustomSkills.Registered && (int)hit.m_skill != 0)
			{
				SkillType val = Grips.SkillFor(Grips.Of(player));
				if ((int)val != 0)
				{
					float totalDamage = hit.GetTotalDamage();
					((Character)player).RaiseSkill(val, Mathf.Clamp(totalDamage * 0.03f, 0.05f, 1.2f));
				}
			}
		}

		internal static bool TrainsAGrip(Grip grip)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			return (int)Grips.SkillFor(grip) > 0;
		}
	}
	internal sealed class Kata
	{
		internal string Id = string.Empty;

		internal string Name = string.Empty;

		internal string Blurb = string.Empty;

		internal string RequiresPerk = string.Empty;

		internal Grip Grip;

		internal float Cooldown;

		internal readonly List<KataStep> Steps = new List<KataStep>();

		internal bool IsAbility => Cooldown > 0f;

		internal int Length => Steps.Count;

		internal KataStep At(int index)
		{
			if (index < 0 || index >= Steps.Count)
			{
				return null;
			}
			return Steps[index];
		}
	}
	internal enum Grip
	{
		Empty,
		OneHand,
		SwordAndBoard,
		TwoHanded,
		DualWield
	}
	internal static class KataBroadcast
	{
		internal const string ZdoKey = "nsg.kata";

		private static int _counter;

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

		internal static void Reset()
		{
			_counter = 0;
			Seen.Clear();
		}

		internal static void Publish(Player player, string kataId, int step)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				ZDO val = ZdoOf(player);
				if (val != null)
				{
					_counter++;
					val.Set("nsg.kata", string.IsNullOrEmpty(kataId) ? (_counter + "::0") : (_counter + ":" + kataId + ":" + step));
				}
			}
		}

		internal static bool Read(Player other, out string kataId, out int step)
		{
			kataId = null;
			step = 0;
			if ((Object)(object)other == (Object)null || (Object)(object)other == (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			ZDO val = ZdoOf(other);
			if (val == null)
			{
				return false;
			}
			string text = val.GetString("nsg.kata", string.Empty);
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			string key = other.GetPlayerID().ToString();
			if (Seen.TryGetValue(key, out var value) && value == text)
			{
				return false;
			}
			Seen[key] = text;
			string[] array = text.Split(':');
			if (array.Length != 3)
			{
				return false;
			}
			if (string.IsNullOrEmpty(array[1]))
			{
				return false;
			}
			kataId = array[1];
			int.TryParse(array[2], out step);
			return true;
		}

		private static ZDO ZdoOf(Player player)
		{
			ZNetView val = (((Object)(object)player == (Object)null) ? null : ((Component)player).GetComponent<ZNetView>());
			if (!((Object)(object)val == (Object)null) && val.IsValid())
			{
				return val.GetZDO();
			}
			return null;
		}
	}
	internal static class KataLibrary
	{
		private static readonly Dictionary<string, Kata> Arts;

		internal static IEnumerable<Kata> All => Arts.Values;

		internal static int Count => Arts.Count;

		internal static Kata Get(string id)
		{
			if (id == null || !Arts.TryGetValue(id, out var value))
			{
				return null;
			}
			return value;
		}

		internal static Kata ForGrip(Grip grip, Func<string, bool> unlocked)
		{
			foreach (Kata value in Arts.Values)
			{
				if (value.Grip == grip)
				{
					if (string.IsNullOrEmpty(value.RequiresPerk))
					{
						return value;
					}
					if (unlocked != null && unlocked(value.RequiresPerk))
					{
						return value;
					}
				}
			}
			return null;
		}

		private static Kata Add(string id, string name, Grip grip, string perk, string blurb)
		{
			Kata kata = new Kata
			{
				Id = id,
				Name = name,
				Grip = grip,
				RequiresPerk = perk,
				Blurb = blurb
			};
			Arts[id] = kata;
			return kata;
		}

		private static Kata Step(this Kata kata, string name, StepKind kind, string[] animations, float damage, float stamina, float lunge, float window, float stagger = 1f, float range = 2.4f)
		{
			kata.Steps.Add(new KataStep
			{
				Name = name,
				Kind = kind,
				Animations = animations,
				Damage = damage,
				Stamina = stamina,
				Lunge = lunge,
				Window = window,
				Stagger = stagger,
				Range = range
			});
			return kata;
		}

		static KataLibrary()
		{
			Arts = new Dictionary<string, Kata>(StringComparer.Ordinal);
			Add("drunken_fist", "Drunken Fist", Grip.Empty, "br7", "Three parts falling over, one part deciding where.").Step("Stumble In", StepKind.Move, new string[1] { "dodge" }, 0f, 6f, 4.5f, 1.1f).Step("Wild Swing", StepKind.Strike, new string[3] { "KnifeButcher", "Club", "swing" }, 1f, 8f, 1.5f, 1f).Step("Backhand", StepKind.Strike, new string[3] { "Club_secondary", "MaceIron", "swing" }, 1.2f, 9f, 0f, 1f, 1.6f)
				.Step("Rising Knee", StepKind.Strike, new string[1] { "jump" }, 1.4f, 11f, 2f, 1.2f, 2f)
				.Step("Faceplant", StepKind.Finisher, new string[3] { "AtgeirIron_secondary", "Battleaxe", "attack_abort" }, 2.4f, 14f, 3f, 0f, 3f, 3f);
			Add("open_palm", "Open Palm", Grip.Empty, string.Empty, "No weapon, no trick, no wasted motion.").Step("Jab", StepKind.Strike, new string[2] { "KnifeButcher", "swing" }, 0.8f, 5f, 0.8f, 0.8f, 0.6f).Step("Cross", StepKind.Strike, new string[2] { "Club", "swing" }, 1f, 6f, 1f, 0.8f).Step("Elbow", StepKind.Strike, new string[2] { "Club_secondary", "swing" }, 1.5f, 9f, 1.2f, 0f, 2f);
			Add("shield_rush", "Shield Rush", Grip.SwordAndBoard, "sb5", "The wall moves. Nobody expects the wall to move.").Step("Set", StepKind.Guard, new string[1] { "attack_abort" }, 0f, 4f, 0f, 1.2f).Step("Shove", StepKind.Move, new string[2] { "ShieldBanded", "interact" }, 0.4f, 8f, 5f, 1f, 2.5f).Step("Punch Through", StepKind.Strike, new string[2] { "SwordIron", "swing" }, 1.4f, 10f, 1f, 0.9f)
				.Step("Pin", StepKind.Finisher, new string[2] { "SwordIron_secondary", "stagger" }, 2f, 12f, 0f, 0f, 2.5f);
			Add("long_guard", "Long Guard", Grip.TwoHanded, "th7", "Everything at the end of the haft is the same distance away.").Step("Give Ground", StepKind.Move, new string[1] { "dodge" }, 0f, 6f, -3f, 1.3f).Step("Sweep", StepKind.Strike, new string[2] { "AtgeirIron", "swing" }, 1.3f, 11f, 0f, 1.1f, 1.8f, 3.2f).Step("Overhead", StepKind.Strike, new string[2] { "Battleaxe", "swing" }, 1.8f, 14f, 1.5f, 1f, 2.2f, 3f)
				.Step("Pommel", StepKind.Finisher, new string[2] { "AtgeirIron_secondary", "stagger" }, 2.6f, 16f, 1f, 0f, 3.5f, 2.6f);
			Add("free_hand", "Free Hand", Grip.OneHand, "oh7", "One weapon and somewhere to be.").Step("Lead", StepKind.Strike, new string[2] { "SwordIron", "swing" }, 0.9f, 5f, 1.2f, 0.7f).Step("Tumble", StepKind.Move, new string[1] { "dodge" }, 0f, 5f, 5f, 0.9f).Step("Rise", StepKind.Strike, new string[2] { "KnifeButcher_secondary", "swing" }, 1.3f, 7f, 1f, 0.8f)
				.Step("Through", StepKind.Finisher, new string[2] { "SwordIron_secondary", "swing" }, 1.9f, 10f, 2f, 0f, 2f);
		}
	}
	internal static class KataRunner
	{
		private static float _windowEnds;

		private static bool _running;

		internal static Kata Active { get; private set; }

		internal static int NextStep { get; private set; }

		internal static bool WindowOpen
		{
			get
			{
				if (Active != null)
				{
					return Time.time < _windowEnds;
				}
				return false;
			}
		}

		internal static void Reset()
		{
			Active = null;
			NextStep = 0;
			_windowEnds = 0f;
			_running = false;
		}

		internal static void Tick(Player player)
		{
			if (Active != null && !(Time.time < _windowEnds))
			{
				KataBroadcast.Publish(player, null, 0);
				Reset();
			}
		}

		internal static KataStep Advance(Player player, Kata kata)
		{
			if ((Object)(object)player == (Object)null || kata == null || kata.Length == 0)
			{
				return null;
			}
			if (_running)
			{
				return null;
			}
			if (Active != kata || !WindowOpen)
			{
				Active = kata;
				NextStep = 0;
			}
			KataStep kataStep = kata.At(NextStep);
			if (kataStep == null)
			{
				Reset();
				return null;
			}
			if (!((Character)player).HaveStamina(kataStep.Stamina))
			{
				Reset();
				return null;
			}
			_running = true;
			try
			{
				((Character)player).UseStamina(kataStep.Stamina);
				Play(player, kataStep);
				KataBroadcast.Publish(player, kata.Id, NextStep);
				NextStep++;
				_windowEnds = ((kataStep.Window > 0f && NextStep < kata.Length) ? (Time.time + kataStep.Window) : 0f);
				if (_windowEnds <= 0f)
				{
					KataBroadcast.Publish(player, null, 0);
					Active = null;
					NextStep = 0;
				}
				return kataStep;
			}
			finally
			{
				_running = false;
			}
		}

		private static void Play(Player player, KataStep step)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			ZSyncAnimation val = AnimationVocabulary.Of((Component)(object)player);
			string text = AnimationVocabulary.Resolve(val, step.Animations);
			if (text != null)
			{
				val.SetTrigger(text);
			}
			else
			{
				Log.Debug("Kata step '" + step.Name + "' found no animation this install has.");
			}
			if (step.Lunge > 0f)
			{
				((Character)player).ApplyPushback(((Component)player).transform.forward, step.Lunge);
			}
		}

		internal static string Describe()
		{
			if (Active != null)
			{
				return Active.Name + " step " + NextStep + "/" + Active.Length + (WindowOpen ? (" (window open " + Math.Round(_windowEnds - Time.time, 2) + "s)") : " (window shut)");
			}
			return "idle";
		}
	}
	internal enum StepKind
	{
		Strike,
		Move,
		Finisher,
		Guard
	}
	internal sealed class KataStep
	{
		internal string Name = string.Empty;

		internal StepKind Kind;

		internal string[] Animations = new string[0];

		internal float Damage = 1f;

		internal float Stamina = 8f;

		internal float Lunge;

		internal float Range = 2.4f;

		internal float Radius;

		internal float Fear;

		internal float Window = 0.9f;

		internal float Stagger = 1f;

		internal string Describe()
		{
			return $"{Name} [{Kind}] x{Damage:0.00} st {Stamina:0} " + ((Lunge > 0f) ? $"lunge {Lunge:0.0} " : string.Empty) + $"window {Window:0.0}s";
		}
	}
	internal static class MartialInput
	{
		internal static ConfigEntry<KeyboardShortcut> KataKey;

		internal static ConfigEntry<bool> Enabled;

		internal static void Bind(ConfigFile config)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			Enabled = config.Bind<bool>("Martial Arts", "Enabled", true, "The kata system: a combo key whose art depends on your grip. Every animation it plays is one the game already has, so other players see it whether or not they have this mod.");
			KataKey = config.Bind<KeyboardShortcut>("Martial Arts", "KataKey", new KeyboardShortcut((KeyCode)103, Array.Empty<KeyCode>()), "Walks the next beat of your current art. G is free again now that the brawler has moved off it - Valheim uses it for the radial menu, so if that clashes for you, rebind it here.");
		}

		internal static void Tick(Player player)
		{
			//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)
			if (Enabled == null || !Enabled.Value || KataKey == null || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			KeyboardShortcut value = KataKey.Value;
			if (!((KeyboardShortcut)(ref value)).IsDown() || PerkPanel.IsOpen || Console.IsVisible() || TextInput.IsVisible() || ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus()))
			{
				return;
			}
			Grip grip = Grips.Of(player);
			Kata kata = KataLibrary.ForGrip(grip, PerkUnlocked);
			if (kata == null)
			{
				((Character)player).Message((MessageType)2, "No art for " + Grips.Describe(grip) + " yet", 0, (Sprite)null, false);
				return;
			}
			KataStep kataStep = KataRunner.Advance(player, kata);
			if (kataStep != null)
			{
				MartialStrike.Resolve(player, kata, kataStep);
			}
		}

		private static bool PerkUnlocked(string perkId)
		{
			if (!string.IsNullOrEmpty(perkId))
			{
				return PerkState.Current.GetRank(perkId) > 0;
			}
			return false;
		}
	}
	internal static class MartialStrike
	{
		internal const float BaseDamage = 12f;

		internal const float SkillScale = 0.6f;

		internal static void Resolve(Player player, Kata kata, KataStep step)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00bb: 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)
			if (!((Object)(object)player == (Object)null) && kata != null && step != null && step.Kind != StepKind.Move && step.Kind != StepKind.Guard)
			{
				string text = ((step.Radius > 0f) ? ("everything within " + step.Radius.ToString("0.0") + "m") : ("a cone " + step.Range.ToString("0.0") + "m ahead"));
				SkillType val = Grips.SkillFor(kata.Grip);
				float num = (((int)val == 0) ? 0f : LevelOf(player, val));
				float num2 = 12f * step.Damage * (1f + 0.6f * num / 100f);
				TriggerBus.Fire(TriggerKind.Hit, new TriggerContext
				{
					Skill = (SkillType)(((int)val == 0) ? 11 : ((int)val))
				});
				Log.Debug("Kata beat '" + step.Name + "' for " + num2.ToString("0.0") + " across " + text + " in " + Grips.Describe(kata.Grip) + ".");
			}
		}

		private static float LevelOf(Player player, SkillType skill)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Skills skills = ((Character)player).GetSkills();
			if (!((Object)(object)skills == (Object)null))
			{
				return skills.GetSkillFactor(skill) * 100f;
			}
			return 0f;
		}
	}
}
namespace Norntastic.Kitchen
{
	internal static class Bakery
	{
		internal const string CounterName = "nsg_bakery_counter";

		internal const string PieName = "nsg_raspberry_pie";

		private static bool _recipeBuilt;

		private static string CounterSource => ModConfig.BakeryCounterSource?.Value ?? "piece_cauldron";

		private static string PieSource => ModConfig.BakeryPieSource?.Value ?? "QueensJam";

		private static string PieCost => ModConfig.BakeryPieCost?.Value ?? "Raspberry";

		private static string CounterCost => ModConfig.BakeryCounterCost?.Value ?? "Wood";

		internal static void Arm()
		{
			ForgePatches.Register(Build);
		}

		private static void Build(Func<string, GameObject> find)
		{
			if (ModConfig.BakeryEnabled == null || !ModConfig.BakeryEnabled.Value)
			{
				return;
			}
			GameObject val = find(CounterSource);
			if ((Object)(object)val == (Object)null)
			{
				Log.Warn("Bakery: no prefab named '" + CounterSource + "' - set Content.BakeryCounterSource to something that exists.");
			}
			else if (!PrefabForge.Has("nsg_bakery_counter"))
			{
				Dress(PrefabForge.MakePiece(val, "nsg_bakery_counter", derived: false), find);
			}
			GameObject val2 = find(PieSource);
			if ((Object)(object)val2 == (Object)null)
			{
				Log.Warn("Bakery: no prefab named '" + PieSource + "' - set Content.BakeryPieSource to something that exists.");
			}
			else if (!PrefabForge.Has("nsg_raspberry_pie"))
			{
				GameObject val3 = PrefabForge.MakeItem(val2, "nsg_raspberry_pie", derived: false);
				ItemDrop val4 = (((Object)(object)val3 == (Object)null) ? null : val3.GetComponent<ItemDrop>());
				if (val4?.m_itemData?.m_shared != null)
				{
					val4.m_itemData.m_shared.m_name = "Raspberry Pie";
				}
			}
			if (!_recipeBuilt)
			{
				BuildRecipe(find);
			}
		}

		private static void Dress(GameObject counter, Func<string, GameObject> find)
		{
			if (!((Object)(object)counter == (Object)null))
			{
				CraftingStation component = counter.GetComponent<CraftingStation>();
				if ((Object)(object)component != (Object)null)
				{
					component.m_name = "Bakery Counter";
					component.m_craftRequireFire = false;
					component.m_craftRequireRoof = false;
				}
				Piece component2 = counter.GetComponent<Piece>();
				if (!((Object)(object)component2 == (Object)null))
				{
					component2.m_name = "Bakery Counter";
					component2.m_description = "Proof that this works. One wood.";
					component2.m_enabled = true;
					component2.m_craftingStation = null;
					component2.m_resources = PrefabForge.Cost(find, CounterCost, 1);
				}
			}
		}

		private static void BuildRecipe(Func<string, GameObject> find)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			GameObject val = PrefabForge.Find("nsg_raspberry_pie");
			GameObject val2 = PrefabForge.Find("nsg_bakery_counter");
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
			{
				ItemDrop component = val.GetComponent<ItemDrop>();
				CraftingStation component2 = val2.GetComponent<CraftingStation>();
				GameObject val3 = find(PieCost);
				ItemDrop val4 = (((Object)(object)val3 == (Object)null) ? null : val3.GetComponent<ItemDrop>());
				if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || (Object)(object)val4 == (Object)null)
				{
					Log.Warn("Bakery: recipe not built - missing result, station or '" + PieCost + "'.");
					return;
				}
				Recipe val5 = ScriptableObject.CreateInstance<Recipe>();
				((Object)val5).name = "Recipe_nsg_raspberry_pie";
				val5.m_item = component;
				val5.m_amount = 1;
				val5.m_enabled = true;
				val5.m_craftingStation = component2;
				val5.m_minStationLevel = 1;
				val5.m_resources = (Requirement[])(object)new Requirement[1]
				{
					new Requirement
					{
						m_resItem = val4,
						m_amount = 1,
						m_recover = true
					}
				};
				PrefabForge.AddRecipe(val5);
				_recipeBuilt = true;
			}
		}
	}
	internal static class CookingCombat
	{
		internal static SkillType Governs(ItemData item)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (!IsKitchen(item))
			{
				return CustomSkills.Brawler;
			}
			return (SkillType)105;
		}

		internal static bool IsKitchen(ItemData item)
		{
			SharedData val = item?.m_shared;
			if (val == null)
			{
				return false;
			}
			if (val.m_food > 0f)
			{
				return true;
			}
			return IsUtensil(val.m_name);
		}

		internal static bool IsUtensil(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			return ModConfig.MatchesFragment(name, ModConfig.Utensils?.Value);
		}

		internal static float QualityMultiplier(ItemData item)
		{
			SharedData val = item?.m_shared;
			if (val == null || val.m_food <= 0f)
			{
				return 1f;
			}
			return 1f + Mathf.Clamp(val.m_food / 60f, 0f, 1.5f);
		}

		internal static float SkillMultiplier(Player player, ItemData item)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return 1f;
			}
			Skills skills = ((Character)player).GetSkills();
			if ((Object)(object)skills == (Object)null)
			{
				return 1f;
			}
			float skillLevel = skills.GetSkillLevel(Governs(item));
			return 1f + Mathf.Clamp01(skillLevel / 100f) * 0.6f;
		}
	}
	internal static class FoodNames
	{
		internal static string FromPrefab(string prefabName)
		{
			return Render(prefabName, dropTag: true);
		}

		internal static string FromPrefabKeepingTag(string prefabName)
		{
			return Render(prefabName, dropTag: false);
		}

		private static string Render(string prefabName, bool dropTag)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return string.Empty;
			}
			List<string> list = Split(prefabName);
			if (list.Count == 0)
			{
				return prefabName;
			}
			if (dropTag && list.Count > 1 && IsModTag(list[0]))
			{
				list.RemoveAt(0);
			}
			return string.Join(" ", list.ToArray());
		}

		private static List<string> Split(string name)
		{
			List<string> list = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < name.Length; i++)
			{
				char c = name[i];
				if (c == '_' || c == '-' || c == ' ')
				{
					Flush(list, stringBuilder);
					continue;
				}
				if (i > 0 && char.IsUpper(c))
				{
					char c2 = name[i - 1];
					if (char.IsLower(c2) || char.IsDigit(c2) || (char.IsUpper(c2) && i + 1 < name.Length && char.IsLower(name[i + 1])))
					{
						Flush(list, stringBuilder);
					}
				}
				stringBuilder.Append(c);
			}
			Flush(list, stringBuilder);
			return list;
		}

		private static void Flush(List<string> words, StringBuilder current)
		{
			if (current.Length != 0)
			{
				words.Add(Capitalise(current.ToString()));
				current.Length = 0;
			}
		}

		private static string Capitalise(string word)
		{
			if (word.Length == 0)
			{
				return word;
			}
			if (IsShout(word))
			{
				return word;
			}
			return char.ToUpperInvariant(word[0]) + ((word.Length > 1) ? word.Substring(1) : string.Empty);
		}

		private static bool IsShout(string word)
		{
			int num = 0;
			foreach (char c in word)
			{
				if (char.IsLower(c))
				{
					return false;
				}
				if (char.IsLetter(c))
				{
					num++;
				}
			}
			return num > 0;
		}

		private static bool IsModTag(string word)
		{
			if (!IsShout(word))
			{
				return false;
			}
			bool flag = false;
			int num = 0;
			foreach (char c in word)
			{
				if (char.IsDigit(c))
				{
					flag = true;
					continue;
				}
				if (char.IsLetter(c))
				{
					num++;
					continue;
				}
				return false;
			}
			if (!flag)
			{
				return num <= 2;
			}
			return true;
		}
	}
	internal static class Fryer
	{
		private static readonly List<FryResult> Planned = new List<FryResult>();

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

		internal static IEnumerable<FryResult> Results => Planned;

		internal static IEnumerable<string> Skipped => Excluded;

		internal static int SkippedCount => Excluded.Count;

		internal static int Count => Planned.Count;

		internal static bool Planned_ { get; private set; }

		internal static int BuiltCount { get; private set; }

		internal static void Plan()
		{
			List<PieIngredient> list = Larder.Snapshot();
			Planned.Clear();
			Planned.AddRange(FryGenerator.Build(list));
			Excluded.Clear();
			foreach (PieIngredient item in list)
			{
				string text = FryGenerator.Excuse(item);
				if (text != null)
				{
					Excluded.Add((item.PrefabName ?? "?") + " - " + text);
				}
			}
			Excluded.Sort(StringComparer.Ordinal);
			Planned_ = true;
			Log.Info("Fryer: " + Planned.Count + " food(s) could be fried, " + Excluded.Count + " left out. Run nsg.fryer, or nsg.fryer skipped. The basin itself is still station work.");
		}

		internal static void Arm()
		{
			ForgePatches.Register(Build);
		}

		internal static void Build(Func<string, GameObject> find)
		{
			if (!Planned_)
			{
				return;
			}
			int num = 0;
			foreach (FryResult item in Planned)
			{
				if (PrefabForge.Has(item.PrefabName))
				{
					continue;
				}
				GameObject val = find(item.SourceName);
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				GameObject val2 = PrefabForge.MakeItem(val, item.PrefabName, derived: true);
				if (!((Object)(object)val2 == (Object)null))
				{
					ItemDrop component = val2.GetComponent<ItemDrop>();
					SharedData val3 = (((Object)(object)component == (Object)null || component.m_itemData == null) ? null : component.m_itemData.m_shared);
					if (val3 != null)
					{
						val3.m_name = item.DisplayName;
						val3.m_description = "Hot, and briefly perfect. Worth more now and less later than what went in.";
						val3.m_food = item.Health;
						val3.m_foodStamina = item.Stamina;
						val3.m_foodEitr = item.Eitr;
						val3.m_foodBurnTime = item.Duration;
					}
					num++;
				}
			}
			BuiltCount = 0;
			foreach (FryResult item2 in Planned)
			{
				if (PrefabForge.Has(item2.PrefabName))
				{
					BuiltCount++;
				}
			}
			if (num > 0)
			{
				Log.Info("Fried " + num + " kind(s) of food.");
			}
		}

		internal static IEnumerable<ConversionDef> Chains()
		{
			List<ConversionDef> list = new List<ConversionDef>();
			foreach (FryResult item in Planned)
			{
				if (PrefabForge.Has(item.PrefabName))
				{
					list.Add(new ConversionDef
					{
						From = item.SourceName,
						To = item.PrefabName,
						Note = item.DisplayName
					});
				}
			}
			return list;
		}

		internal static FryResult For(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return null;
			}
			foreach (FryResult item in Planned)
			{
				if (item.SourceName == prefabName)
				{
					return item;
				}
			}
			return null;
		}
	}
	internal static class FryGenerator
	{
		internal const string Prefix = "NSG_Fried_";

		internal const float Gain = 1.35f;

		internal const float DurationKept = 0.7f;

		private static readonly string[] OwnPrefixes = new string[1] { "NSG_" };

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

		internal static readonly string[] NotFood = new string[6] { "uncooked", "unbaked", "dough", "batter", "raw_", "_raw" };

		internal static int IngredientCount => OwnIngredients.Count;

		internal static void DeclareIngredient(string prefabName)
		{
			if (!string.IsNullOrEmpty(prefabName))
			{
				OwnIngredients.Add(prefabName);
			}
		}

		internal static float EitrOf(float sourceEitr)
		{
			return sourceEitr;
		}

		internal static string Excuse(PieIngredient food)
		{
			if (food == null || string.IsNullOrEmpty(food.PrefabName))
			{
				return "no prefab";
			}
			if (IsOurs(food.PrefabName))
			{
				return "this mod made it";
			}
			if (IsNotFood(food.PrefabName))
			{
				return "an unbaked intermediate, not a dish";
			}
			if (food.Health <= 0f && food.Stamina <= 0f)
			{
				return "no nutrition to multiply";
			}
			return null;
		}

		internal static bool IsOurs(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			if (OwnIngredients.Contains(prefabName))
			{
				return false;
			}
			string[] ownPrefixes = OwnPrefixes;
			foreach (string value in ownPrefixes)
			{
				if (prefabName.StartsWith(value, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsNotFood(string prefabName)
		{
			string[] notFood = NotFood;
			foreach (string value in notFood)
			{
				if (prefabName.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		internal static List<FryResult> Build(List<PieIngredient> foods)
		{
			List<FryResult> list = new List<FryResult>();
			if (foods == null)
			{
				return list;
			}
			foreach (PieIngredient food in foods)
			{
				if (Excuse(food) == null)
				{
					list.Add(new FryResult
					{
						SourceName = food.PrefabName,
						PrefabName = "NSG_Fried_" + food.PrefabName,
						DisplayName = "Fried " + FoodNames.FromPrefab(food.PrefabName),
						Health = Round(food.Health * 1.35f),
						Stamina = Round(food.Stamina * 1.35f),
						Eitr = EitrOf(food.Eitr),
						Duration = Round(food.Duration * 0.7f),
						DurationLostPct = 30.000002f
					});
				}
			}
			Disambiguate(list);
			list.Sort((FryResult a, FryResult b) => string.Compare(a.PrefabName, b.PrefabName, StringComparison.Ordinal));
			return list;
		}

		private static void Disambiguate(List<FryResult> results)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			foreach (FryResult result in results)
			{
				dictionary.TryGetValue(result.DisplayName, out var value);
				dictionary[result.DisplayName] = value + 1;
			}
			foreach (FryResult result2 in results)
			{
				if (dictionary[result2.DisplayName] > 1)
				{
					result2.DisplayName = "Fried " + FoodNames.FromPrefabKeepingTag(result2.SourceName);
				}
			}
		}

		private static float Round(float value)
		{
			return (float)Math.Round(value);
		}
	}
	internal sealed class FryResult
	{
		internal string SourceName = string.Empty;

		internal string PrefabName = string.Empty;

		internal string DisplayName = string.Empty;

		internal float Health;

		internal float Stamina;

		internal float Eitr;

		internal float Duration;

		internal float DurationLostPct;

		internal string Describe()
		{
			return $"{DisplayName} <- {SourceName}  hp {Health:0} st {Stamina:0}" + ((Eitr > 0f) ? $" ei {Eitr:0}" : string.Empty) + $" for {Duration / 60f:0}min (-{DurationLostPct:0}%)";
		}
	}
	internal static class Jerky
	{
		internal const string Prefix = "NSG_Jerky_";

		internal const float Kept = 0.7f;

		internal const float DurationGain = 2.5f;

		internal static readonly string[] NotHangable = new string[19]
		{
			"jerky", "smoked", "stew", "soup", "pie", "wrap", "platter", "sausage", "skewer", "sauce",
			"supreme", "glazed", "bread", "omelette", "roll", "pudding", "porridge", "salad", "vine"
		};

		private static readonly List<PieIngredient> Planned = new List<PieIngredient>();

		private static readonly Dictionary<string, string> Skipped = new Dictionary<string, string>(StringComparer.Ordinal);

		internal static bool Scanned { get; private set; }

		internal static int Count => Planned.Count;

		internal static IEnumerable<PieIngredient> All => Planned;

		internal static IReadOnlyDictionary<string, string> SkippedMeats => Skipped;

		internal static string NameFor(PieIngredient meat)
		{
			return "NSG_Jerky_" + meat.PrefabName;
		}

		internal static string DisplayFor(PieIngredient meat)
		{
			if (!string.IsNullOrEmpty(meat.Shortened))
			{
				return meat.Shortened + " Jerky";
			}
			return "Jerky";
		}

		internal static void Scan()
		{
			Planned.Clear();
			Skipped.Clear();
			foreach (PieIngredient item in Larder.All)
			{
				if (item.IsMeat)
				{
					if (item.PrefabName.StartsWith("nsg_", StringComparison.OrdinalIgnoreCase) || item.PrefabName.StartsWith("NSG_", StringComparison.Ordinal))
					{
						Skipped[item.PrefabName] = "this mod made it";
					}
					else if (IsNotHangable(item))
					{
						Skipped[item.PrefabName] = "a prepared dish, or already preserved";
					}
					else if (FryGenerator.IsNotFood(item.PrefabName))
					{
						Skipped[item.PrefabName] = "an unbaked intermediate, not a dish";
					}
					else if (item.Health <= 0f && item.Stamina <= 0f)
					{
						Skipped[item.PrefabName] = "no nutrition to preserve";
					}
					else
					{
						Planned.Add(item);
					}
				}
			}
			Scanned = true;
			Log.Info("Jerky: " + Planned.Count + " meat(s) can be hung, " + Skipped.Count + " left out.");
		}

		internal static bool IsNotHangable(PieIngredient food)
		{
			if (food == null)
			{
				return true;
			}
			string[] notHangable = NotHangable;
			foreach (string value in notHangable)
			{
				if (food.PrefabName.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				if (!string.IsNullOrEmpty(food.Shortened) && food.Shortened.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		internal static IEnumerable<ConversionDef> Chains()
		{
			List<ConversionDef> list = new List<ConversionDef>();
			foreach (PieIngredient item in Planned)
			{
				list.Add(new ConversionDef
				{
					From = item.PrefabName,
					To = NameFor(item),
					Note = DisplayFor(item) + ", hung and smoked"
				});
			}
			return list;
		}

		internal static void Build(Func<string, GameObject> find)
		{
			if (!Scanned)
			{
				return;
			}
			int num = 0;
			foreach (PieIngredient item in Planned)
			{
				string name = NameFor(item);
				if (PrefabForge.Has(name))
				{
					continue;
				}
				GameObject val = find(item.PrefabName);
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				GameObject val2 = PrefabForge.MakeItem(val, name, derived: true);
				if (!((Object)(object)val2 == (Object)null))
				{
					ItemDrop component = val2.GetComponent<ItemDrop>();
					SharedData val3 = (((Object)(object)component == (Object)null || component.m_itemData == null) ? null : component.m_itemData.m_shared);
					if (val3 != null)
					{
						val3.m_name = DisplayFor(item);
						val3.m_description = "Dried until it stops being perishable. Less in a bite, far more in a week.";
						val3.m_food = item.Health * 0.7f;
						val3.m_foodStamina = item.Stamina * 0.7f;
						val3.m_foodBurnTime = item.Duration * 2.5f;
						val3.m_foodEitr = item.Eitr;
					}
					num++;
				}
			}
			if (num > 0)
			{
				Log.Info("Hung " + num + " kind(s) of jerky.");
			}
		}

		internal static void ResetForTests()
		{
			Planned.Clear();
			Skipped.Clear();
			Scanned = false;
		}
	}
	internal static class Larder
	{
		private static readonly List<PieIngredient> Foods = new List<PieIngredient>();

		internal static IEnumerable<PieIngredient> All => Foods;

		internal static int Count => Foods.Count;

		internal static List<PieIngredient> Snapshot()
		{
			return new List<PieIngredient>(Foods);
		}

		internal static void Clear()
		{
			Foods.Clear();
		}

		internal static void Add(PieIngredient food)
		{
			if (food != null)
			{
				Foods.Add(food);
			}
		}
	}
	internal static class PieGenerator
	{
		private const float CombinationBonus = 1.25f;

		private const float PlainBonus = 1.1f;

		internal static List<PieRecipe> Build(List<PieIngredient> ingredients, int limit)
		{
			List<PieRecipe> list = new List<PieRecipe>();
			if (ingredients == null || ingredients.Count == 0)
			{
				return list;
			}
			List<PieIngredient> list2 = new List<PieIngredient>();
			List<PieIngredient> list3 = new List<PieIngredient>();
			foreach (PieIngredient ingredient in ingredients)
			{
				if (ingredient != null && !string.IsNullOrEmpty(ingredient.PrefabName))
				{
					(ingredient.IsMeat ? list2 : list3).Add(ingredient);
				}
			}
			foreach (PieIngredient item in list2)
			{
				foreach (PieIngredient item2 in list3)
				{
					list.Add(Combine(item, item2));
				}
			}
			foreach (PieIngredient ingredient2 in ingredients)
			{
				list.Add(Plain(ingredient2));
			}
			list.Sort(delegate(PieRecipe a, PieRecipe b)
			{
				bool flag = DerivedSeal.WasMadeBefore(a.PrefabName);
				bool flag2 = DerivedSeal.WasMadeBefore(b.PrefabName);
				return (flag != flag2) ? ((!flag) ? 1 : (-1)) : (b.Health + b.Stamina).CompareTo(a.Health + a.Stamina);
			});
			if (limit > 0 && list.Count > limit)
			{
				list.RemoveRange(limit, list.Count - limit);
			}
			list.Sort((PieRecipe a, PieRecipe b) => string.Compare(a.PrefabName, b.PrefabName, StringComparison.Ordinal));
			return list;
		}

		private static PieRecipe Combine(PieIngredient meat, PieIngredient green)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			return new PieRecipe
			{
				PrefabName = "NSG_Pie_" + meat.PrefabName + "_" + green.PrefabName,
				DisplayName = meat.Shortened + " and " + green.Shortened + " Pie",
				Health = (meat.Health + green.Health) / 2f * 1.25f,
				Stamina = (meat.Stamina + green.Stamina) / 2f * 1.25f,
				Duration = Mathf.Max(meat.Duration, green.Duration) * 1.25f,
				Colour = Tint(meat.PrefabName + green.PrefabName),
				Ingredients = { meat.PrefabName, green.PrefabName }
			};
		}

		private static PieRecipe Plain(PieIngredient only)
		{
			//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)
			return new PieRecipe
			{
				PrefabName = "NSG_Pie_" + only.PrefabName,
				DisplayName = only.Shortened + " Pie",
				Health = only.Health * 1.1f,
				Stamina = only.Stamina * 1.1f,
				Duration = only.Duration * 1.1f,
				Colour = Tint(only.PrefabName),
				Ingredients = { only.PrefabName }
			};
		}

		internal static Color Tint(string seed)
		{
			//IL_0008: 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)
			if (string.IsNullOrEmpty(seed))
			{
				return Color.white;
			}
			uint num = 2166136261u;
			foreach (char c in seed)
			{
				num ^= c;
				num *= 16777619;
			}
			return Color.HSVToRGB((float)(num % 1000) / 1000f, 0.45f, 0.95f);
		}

		internal static string Shorten(string displayName)
		{
			if (string.IsNullOrEmpty(displayName))
			{
				return string.Empty;
			}
			string text = displayName.Trim();
			string[] array = new string[4] { "Raw ", "Cooked ", "Grilled ", "Uncooked " };
			foreach (string text2 in array)
			{
				if (text.StartsWith(text2, StringComparison.OrdinalIgnoreCase))
				{
					text = text.Substring(text2.Length);
				}
			}
			array = new string[2] { " meat", " Meat" };
			foreach (string text3 in array)
			{
				if (text.EndsWith(text3, StringComparison.Ordinal) && text.Length > text3.Length)
				{
					text = text.Substring(0, text.Length - text3.Length);
				}
			}
			return text.Trim();
		}
	}
	internal sealed class PieRecipe
	{
		internal string PrefabName = string.Empty;

		internal string DisplayName = string.Empty;

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

		internal float Health;

		internal float Stamina;

		internal float Duration;

		internal Color Colour = Color.white;

		internal string Describe()
		{
			return DisplayName + " [" + string.Join(" + ", Ingredients.ToArray()) + "] " + $"hp {Health:0} st {Stamina:0} for {Duration / 60f:0}min";
		}
	}
	internal sealed class PieIngredient
	{
		internal string PrefabName = string.Empty;

		internal string DisplayName = string.Empty;

		internal float Health;

		internal float Stamina;

		internal float Duration;

		internal float Eitr;

		internal bool IsMeat;

		internal string Shortened = string.Empty;
	}
	internal static class Pies
	{
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		internal static class ScanOnLoad
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				try
				{
					Scan();
				}
				catch (Exception ex)
				{
					Log.Warn("Could not read the larder: " + ex.Message);
				}
			}
		}

		private static readonly List<PieRecipe> Planned = new List<PieRecipe>();

		internal static bool Scanned { get; private set; }

		internal static IEnumerable<PieRecipe> Recipes => Planned;

		internal static int Count => Planned.Count;

		internal static void Scan()
		{
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null || instance.m_items == null)
			{
				return;
			}
			List<PieIngredient> list = new List<PieIngredient>();
			Larder.Clear();
			foreach (GameObject item in instance.m_items)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				SharedData val = item.GetComponent<ItemDrop>()?.m_itemData?.m_shared;
				if (val != null && !(val.m_food <= 0f))
				{
					string name = ((Object)item).name;
					bool flag = ModConfig.MatchesFragment(name, ModConfig.PieMeats?.Value);
					bool flag2 = ModConfig.MatchesFragment(name, ModConfig.PieVegetables?.Value);
					PieIngredient pieIngredient = new PieIngredient
					{
						PrefabName = name,
						DisplayName = val.m_name,
						Shortened = PieGenerator.Shorten(Localised(val.m_name)),
						Health = val.m_food,
						Stamina = val.m_foodStamina,
						Duration = val.m_foodBurnTime,
						Eitr = val.m_foodEitr,
						IsMeat = flag
					};
					Larder.Add(pieIngredient);
					if ((flag || flag2) && !FryGenerator.IsOurs(name) && !FryGenerator.IsNotFood(name))
					{
						list.Add(pieIngredient);
					}
				}
			}
			Planned.Clear();
			Planned.AddRange(PieGenerator.Build(list, ModConfig.PieLimit?.Value ?? 40));
			Scanned = true;
			Fryer.Plan();
			Jerky.Scan();
			AnimationVocabulary.Harvest(instance);
			Log.Info($"Larder: {Larder.Count} food(s), {list.Count} pie ingredient(s), " + $"{Planned.Count} pie(s) planned. " + ((ModConfig.PiesEnabled != null && ModConfig.PiesEnabled.Value) ? "Baking is ON." : "Baking is off - run nsg.pies to see the list, and turn on Content.Pies to bake them."));
		}

		private static string Localised(string token)
		{
			if (string.IsNullOrEmpty(token))
			{
				return string.Empty;
			}
			if (!token.StartsWith("$", StringComparison.Ordinal))
			{
				return token;
			}
			string text = token.TrimStart('$');
			if (text.StartsWith("item_", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(5);
			}
			string[] array = text.Split('_');
			List<string> list = new List<string>();
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				if (text2.Length != 0)
				{
					list.Add(char.ToUpperInvariant(text2[0]) + text2.Substring(1));
				}
			}
			if (list.Count != 0)
			{
				return string.Join(" ", list.ToArray());
			}
			return text;
		}

		internal static void Arm()
		{
			ForgePatches.Register(Bake);
		}

		private static void Bake(Func<string, GameObject> find)
		{
			if (ModConfig.PiesEnabled == null || !ModConfig.PiesEnabled.Value)
			{
				return;
			}
			if (!Scanned)
			{
				Scan();
			}
			if (Planned.Count == 0)
			{
				return;
			}
			string text = ModConfig.PieBaseItem?.Value ?? "QueensJam";
			GameObject val = find(text);
			if ((Object)(object)val == (Object)null)
			{
				Log.Warn("Pies: no item named '" + text + "' to build pies out of - set Content.PieBaseItem to a food that exists.");
				return;
			}
			string text2 = ModConfig.PieStation?.Value ?? "nsg_pie_counter";
			GameObject val2 = PrefabForge.Find(text2) ?? find(text2);
			CraftingStation val3 = (((Object)(object)val2 == (Object)null) ? null : val2.GetComponent<CraftingStation>());
			if ((Object)(object)val3 == (Object)null)
			{
				Log.Warn("Pies: no crafting station named '" + text2 + "' - set Content.PieStation to a buildable that has one.");
				return;
			}
			int num = 0;
			foreach (PieRecipe item in Planned)
			{
				if (PrefabForge.Has(item.PrefabName))
				{
					continue;
				}
				GameObject val4 = PrefabForge.MakeItem(val, item.PrefabName, derived: true);
				if (!((Object)(object)val4 == (Object)null))
				{
					ItemDrop component = val4.GetComponent<ItemDrop>();
					SharedData val5 = component?.m_itemData?.m_shared;
					if (val5 != null)
					{
						val5.m_name = item.DisplayName;
						val5.m_food = item.Health;
						val5.m_foodStamina = item.Stamina;
						val5.m_foodBurnTime = item.Duration;
					}
					Recipe val6 = BuildRecipe(find, item, component, val3);
					if ((Object)(object)val6 != (Object)null)
					{
						PrefabForge.AddRecipe(val6);
					}
					num++;
				}
			}
			if (num > 0)
			{
				Log.Info("Baked " + num + " pie(s).");
			}
		}

		private static Recipe BuildRecipe(Func<string, GameObject> find, PieRecipe pie, ItemDrop result, CraftingStation station)
		{
			//IL_008e: 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_009b: 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_00ae: Expected O, but got Unknown
			if ((Object)(object)result == (Object)null)
			{
				return null;
			}
			List<Requirement> list = new List<Requirement>();
			foreach (string ingredient in pie.Ingredients)
			{
				GameObject val = find(ingredient);
				ItemDrop val2 = (((Object)(object)val == (Object)null) ? null : val.GetComponent<ItemDrop>());
				if ((Object)(object)val2 == (Object)null)
				{
					Log.Warn("Pies: '" + pie.DisplayName + "' wants '" + ingredient + "', which is not there any more. Skipping the recipe.");
					return null;
				}
				list.Add(new Requirement
				{
					m_resItem = val2,
					m_amount = 1,
					m_recover = true
				});
			}
			if (list.Count == 0)
			{
				return null;
			}
			Recipe obj = ScriptableObject.CreateInstance<Recipe>();
			((Object)obj).name = "Recipe_" + pie.PrefabName;
			obj.m_item = result;
			obj.m_amount = 1;
			obj.m_enabled = true;
			obj.m_craftingStation = station;
			obj.m_minStationLevel = 1;
			obj.m_resources = list.ToArray();
			return obj;
		}
	}
}
namespace Norntastic.Emotes
{
	internal static class EmoteBroadcast
	{
		internal const string ZdoKey = "nsg.emote";

		private static int _counter;

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

		internal static void Reset()
		{
			_counter = 0;
			Heard.Clear();
		}

		internal static void Publish(Player player, string emoteName)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				ZDO val = ZdoOf(player);
				if (val != null)
				{
					_counter++;
					val.Set("nsg.emote", _counter + ":" + emoteName);
				}
			}
		}

		internal static void Tick(string soundDirectory)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null)
			{
				return;
			}
			foreach (Player item in allPlayers)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				ZDO val = ZdoOf(item);
				if (val == null)
				{
					continue;
				}
				string text = val.GetString("nsg.emote", string.Empty);
				if (!string.IsNullOrEmpty(text))
				{
					string key = item.GetPlayerID().ToString();
					if (!Heard.TryGetValue(key, out var value))
					{
						Heard[key] = text;
					}
					else if (!(value == text))
					{
						Heard[key] = text;
						Play(localPlayer, item, text, soundDirectory);
					}
				}
			}
		}

		private static void Play(Player local, Player source, string payload, string directory)
		{
			//IL_003f: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			int num = payload.IndexOf(':');
			if (num < 0 || num + 1 >= payload.Length)
			{
				return;
			}
			EmoteDef emoteDef = EmoteLibrary.Find(payload.Substring(num + 1));
			if (emoteDef == null || string.IsNullOrEmpty(emoteDef.Sound))
			{
				return;
			}
			float num2 = Vector3.Distance(((Component)local).transform.position, ((Component)source).transform.position);
			if (!(num2 > emoteDef.Range))
			{
				AudioClip val = EmoteSounds.Get(directory, emoteDef.Sound);
				if (!((Object)(object)val == (Object)null))
				{
					AudioSource.PlayClipAtPoint(val, ((Component)source).transform.position, emoteDef.Volume);
					Log.Debug($"Heard '{emoteDef.Name}' from {num2:0}m away.");
				}
			}
		}

		private static ZDO ZdoOf(Player player)
		{
			ZNetView value = Traverse.Create((object)player).Field<ZNetView>("m_nview").Value;
			if ((Object)(object)value == (Object)null || !value.IsValid())
			{
				return null;
			}
			return value.GetZDO();
		}
	}
	internal static class EmoteChat
	{
		[HarmonyPatch(typeof(Terminal), "TryRunCommand")]
		internal static class TypedCommandPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(string text)
			{
				if (string.IsNullOrEmpty(text))
				{
					return true;
				}
				string text2 = text.Trim().TrimStart('/').Trim();
				if (text2.Length == 0)
				{
					return true;
				}
				if (text2.IndexOf(' ') >= 0)
				{
					return true;
				}
				EmoteDef emoteDef = EmoteLibrary.Find(text2);
				if (emoteDef == null)
				{
					return true;
				}
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return true;
				}
				if (!Emotes.Perform(localPlayer, emoteDef))
				{
					Log.Info("'" + text2 + "' was refused right now - mid-swing, sitting or in the air.");
				}
				else
				{
					Log.Debug("'" + text2 + "' came in through the chat box.");
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Chat), "isAllowedCommand")]
		internal static class AllowEmotesInChatPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ConsoleCommand cmd, ref bool __result)
			{
				if (!__result && cmd != null && !string.IsNullOrEmpty(cmd.Command) && EmoteLibrary.Find(cmd.Command) != null)
				{
					__result = true;
				}
			}
		}
	}
	internal sealed class EmoteDef
	{
		internal string Name = string.Empty;

		internal string RidesAnimation = "roar";

		internal string Sound = string.Empty;

		internal float Range = 24f;

		internal float Volume = 1f;

		internal string Blurb = string.Empty;
	}
	internal static class EmoteLibrary
	{
		internal static readonly List<EmoteDef> All = new List<EmoteDef>
		{
			new EmoteDef
			{
				Name = "rawr",
				RidesAnimation = "roar",
				Sound = "rawr.wav",
				Range = 28f,
				Blurb = "RAWR."
			}
		};

		internal static readonly string[] KnownVanilla = new string[11]
		{
			"blowkiss", "bow", "cheer", "cry", "dance", "flex", "kneel", "laugh", "roar", "shrug",
			"sit"
		};

		internal static EmoteDef Find(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			foreach (EmoteDef item in All)
			{
				if (string.Equals(item.Name, name, StringComparison.OrdinalIgnoreCase))
				{
					return item;
				}
			}
			return null;
		}

		internal static string[] SoundFiles()
		{
			List<string> list = new List<string>();
			foreach (EmoteDef item in All)
			{
				if (!string.IsNullOrEmpty(item.Sound) && !list.Contains(item.Sound))
				{
					list.Add(item.Sound);
				}
			}
			return list.ToArray();
		}
	}
	internal static class Emotes
	{
		private static string _directory = string.Empty;

		private const float Interval = 0.25f;

		private static float _timer;

		internal static int PerformedThisSession { get; private set; }

		internal static void Init(string configDirectory)
		{
			_directory = configDirectory;
			EmoteSounds.Unpack(configDirectory, EmoteLibrary.SoundFiles());
			EmoteBroadcast.Reset();
			Log.Info($"Emotes ready: {EmoteLibrary.All.Count} registered. Try 'nsg.emote rawr'.");
		}

		internal static bool Perform(Player player, EmoteDef emote)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || emote == null)
			{
				return false;
			}
			if (!player.StartEmote(emote.RidesAnimation, true))
			{
				return false;
			}
			PerformedThisSession++;
			EmoteBroadcast.Publish(player, emote.Name);
			AudioClip val = EmoteSounds.Get(_directory, emote.Sound);
			if ((Object)(object)val != (Object)null)
			{
				AudioSource.PlayClipAtPoint(val, ((Component)player).transform.position, emote.Volume);
			}
			return true;
		}

		internal static void Tick(float dt)
		{
			_timer += dt;
			if (!(_timer < 0.25f))
			{
				_timer = 0f;
				EmoteBroadcast.Tick(_directory);
			}
		}
	}
	internal static class EmoteSounds
	{
		private static readonly Dictionary<string, AudioClip> Cache = new Dictionary<string, AudioClip>();

		private static readonly HashSet<string> Failed = new HashSet<string>();

		internal static void Unpack(string directory, params string[] names)
		{
			if (string.IsNullOrEmpty(directory))
			{
				return;
			}
			try
			{
				Directory.CreateDirectory(directory);
				foreach (string text in names)
				{
					string text2 = Path.Combine(directory, text);
					if (!File.Exists(text2))
					{
						byte[] array = Embedded(text);
						if (array == null)
						{
							Log.Warn("No embedded copy of '" + text + "' in the assembly.");
							continue;
						}
						File.WriteAllBytes(text2, array);
						Log.Info("Wrote emote sound " + text2 + ". Replace it to change the sound; it is never overwritten.");
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warn("Could not unpack the emote sounds: " + ex.Message);
			}
		}

		private static byte[] Embedded(string name)
		{
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Norntastic." + name);
			if (stream == null)
			{
				return null;
			}
			byte[] array = new byte[stream.Length];
			int num;
			for (int i = 0; i < array.Length; i += num)
			{
				num = stream.Read(array, i, array.Length - i);
				if (num <= 0)
				{
					break;
				}
			}
			return array;
		}

		internal static AudioClip Get(string directory, string name)
		{
			if (string.IsNullOrEmpty(name) || Failed.Contains(name))
			{
				return null;
			}
			if (Cache.TryGetValue(name, out var value))
			{
				return value;
			}
			try
			{
				string text = Path.Combine(directory ?? string.Empty, name);
				if (!File.Exists(text))
				{
					Failed.Add(name);
					Log.Warn("Emote sound '" + text + "' is not there. That emote will be silent.");
					return null;
				}
				AudioClip val = FromWav(File.ReadAllBytes(text), name);
				if ((Object)(object)val == (Object)null)
				{
					Failed.Add(name);
					return null;
				}
				Cache[name] = val;
				return val;
			}
			catch (Exception ex)
			{
				Failed.Add(name);
				Log.Warn("Could not read emote sound '" + name + "': " + ex.Message);
				return null;
			}
		}

		private static AudioClip FromWav(byte[] bytes, string name)
		{
			if (bytes == null || bytes.Length < 12 || bytes[0] != 82 || bytes[1] != 73 || bytes[2] != 70 || bytes[3] != 70)
			{
				Log.Warn("'" + name + "' is not a RIFF/WAV file.");
				return null;
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = -1;
			int num5 = 0;
			int num6 = 12;
			while (num6 + 8 <= bytes.Length)
			{
				string text = Encoding.ASCII.GetString(bytes, num6, 4);
				int num7 = BitConverter.ToInt32(bytes, num6 + 4);
				int num8 = num6 + 8;
				if (num7 < 0 || num8 + num7 > bytes.Length)
				{
					num7 = bytes.Length - num8;
				}
				if (text == "fmt ")
				{
					num = BitConverter.ToInt16(bytes, num8 + 2);
					num2 = BitConverter.ToInt32(bytes, num8 + 4);
					num3 = BitConverter.ToInt16(bytes, num8 + 14);
				}
				else if (text == "data")
				{
					num4 = num8;
					num5 = num7;
				}
				num6 = num8 + num7 + num7 % 2;
			}
			if (num4 < 0 || num <= 0 || num2 <= 0)
			{
				Log.Warn("'" + name + "' has no usable fmt/data chunks.");
				return null;
			}
			if (num3 != 16)
			{
				Log.Warn($"'{name}' is {num3}-bit. Re-export it as 16-bit PCM WAV, mono - " + "a stereo clip will not come from the right direction in the world.");
				return null;
			}
			int num9 = num5 / 2;
			float[] array = new float[num9];
			for (int i = 0; i < num9; i++)
			{
				array[i] = (float)BitConverter.ToInt16(bytes, num4 + i * 2) / 32768f;
			}
			AudioClip obj = AudioClip.Create(name, num9 / num, num, num2, false);
			obj.SetData(array, 0);
			if (num > 1)
			{
				Log.Warn($"'{name}' is {num}-channel. It will play, but Unity cannot " + "place a stereo clip in the world, so nobody will hear which direction it came from. Mono is better for an emote.");
			}
			return obj;
		}
	}
}
namespace Norntastic.Effects
{
	internal static class Afflictions
	{
		private static readonly Dictionary<string, List<AfflictionSpec>> ByNode = new Dictionary<string, List<AfflictionSpec>>();

		internal static int AppliedThisSession { get; private set; }

		internal static int ClauseCount { get; private set; }

		internal static int LiveCount
		{
			get
			{
				PerkState current = PerkState.Current;
				if (current == null)
				{
					return 0;
				}
				int num = 0;
				foreach (KeyValuePair<string, List<AfflictionSpec>> item in ByNode)
				{
					if (current.GetRank(item.Key) > 0)
					{
						num += item.Value.Count;
					}
				}
				return num;
			}
		}

		internal static int UnresolvedCount()
		{
			int num = 0;
			foreach (KeyValuePair<string, List<AfflictionSpec>> item in ByNode)
			{
				foreach (AfflictionSpec item2 in item.Value)
				{
					if (item2.Unresolved)
					{
						num++;
					}
				}
			}
			return num;
		}

		internal static void Rebuild()
		{
			ByNode.Clear();
			ClauseCount = 0;
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				foreach (PerkNode node in value.Nodes)
				{
					if (node.Afflictions != null && node.Afflictions.Count != 0)
					{
						ByNode[node.Id] = node.Afflictions;
						ClauseCount += node.Afflictions.Count;
					}
				}
			}
		}

		internal static bool Implements(string nodeId)
		{
			return ByNode.ContainsKey(nodeId);
		}

		internal static void FromHit(Character target, HitData hit, PerkState state)
		{
			//IL_007b: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			if (ByNode.Count == 0 || (Object)(object)target == (Object)null || hit == null || state == null || target.IsDead())
			{
				return;
			}
			foreach (KeyValuePair<string, List<AfflictionSpec>> item in ByNode)
			{
				int rank = state.GetRank(item.Key);
				if (rank <= 0)
				{
					continue;
				}
				foreach (AfflictionSpec item2 in item.Value)
				{
					if (!item2.Unresolved && ((int)item2.Skill == 0 || item2.Skill == hit.m_skill) && (item2.While == ConditionKind.Always || Conditions.Holds(item2.While, item2.WhileValue, item2.WhileText, Player.m_localPlayer)) && !(HitConditions.Factor(new HitModifier
					{
						When = item2.When,
						ConditionValue = item2.ConditionValue,
						ConditionText = item2.ConditionText
					}, target) <= 0f))
					{
						float num = item2.ChanceAt(rank);
						if (!(num <= 0f) && (!(num < 100f) || !(Random.Range(0f, 100f) >= num)))
						{
							Apply(target, item2);
						}
					}
				}
			}
		}

		private static void Apply(Character target, AfflictionSpec spec)
		{
			if (spec.ResolvedHash != 0 || Resolve(spec))
			{
				SEMan sEMan = target.GetSEMan();
				if (sEMan != null)
				{
					sEMan.AddStatusEffect(spec.ResolvedHash, spec.ResetTime, 0, 0f, (short)0);
					AppliedThisSession++;
				}
			}
		}

		private static bool Resolve(AfflictionSpec spec)
		{
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(spec.EffectName);
			if ((Object)(object)instance.GetStatusEffect(stableHashCode) != (Object)null)
			{
				spec.ResolvedHash = stableHashCode;
				return true;
			}
			string text = spec.EffectName.TrimStart('$').Replace("se_", "").ToLowerInvariant();
			if (instance.m_StatusEffects != null && text.Length > 2)
			{
				foreach (StatusEffect statusEffect in instance.m_StatusEffects)
				{
					if (statusEffect != null && statusEffect.m_name != null && statusEffect.m_name.ToLowerInvariant().IndexOf(text, StringComparison.Ordinal) >= 0)
					{
						spec.ResolvedHash = statusEffect.NameHash();
						Log.Info("Perk '" + spec.NodeId + "' asked for '" + spec.EffectName + "' and this game calls it '" + statusEffect.m_name + "'. Matched on name.");
						return true;
					}
				}
			}
			spec.Unresolved = true;
			Log.Warn("Perk '" + spec.NodeId + "' wants a status effect matching '" + spec.EffectName + "', and nothing in this game's list is close. That part of the perk is off for the session. Run nsg.effects for the real names, then fix it in config/Norntastic/perks.json - no rebuild needed.");
			return false;
		}

		internal static List<string> KnownNames()
		{
			List<string> list = new List<string>();
			ObjectDB instance = ObjectDB.instance;
			if (instance?.m_StatusEffects == null)
			{
				return list;
			}
			foreach (StatusEffect statusEffect in instance.m_StatusEffects)
			{
				if ((Object)(object)statusEffect != (Object)null && !string.IsNullOrEmpty(statusEffect.m_name))
				{
					list.Add(statusEffect.m_name);
				}
			}
			list.Sort();
			return list;
		}
	}
	internal sealed class AfflictionSpec
	{
		internal string NodeId = string.Empty;

		internal string EffectName = string.Empty;

		internal SkillType Skill;

		internal HitConditionKind When;

		internal float ConditionValue;

		internal ConditionKind While;

		internal float WhileValue;

		internal string WhileText = string.Empty;

		internal string ConditionText = string.Empty;

		internal float[] Chance = new float[0];

		internal bool ResetTime = true;

		internal bool Unresolved;

		internal int ResolvedHash;

		internal float ChanceAt(int rank)
		{
			if (Chance.Length == 0 || rank <= 0)
			{
				return 0f;
			}
			if (rank < Chance.Length)
			{
				return Chance[rank - 1];
			}
			return Chance[Chance.Length - 1];
		}
	}
	internal static class Cadence
	{
		private static readonly Dictionary<string, int> Running = new Dictionary<string, int>();

		private static readonly Dictionary<string, HitCounter> PerTarget = new Dictionary<string, HitCounter>();

		internal static void Reset()
		{
			Running.Clear();
			PerTarget.Clear();
		}

		internal static bool Due(EffectSpec spec, string key, TriggerContext context)
		{
			switch (spec.TriggerScope)
			{
			case TriggerScope.String:
			{
				int current = ComboCounter.Current;
				if (current > 0)
				{
					return current % spec.TriggerEvery == 0;
				}
				return false;
			}
			case TriggerScope.Target:
			{
				if ((Object)(object)context.Target == (Object)null)
				{
					return false;
				}
				if (!PerTarget.TryGetValue(key, out var value2))
				{
					value2 = new HitCounter(spec.TriggerEvery);
					PerTarget[key] = value2;
				}
				return value2.Advance(context.Target);
			}
			default:
			{
				Running.TryGetValue(key, out var value);
				value++;
				Running[key] = value;
				return value % spec.TriggerEvery == 0;
			}
			}
		}

		internal static int RunningCountForTests(string key)
		{
			Running.TryGetValue(key, out var value);
			return value;
		}
	}
	internal static class Conditions
	{
		private static float _stillSince;

		private static float _runningSince;

		private static Vector3 _lastPosition;

		private static float _proximityAge;

		private static int _enemiesNear;

		private static int _alliesNear;

		private static float _scannedRadius;

		private const float ProximityInterval = 0.5f;

		private const float DefaultRadius = 12f;

		private static readonly List<Character> Scratch = new List<Character>();

		internal static void Tick(Player player, float dt)
		{
			//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_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)
			//IL_0020: 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)
			if (!((Object)(object)player == (Object)null))
			{
				Vector3 position = ((Component)player).transform.position;
				Vector3 val = position - _lastPosition;
				if (((Vector3)(ref val)).sqrMagnitude < 0.0004f)
				{
					_stillSince += dt;
				}
				else
				{
					_stillSince = 0f;
				}
				_lastPosition = position;
				if (((Character)player).IsRunning())
				{
					_runningSince += dt;
				}
				else
				{
					_runningSince = 0f;
				}
				_proximityAge += dt;
			}
		}

		internal static float Multiplier(EffectSpec spec, Player player)
		{
			if (!spec.ConditionScales || (Object)(object)player == (Object)null)
			{
				return 1f;
			}
			float num;
			switch (spec.Condition)
			{
			case ConditionKind.EnemiesNearby:
				num = NearbyEnemies(player, spec);
				break;
			case ConditionKind.AlliesNearby:
				num = NearbyAllies(player, spec);
				break;
			default:
				return 1f;
			}
			if (spec.ConditionMax > 0f)
			{
				num = Mathf.Min(num, spec.ConditionMax);
			}
			return num;
		}

		internal static bool Holds(ConditionKind kind, float value, string text, Player player)
		{
			if (kind == ConditionKind.Always)
			{
				return true;
			}
			EffectSpec spec = new EffectSpec
			{
				Condition = kind,
				ConditionValue = value,
				ConditionText = (text ?? string.Empty)
			};
			return One(kind, value, spec, player);
		}

		internal static bool Holds(EffectSpec spec, Player player)
		{
			if (!One(spec.Condition, spec.ConditionValue, spec, player))
			{
				return false;
			}
			if (spec.Condition2 == ConditionKind.Always)
			{
				return true;
			}
			return One(spec.Condition2, spec.Condition2Value, spec, player);
		}

		private static bool One(ConditionKind kind, float value, EffectSpec spec, Player player)
		{
			if (kind == ConditionKind.Always)
			{
				return true;
			}
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			switch (kind)
			{
			case ConditionKind.Unarmored:
				return Equipment.IsUnarmored(player);
			case ConditionKind.Armored:
				return !Equipment.IsUnarmored(player);
			case ConditionKind.EmptyHanded:
				return Equipment.IsEmptyHanded(player);
			case ConditionKind.FullArmorSet:
				return Equipment.IsFullMatchedSet(player);
			case ConditionKind.ShieldEquipped:
				return Equipment.HasShield(player);
			case ConditionKind.NoShield:
				return !Equipment.HasShield(player);
			case ConditionKind.TorchEquipped:
				return Equipment.HasTorch(player);
			case ConditionKind.TwoHanded:
				return Equipment.IsTwoHanded(player);
			case ConditionKind.OneHanded:
				return Equipment.IsOneHanded(player);
			case ConditionKind.DualWielding:
				return Offhand.IsDualWielding(player);
			case ConditionKind.OffhandFull:
				return Offhand.KindOf(player) != OffhandKind.Empty;
			case ConditionKind.TrinketEquipped:
				return Equipment.HasTrinket(player);
			case ConditionKind.HealthBelow:
				return HealthPercent(player) < value;
			case ConditionKind.HealthAbove:
				return HealthPercent(player) > value;
			case ConditionKind.FullHealth:
				return HealthPercent(player) >= 99.5f;
			case ConditionKind.StaminaBelow:
				return ((Character)player).GetStaminaPercentage() * 100f < value;
			case ConditionKind.StaminaAbove:
				return ((Character)player).GetStaminaPercentage() * 100f > value;
			case ConditionKind.EitrBelow:
				return ((Character)player).GetEitrPercentage() * 100f < value;
			case ConditionKind.EitrAbove:
				return ((Character)player).GetEitrPercentage() * 100f > value;
			case ConditionKind.StandingStill:
				return _stillSince >= Mathf.Max(0.1f, value);
			case ConditionKind.Running:
				return _runningSince >= Mathf.Max(0f, value);
			case ConditionKind.Crouching:
				return ((Character)player).IsCrouching();
			case ConditionKind.Swimming:
				return ((Character)player).IsSwimming();
			case ConditionKind.Airborne:
				return !((Character)player).IsOnGround();
			case ConditionKind.Blocking:
				return ((Character)player).IsBlocking();
			case ConditionKind.Sheltered:
				return player.InShelter();
			case ConditionKind.Wet:
				return HasVanilla(player, SEMan.s_statusEffectWet);
			case ConditionKind.Cold:
				if (!HasVanilla(player, SEMan.s_statusEffectCold))
				{
					return HasVanilla(player, SEMan.s_statusEffectFreezing);
				}
				return true;
			case ConditionKind.Rested:
				return HasVanilla(player, SEMan.s_statusEffectRested);
			case ConditionKind.Burning:
				return HasVanilla(player, SEMan.s_statusEffectBurning);
			case ConditionKind.Encumbered:
				return HasVanilla(player, SEMan.s_statusEffectEncumbered);
			case ConditionKind.CarryOver:
				return CarryFraction(player) * 100f > value;
			case ConditionKind.CarryUnder:
				return CarryFraction(player) * 100f < value;
			case ConditionKind.Night:
				return EnvMan.IsNight();
			case ConditionKind.Day:
				return EnvMan.IsDay();
			case ConditionKind.HasStatusEffect:
				return HasNamed(player, spec.ConditionText);
			case ConditionKind.Intoxicated:
				return IsIntoxicated(player);
			case ConditionKind.EnemiesNearby:
				if (!spec.ConditionScales)
				{
					return NearbyEnemies(player, spec) >= Threshold(value);
				}
				return true;
			case ConditionKind.AlliesNearby:
				if (!spec.ConditionScales)
				{
					return NearbyAllies(player, spec) >= Threshold(value);
				}
				return true;
			case ConditionKind.Alone:
				return NearbyAllies(player, spec) == 0;
			case ConditionKind.RecentlyKilled:
				return Within(TriggerKind.Kill, value);
			case ConditionKind.RecentlyDamaged:
				return Within(TriggerKind.TookDamage, value);
			case ConditionKind.RecentlyParried:
				return Within(TriggerKind.Parried, value);
			case ConditionKind.RecentlyBlocked:
				return Within(TriggerKind.Blocked, value);
			case ConditionKind.RecentlyDodged:
				return Within(TriggerKind.Dodged, value);
			case ConditionKind.RecentlyBuilt:
				return Within(TriggerKind.Built, value);
			case ConditionKind.RecentlyCrafted:
				return Within(TriggerKind.Crafted, value);
			case ConditionKind.RecentlyBrewed:
				return Within(TriggerKind.Brewed, value);
			case ConditionKind.PowerActive:
				return GuardianPowers.IsActive(player);
			case ConditionKind.PowerReady:
				if (!GuardianPowers.IsActive(player))
				{
					return player.m_guardianPowerCooldown <= 0f;
				}
				return false;
			default:
				return true;
			}
		}

		private static bool Within(TriggerKind kind, float seconds)
		{
			return TriggerBus.Within(kind, (seconds > 0f) ? seconds : 5f);
		}

		private static int Threshold(float value)
		{
			if (!(value > 0f))
			{
				return 1;
			}
			return Mathf.RoundToInt(value);
		}

		private static float HealthPercent(Player player)
		{
			float maxHealth = ((Character)player).GetMaxHealth();
			if (!(maxHealth <= 0f))
			{
				return ((Character)player).GetHealth() / maxHealth * 100f;
			}
			return 100f;
		}

		private static float CarryFraction(Player player)
		{
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return 0f;
			}
			float maxCarryWeight = player.GetMaxCarryWeight();
			if (maxCarryWeight <= 0f)
			{
				return 0f;
			}
			return inventory.GetTotalWeight() / maxCarryWeight;
		}

		private static bool HasVanilla(Player player, int nameHash)
		{
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan != null)
			{
				return sEMan.HaveStatusEffect(nameHash);
			}
			return false;
		}

		private static bool HasNamed(Player player, string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null)
			{
				return false;
			}
			List<StatusEffect> statusEffects = sEMan.GetStatusEffects();
			if (statusEffects == null)
			{
				return false;
			}
			foreach (StatusEffect item in statusEffects)
			{
				if (!((Object)(object)item == (Object)null) && Matches(item, name))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsIntoxicated(Player player)
		{
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null)
			{
				return false;
			}
			List<StatusEffect> statusEffects = sEMan.GetStatusEffects();
			if (statusEffects == null)
			{
				return false;
			}
			string[] array = ModConfig.IntoxicantNames();
			foreach (StatusEffect item in statusEffects)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				string[] array2 = array;
				foreach (string fragment in array2)
				{
					if (Matches(item, fragment))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool Matches(StatusEffect effect, string fragment)
		{
			if (string.IsNullOrEmpty(fragment))
			{
				return false;
			}
			string name = effect.m_name;
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			return name.IndexOf(fragment, StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static void ScanIfStale(Player player, float radius)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (_proximityAge < 0.5f && radius <= _scannedRadius)
			{
				return;
			}
			_proximityAge = 0f;
			_scannedRadius = radius;
			_enemiesNear = 0;
			_alliesNear = 0;
			Scratch.Clear();
			Character.GetCharactersInRange(((Component)player).transform.position, radius, Scratch);
			foreach (Character item in Scratch)
			{
				if (!((Object)(object)item == (Object)null) && !item.IsDead() && !((Object)(object)item == (Object)(object)player))
				{
					if (item.IsPlayer() || item.IsTamed())
					{
						_alliesNear++;
					}
					else
					{
						_enemiesNear++;
					}
				}
			}
			Scratch.Clear();
		}

		private static float RadiusOf(EffectSpec spec)
		{
			if (!(spec.ConditionRadius > 0f))
			{
				return 12f;
			}
			return spec.ConditionRadius;
		}

		private static int NearbyEnemies(Player player, EffectSpec spec)
		{
			ScanIfStale(player, RadiusOf(spec));
			return _enemiesNear;
		}

		private static int NearbyAllies(Player player, EffectSpec spec)
		{
			ScanIfStale(player, RadiusOf(spec));
			return _alliesNear;
		}

		internal static void Reset()
		{
			_stillSince = 0f;
			_runningSince = 0f;
			_proximityAge = 0.5f;
			_scannedRadius = 0f;
			_enemiesNear = 0;
			_alliesNear = 0;
		}
	}
	internal static class EffectAggregator
	{
		internal delegate void Sink(EffectKind kind, SkillType skill, bool allSkills, float value);

		private static readonly Dictionary<EffectKind, float> Totals = new Dictionary<EffectKind, float>();

		private static readonly Dictionary<SkillType, float> DamageBySkill = new Dictionary<SkillType, float>();

		private static readonly Dictionary<SkillType, float> LevelsBySkill = new Dictionary<SkillType, float>();

		private static readonly Dictionary<SkillType, float> XpBySkill = new Dictionary<SkillType, float>();

		private static readonly Dictionary<EffectKind, Dictionary<SkillType, float>> ScopedTotals = new Dictionary<EffectKind, Dictionary<SkillType, float>>();

		private static float _allDamagePct;

		private static float _allLevels;

		private static float _allXpPct;

		internal static int ActiveEffectCount { get; private set; }

		internal static int ConditionalHeldBack { get; private set; }

		internal static float Pct(EffectKind kind)
		{
			if (!Totals.TryGetValue(kind, out var value))
			{
				return 0f;
			}
			return value;
		}

		internal static float Pct(EffectKind kind, SkillType skill)
		{
			//IL_0007: 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)
			float num = Pct(kind);
			if ((int)skill == 0)
			{
				return num;
			}
			if (ScopedTotals.TryGetValue(kind, out var value) && value.TryGetValue(skill, out var value2))
			{
				num += value2;
			}
			return num;
		}

		internal static float Mul(EffectKind kind)
		{
			return 1f + Pct(kind) / 100f;
		}

		internal static float MulAtLeast(EffectKind kind, float floor)
		{
			float num = Mul(kind);
			if (!(num < floor))
			{
				return num;
			}
			return floor;
		}

		internal static float DamageMultiplier(SkillType type)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			float num = _allDamagePct;
			if (DamageBySkill.TryGetValue(type, out var value))
			{
				num += value;
			}
			return 1f + num / 100f;
		}

		internal static float BonusLevels(SkillType type)
		{
			//IL_000a: 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)
			float num = _allLevels + Prestige.EffectiveLevelBonus(PerkState.Current, type);
			if (LevelsBySkill.TryGetValue(type, out var value))
			{
				num += value;
			}
			return num;
		}

		internal static float XpMultiplier(SkillType type)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			float num = _allXpPct;
			if (XpBySkill.TryGetValue(type, out var value))
			{
				num += value;
			}
			return 1f + num / 100f;
		}

		internal static void Rebuild(PerkState state, Player player)
		{
			Totals.Clear();
			ScopedTotals.Clear();
			DamageBySkill.Clear();
			LevelsBySkill.Clear();
			XpBySkill.Clear();
			_allDamagePct = 0f;
			_allLevels = 0f;
			_allXpPct = 0f;
			ActiveEffectCount = 0;
			ConditionalHeldBack = 0;
			Immunities.Rebuild(state);
			if (state == null)
			{
				return;
			}
			foreach (KeyValuePair<string, int> item in state.Allocated)
			{
				int value = item.Value;
				if (value <= 0)
				{
					continue;
				}
				PerkNode perkNode = PerkDatabase.Node(item.Key);
				if (perkNode?.Effects == null)
				{
					continue;
				}
				foreach (EffectSpec effect in perkNode.Effects)
				{
					if (effect.IsContinuous)
					{
						if (!Conditions.Holds(effect, player))
						{
							ConditionalHeldBack++;
							continue;
						}
						Apply(effect, effect.ValueAt(value) * Conditions.Multiplier(effect, player));
						ActiveEffectCount++;
					}
				}
			}
			TimedBuffs.Contribute(Contribute);
			AuraReceiver.Contribute(Contribute);
		}

		private static void Contribute(EffectKind kind, SkillType skill, bool allSkills, float value)
		{
			//IL_0035: 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_0073: 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)
			if (value == 0f)
			{
				return;
			}
			switch (kind)
			{
			case EffectKind.DamagePct:
				if (allSkills)
				{
					_allDamagePct += value;
				}
				else
				{
					Add(DamageBySkill, skill, value);
				}
				break;
			case EffectKind.SkillLevel:
				if (allSkills)
				{
					_allLevels += value;
				}
				else
				{
					Add(LevelsBySkill, skill, value);
				}
				break;
			case EffectKind.XpRatePct:
				if (allSkills)
				{
					_allXpPct += value;
				}
				else
				{
					Add(XpBySkill, skill, value);
				}
				break;
			default:
				AddTotal(kind, skill, allSkills, value);
				break;
			}
			ActiveEffectCount++;
		}

		private static void Apply(EffectSpec spec, float value)
		{
			//IL_0041: 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_008f: 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)
			if (value == 0f)
			{
				return;
			}
			switch (spec.Kind)
			{
			case EffectKind.DamagePct:
				if (spec.AppliesToAllSkills)
				{
					_allDamagePct += value;
				}
				else
				{
					Add(DamageBySkill, spec.Skill, value);
				}
				break;
			case EffectKind.SkillLevel:
				if (spec.AppliesToAllSkills)
				{
					_allLevels += value;
				}
				else
				{
					Add(LevelsBySkill, spec.Skill, value);
				}
				break;
			case EffectKind.XpRatePct:
				if (spec.AppliesToAllSkills)
				{
					_allXpPct += value;
				}
				else
				{
					Add(XpBySkill, spec.Skill, value);
				}
				break;
			default:
				AddTotal(spec.Kind, spec.Skill, spec.AppliesToAllSkills, value);
				break;
			}
		}

		private static void AddTotal(EffectKind kind, SkillType skill, bool allSkills, float value)
		{
			//IL_0003: 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)
			if (allSkills || (int)skill == 0)
			{
				Totals.TryGetValue(kind, out var value2);
				Totals[kind] = value2 + value;
				return;
			}
			if (!ScopedTotals.TryGetValue(kind, out var value3))
			{
				value3 = new Dictionary<SkillType, float>();
				ScopedTotals[kind] = value3;
			}
			Add(value3, skill, value);
		}

		private static void Add(Dictionary<SkillType, float> map, SkillType key, float value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			map.TryGetValue(key, out var value2);
			map[key] = value2 + value;
		}

		internal static void ReportCoverage()
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				foreach (PerkNode node in value.Nodes)
				{
					num++;
					if (PerkHandlerRegistry.HasHandler(node.Id))
					{
						num4++;
						num2++;
						continue;
					}
					bool flag = false;
					if (node.Effects != null)
					{
						foreach (EffectSpec effect in node.Effects)
						{
							if (!effect.IsPending)
							{
								flag = true;
								break;
							}
						}
					}
					if (flag)
					{
						num2++;
					}
					else
					{
						num3++;
					}
				}
			}
			Log.Info($"Perk effects: {num2}/{num} implemented " + $"({num4} via handlers, {TriggerRuntime.TriggeredPerkCount} via triggers), " + $"{num3} still pending. " + "Pending perks are marked in the UI - they never silently do nothing.");
		}
	}
	internal enum EffectKind
	{
		Pending,
		DamagePct,
		SkillLevel,
		XpRatePct,
		ArmorFlat,
		ArmorPct,
		MaxHealthPct,
		HealthRegenPct,
		StaminaRegenPct,
		EitrRegenPct,
		StaminaAttackPct,
		StaminaBlockPct,
		StaminaDodgePct,
		StaminaJumpPct,
		StaminaRunPct,
		StaminaSwimPct,
		StaminaSneakPct,
		SpeedPct,
		SwimSpeedPct,
		JumpPct,
		CarryWeightFlat,
		NoisePct,
		StealthPct,
		FallDamagePct,
		StaggerPct,
		TimedBlockBonus,
		AdrenalinePct,
		DamageTakenPct,
		StaggerPowerPct,
		KnockbackPowerPct,
		LifestealPct,
		EitrStealPct,
		BackstabPct,
		KnockbackTakenPct,
		DeflectChancePct,
		ThornsPct,
		DamageCapPct,
		FallGraceMetres,
		Immunity,
		StaminaDelayFlat,
		DurabilityLossPct,
		ArmourDurabilityLossPct,
		AggroShedMetres,
		FearRadiusMetres,
		TorchFuelPct,
		ArmourPenPct,
		ChopDamagePct,
		MineDamagePct,
		StationReachMetres,
		StationOutputPct,
		StationRecipesFlat,
		MaterialRefundPct,
		JumpForwardPct,
		JumpWeightReliefPct,
		YieldTreePct,
		YieldOrePct,
		YieldForagePct,
		YieldKillPct,
		BlockPowerPct,
		DeflectionPct,
		ParryWindowPct,
		UnblockableChancePct,
		ProjectileDamagePct,
		ProjectileSpeedPct,
		ProjectileDropPct,
		ProjectilePiercePct
	}
	internal enum ConditionKind
	{
		Always,
		Unarmored,
		Armored,
		EmptyHanded,
		FullArmorSet,
		ShieldEquipped,
		NoShield,
		TorchEquipped,
		TwoHanded,
		OneHanded,
		DualWielding,
		OffhandFull,
		TrinketEquipped,
		HealthBelow,
		HealthAbove,
		FullHealth,
		StaminaBelow,
		StaminaAbove,
		EitrBelow,
		EitrAbove,
		StandingStill,
		Running,
		Crouching,
		Swimming,
		Airborne,
		Blocking,
		Sheltered,
		Wet,
		Cold,
		Rested,
		Burning,
		Encumbered,
		CarryOver,
		CarryUnder,
		Night,
		Day,
		HasStatusEffect,
		Intoxicated,
		EnemiesNearby,
		AlliesNearby,
		Alone,
		RecentlyKilled,
		RecentlyDamaged,
		RecentlyParried,
		RecentlyBlocked,
		RecentlyDodged,
		RecentlyBuilt,
		RecentlyCrafted,
		RecentlyBrewed,
		PowerActive,
		PowerReady
	}
	internal enum TriggerScope
	{
		Running,
		String,
		Target
	}
	internal sealed class EffectSpec
	{
		internal EffectKind Kind;

		internal ConditionKind Condition;

		internal float ConditionValue;

		internal float ConditionRadius;

		internal string ConditionText = string.Empty;

		internal bool ConditionScales;

		internal float ConditionMax;

		internal ConditionKind Condition2;

		internal float Condition2Value;

		internal TriggerKind Trigger;

		internal TriggerPayload Payload;

		internal float TriggerChance;

		internal float TriggerDuration = 5f;

		internal int TriggerMaxStacks = 1;

		internal int TriggerEvery = 1;

		internal TriggerScope TriggerScope;

		internal SkillType TriggerSkill;

		internal SkillType Skill;

		internal bool AppliesToAllSkills = true;

		internal float[] Values = new float[0];

		internal string Note = string.Empty;

		private static readonly Dictionary<string, EffectKind> KindNames = new Dictionary<string, EffectKind>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"pending",
				EffectKind.Pending
			},
			{
				"damage_pct",
				EffectKind.DamagePct
			},
			{
				"skill_level",
				EffectKind.SkillLevel
			},
			{
				"xp_rate_pct",
				EffectKind.XpRatePct
			},
			{
				"armor_flat",
				EffectKind.ArmorFlat
			},
			{
				"armor_pct",
				EffectKind.ArmorPct
			},
			{
				"max_health_pct",
				EffectKind.MaxHealthPct
			},
			{
				"health_regen_pct",
				EffectKind.HealthRegenPct
			},
			{
				"stamina_regen_pct",
				EffectKind.StaminaRegenPct
			},
			{
				"eitr_regen_pct",
				EffectKind.EitrRegenPct
			},
			{
				"stamina_attack_pct",
				EffectKind.StaminaAttackPct
			},
			{
				"stamina_block_pct",
				EffectKind.StaminaBlockPct
			},
			{
				"stamina_dodge_pct",
				EffectKind.StaminaDodgePct
			},
			{
				"stamina_jump_pct",
				EffectKind.StaminaJumpPct
			},
			{
				"stamina_run_pct",
				EffectKind.StaminaRunPct
			},
			{
				"stamina_swim_pct",
				EffectKind.StaminaSwimPct
			},
			{
				"stamina_sneak_pct",
				EffectKind.StaminaSneakPct
			},
			{
				"speed_pct",
				EffectKind.SpeedPct
			},
			{
				"swim_speed_pct",
				EffectKind.SwimSpeedPct
			},
			{
				"jump_pct",
				EffectKind.JumpPct
			},
			{
				"carry_weight_flat",
				EffectKind.CarryWeightFlat
			},
			{
				"noise_pct",
				EffectKind.NoisePct
			},
			{
				"stealth_pct",
				EffectKind.StealthPct
			},
			{
				"fall_damage_pct",
				EffectKind.FallDamagePct
			},
			{
				"stagger_pct",
				EffectKind.StaggerPct
			},
			{
				"timed_block_bonus",
				EffectKind.TimedBlockBonus
			},
			{
				"adrenaline_pct",
				EffectKind.AdrenalinePct
			},
			{
				"damage_taken_pct",
				EffectKind.DamageTakenPct
			},
			{
				"stagger_power_pct",
				EffectKind.StaggerPowerPct
			},
			{
				"knockback_power_pct",
				EffectKind.KnockbackPowerPct
			},
			{
				"knockback_taken_pct",
				EffectKind.KnockbackTakenPct
			},
			{
				"deflect_chance_pct",
				EffectKind.DeflectChancePct
			},
			{
				"thorns_pct",
				EffectKind.ThornsPct
			},
			{
				"damage_cap_pct",
				EffectKind.DamageCapPct
			},
			{
				"fall_grace_metres",
				EffectKind.FallGraceMetres
			},
			{
				"immunity",
				EffectKind.Immunity
			},
			{
				"stamina_delay_flat",
				EffectKind.StaminaDelayFlat
			},
			{
				"jump_forward_pct",
				EffectKind.JumpForwardPct
			},
			{
				"aggro_shed_metres",
				EffectKind.AggroShedMetres
			},
			{
				"armour_pen_pct",
				EffectKind.ArmourPenPct
			},
			{
				"station_reach_metres",
				EffectKind.StationReachMetres
			},
			{
				"station_output_pct",
				EffectKind.StationOutputPct
			},
			{
				"station_recipes_flat",
				EffectKind.StationRecipesFlat
			},
			{
				"material_refund_pct",
				EffectKind.MaterialRefundPct
			},
			{
				"chop_damage_pct",
				EffectKind.ChopDamagePct
			},
			{
				"mine_damage_pct",
				EffectKind.MineDamagePct
			},
			{
				"armor_pen_pct",
				EffectKind.ArmourPenPct
			},
			{
				"torch_fuel_pct",
				EffectKind.TorchFuelPct
			},
			{
				"fear_radius_metres",
				EffectKind.FearRadiusMetres
			},
			{
				"durability_loss_pct",
				EffectKind.DurabilityLossPct
			},
			{
				"armour_durability_loss_pct",
				EffectKind.ArmourDurabilityLossPct
			},
			{
				"armor_durability_loss_pct",
				EffectKind.ArmourDurabilityLossPct
			},
			{
				"jump_weight_relief_pct",
				EffectKind.JumpWeightReliefPct
			},
			{
				"lifesteal_pct",
				EffectKind.LifestealPct
			},
			{
				"eitr_steal_pct",
				EffectKind.EitrStealPct
			},
			{
				"backstab_pct",
				EffectKind.BackstabPct
			},
			{
				"yield_tree_pct",
				EffectKind.YieldTreePct
			},
			{
				"yield_ore_pct",
				EffectKind.YieldOrePct
			},
			{
				"yield_forage_pct",
				EffectKind.YieldForagePct
			},
			{
				"yield_kill_pct",
				EffectKind.YieldKillPct
			},
			{
				"block_power_pct",
				EffectKind.BlockPowerPct
			},
			{
				"deflection_pct",
				EffectKind.DeflectionPct
			},
			{
				"parry_window_pct",
				EffectKind.ParryWindowPct
			},
			{
				"unblockable_pct",
				EffectKind.UnblockableChancePct
			},
			{
				"projectile_damage_pct",
				EffectKind.ProjectileDamagePct
			},
			{
				"projectile_speed_pct",
				EffectKind.ProjectileSpeedPct
			},
			{
				"projectile_drop_pct",
				EffectKind.ProjectileDropPct
			},
			{
				"projectile_pierce_pct",
				EffectKind.ProjectilePiercePct
			}
		};

		private static readonly Dictionary<string, TriggerScope> TriggerScopeNames = new Dictionary<string, TriggerScope>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"running",
				TriggerScope.Running
			},
			{
				"string",
				TriggerScope.String
			},
			{
				"combo",
				TriggerScope.String
			},
			{
				"target",
				TriggerScope.Target
			},
			{
				"victim",
				TriggerScope.Target
			}
		};

		private static readonly Dictionary<string, ConditionKind> ConditionNames = new Dictionary<string, ConditionKind>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"always",
				ConditionKind.Always
			},
			{
				"carry_over",
				ConditionKind.CarryOver
			},
			{
				"carry_under",
				ConditionKind.CarryUnder
			},
			{
				"unarmored",
				ConditionKind.Unarmored
			},
			{
				"armored",
				ConditionKind.Armored
			},
			{
				"empty_handed",
				ConditionKind.EmptyHanded
			},
			{
				"full_armor_set",
				ConditionKind.FullArmorSet
			},
			{
				"shield_equipped",
				ConditionKind.ShieldEquipped
			},
			{
				"no_shield",
				ConditionKind.NoShield
			},
			{
				"torch_equipped",
				ConditionKind.TorchEquipped
			},
			{
				"two_handed",
				ConditionKind.TwoHanded
			},
			{
				"one_handed",
				ConditionKind.OneHanded
			},
			{
				"dual_wielding",
				ConditionKind.DualWielding
			},
			{
				"offhand_full",
				ConditionKind.OffhandFull
			},
			{
				"trinket_equipped",
				ConditionKind.TrinketEquipped
			},
			{
				"health_below",
				ConditionKind.HealthBelow
			},
			{
				"health_above",
				ConditionKind.HealthAbove
			},
			{
				"full_health",
				ConditionKind.FullHealth
			},
			{
				"stamina_below",
				ConditionKind.StaminaBelow
			},
			{
				"stamina_above",
				ConditionKind.StaminaAbove
			},
			{
				"eitr_below",
				ConditionKind.EitrBelow
			},
			{
				"eitr_above",
				ConditionKind.EitrAbove
			},
			{
				"standing_still",
				ConditionKind.StandingStill
			},
			{
				"running",
				ConditionKind.Running
			},
			{
				"crouching",
				ConditionKind.Crouching
			},
			{
				"swimming",
				ConditionKind.Swimming
			},
			{
				"airborne",
				ConditionKind.Airborne
			},
			{
				"blocking",
				ConditionKind.Blocking
			},
			{
				"sheltered",
				ConditionKind.Sheltered
			},
			{
				"wet",
				ConditionKind.Wet
			},
			{
				"cold",
				ConditionKind.Cold
			},
			{
				"rested",
				ConditionKind.Rested
			},
			{
				"burning",
				ConditionKind.Burning
			},
			{
				"encumbered",
				ConditionKind.Encumbered
			},
			{
				"night",
				ConditionKind.Night
			},
			{
				"day",
				ConditionKind.Day
			},
			{
				"has_status",
				ConditionKind.HasStatusEffect
			},
			{
				"intoxicated",
				ConditionKind.Intoxicated
			},
			{
				"enemies_nearby",
				ConditionKind.EnemiesNearby
			},
			{
				"allies_nearby",
				ConditionKind.AlliesNearby
			},
			{
				"alone",
				ConditionKind.Alone
			},
			{
				"recently_killed",
				ConditionKind.RecentlyKilled
			},
			{
				"recently_damaged",
				ConditionKind.RecentlyDamaged
			},
			{
				"recently_parried",
				ConditionKind.RecentlyParried
			},
			{
				"recently_blocked",
				ConditionKind.RecentlyBlocked
			},
			{
				"recently_dodged",
				ConditionKind.RecentlyDodged
			},
			{
				"recently_built",
				ConditionKind.RecentlyBuilt
			},
			{
				"recently_crafted",
				ConditionKind.RecentlyCrafted
			},
			{
				"recently_brewed",
				ConditionKind.RecentlyBrewed
			},
			{
				"power_active",
				ConditionKind.PowerActive
			},
			{
				"power_ready",
				ConditionKind.PowerReady
			}
		};

		internal bool HasTrigger => Trigger != TriggerKind.None;

		internal bool IsPending => Kind == EffectKind.Pending;

		internal bool IsContinuous
		{
			get
			{
				if (!IsPending)
				{
					return !HasTrigger;
				}
				return false;
			}
		}

		internal float ValueAt(int rank)
		{
			if (Values.Length == 0)
			{
				return 0f;
			}
			if (rank <= 0)
			{
				return 0f;
			}
			if (rank < Values.Length)
			{
				return Values[rank - 1];
			}
			return Values[Values.Length - 1];
		}

		internal bool Matches(SkillType type)
		{
			//IL_0009: 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 (!AppliesToAllSkills)
			{
				return Skill == type;
			}
			return true;
		}

		internal static bool TryParseCondition(string name, out ConditionKind kind)
		{
			return ConditionNames.TryGetValue(name ?? string.Empty, out kind);
		}

		internal static EffectSpec FromJson(object raw, int maxRank, string nodeId)
		{
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			EffectSpec effectSpec = new EffectSpec();
			string text = Json.Str(raw, "kind", "pending");
			if (!KindNames.TryGetValue(text, out effectSpec.Kind))
			{
				Log.Warn("Perk '" + nodeId + "' declares unknown effect kind '" + text + "'. Treated as pending.");
				effectSpec.Kind = EffectKind.Pending;
				effectSpec.Note = "unknown kind '" + text + "'";
				return effectSpec;
			}
			effectSpec.Note = Json.Str(raw, "note");
			if (effectSpec.IsPending)
			{
				return effectSpec;
			}
			List<object> list = Json.Arr(Json.Get(raw, "values"));
			if (list == null || list.Count == 0)
			{
				Log.Warn("Perk '" + nodeId + "' effect '" + text + "' has no values. Treated as pending.");
				effectSpec.Kind = EffectKind.Pending;
				effectSpec.Note = "no values";
				return effectSpec;
			}
			effectSpec.Values = new float[list.Count];
			for (int i = 0; i < list.Count; i++)
			{
				effectSpec.Values[i] = ((list[i] is double num) ? ((float)num) : 0f);
			}
			if (effectSpec.Values.Length != maxRank)
			{
				Log.Warn($"Perk '{nodeId}' effect '{text}' has {effectSpec.Values.Length} values " + $"but {maxRank} ranks.");
			}
			string text2 = Json.Str(raw, "skill", "any");
			if (!string.Equals(text2, "any", StringComparison.OrdinalIgnoreCase) && SkillKeys.TryResolve(text2, out var type))
			{
				effectSpec.Skill = type;
				effectSpec.AppliesToAllSkills = false;
			}
			string text3 = Json.Str(raw, "name");
			if (!string.IsNullOrEmpty(text3))
			{
				effectSpec.ConditionText = text3;
			}
			object obj = Json.Get(raw, "condition");
			if (obj != null)
			{
				string text4 = Json.Str(obj, "when", "always");
				if (ConditionNames.TryGetValue(text4, out var value))
				{
					effectSpec.Condition = value;
				}
				else
				{
					Log.Warn("Perk '" + nodeId + "' declares unknown condition '" + text4 + "'. Ignored.");
				}
				effectSpec.ConditionValue = Json.Num(obj, "percent", Json.Num(obj, "seconds", Json.Num(obj, "count")));
				effectSpec.ConditionRadius = Json.Num(obj, "radius");
				string text5 = Json.Str(obj, "name");
				if (!string.IsNullOrEmpty(text5))
				{
					effectSpec.ConditionText = text5;
				}
				effectSpec.ConditionScales = Json.Bool(obj, "scale");
				effectSpec.ConditionMax = Json.Num(obj, "max");
				string text6 = Json.Str(obj, "and");
				if (!string.IsNullOrEmpty(text6))
				{
					if (ConditionNames.TryGetValue(text6, out var value2))
					{
						effectSpec.Condition2 = value2;
					}
					else
					{
						Log.Warn("Perk '" + nodeId + "' declares unknown second condition '" + text6 + "'. Ignored.");
					}
					effectSpec.Condition2Value = Json.Num(obj, "andPercent", Json.Num(obj, "andSeconds"));
				}
			}
			ReadTrigger(effectSpec, Json.Get(raw, "trigger"), nodeId);
			return effectSpec;
		}

		private static void ReadTrigger(EffectSpec spec, object raw, string nodeId)
		{
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			if (raw == null)
			{
				return;
			}
			string text = Json.Str(raw, "on");
			if (!TriggerNames.TryKind(text, out var kind) || kind == TriggerKind.None)
			{
				Log.Warn("Perk '" + nodeId + "' declares unknown trigger '" + text + "'. Treated as pending.");
				spec.Kind = EffectKind.Pending;
				spec.Note = "unknown trigger '" + text + "'";
				return;
			}
			spec.Trigger = kind;
			string text2 = Json.Str(raw, "grants", "buff");
			if (!TriggerNames.TryPayload(text2, out spec.Payload))
			{
				Log.Warn("Perk '" + nodeId + "' declares unknown trigger payload '" + text2 + "'. Treated as pending.");
				spec.Kind = EffectKind.Pending;
				spec.Note = "unknown trigger payload '" + text2 + "'";
				return;
			}
			spec.TriggerChance = Json.Num(raw, "chance");
			spec.TriggerDuration = Json.Num(raw, "seconds", 5f);
			spec.TriggerMaxStacks = (int)Json.Num(raw, "stacks", 1f);
			spec.TriggerEvery = (int)Json.Num(raw, "every", 1f);
			if (spec.TriggerEvery < 1)
			{
				spec.TriggerEvery = 1;
			}
			string text3 = Json.Str(raw, "scope", "running");
			if (TriggerScopeNames.TryGetValue(text3, out var value))
			{
				spec.TriggerScope = value;
			}
			else
			{
				Log.Warn("Perk '" + nodeId + "' declares unknown trigger scope '" + text3 + "'. Counting every occurrence instead.");
			}
			if (spec.TriggerMaxStacks < 1)
			{
				spec.TriggerMaxStacks = 1;
			}
			string text4 = Json.Str(raw, "with", "any");
			if (!string.Equals(text4, "any", StringComparison.OrdinalIgnoreCase) && SkillKeys.TryResolve(text4, out var type))
			{
				spec.TriggerSkill = type;
			}
			if (spec.Payload != TriggerPayload.Buff)
			{
				spec.TriggerDuration = 0f;
			}
			else if (spec.TriggerDuration <= 0f)
			{
				Log.Warn("Perk '" + nodeId + "' has a buff trigger with no duration. Treated as pending.");
				spec.Kind = EffectKind.Pending;
				spec.Note = "buff trigger with no duration";
			}
		}
	}
	internal enum HitConditionKind
	{
		Any,
		TargetStaggered,
		TargetHealthBelow,
		TargetHealthAbove,
		TargetMissingHealth,
		TargetIsBoss,
		TargetIsPlayer,
		TargetHasStatus,
		TargetBlocking,
		TargetFartherThan,
		TargetCloserThan,
		TargetUnaware
	}
	internal enum HitField
	{
		Damage,
		Stagger,
		Knockback,
		Backstab,
		Lifesteal,
		Unblockable
	}
	internal sealed class HitModifier
	{
		internal HitConditionKind When;

		internal HitField Field;

		internal float ConditionValue;

		internal string ConditionText = string.Empty;

		internal SkillType Skill;

		internal float[] Values = new float[0];

		internal string NodeId = string.Empty;

		internal float ValueAt(int rank)
		{
			if (Values.Length == 0 || rank <= 0)
			{
				return 0f;
			}
			if (rank < Values.Length)
			{
				return Values[rank - 1];
			}
			return Values[Values.Length - 1];
		}
	}
	internal static class HitConditions
	{
		private static readonly Dictionary<string, HitConditionKind> Names = new Dictionary<string, HitConditionKind>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"any",
				HitConditionKind.Any
			},
			{
				"target_staggered",
				HitConditionKind.TargetStaggered
			},
			{
				"target_health_below",
				HitConditionKind.TargetHealthBelow
			},
			{
				"target_health_above",
				HitConditionKind.TargetHealthAbove
			},
			{
				"target_missing_health",
				HitConditionKind.TargetMissingHealth
			},
			{
				"target_is_boss",
				HitConditionKind.TargetIsBoss
			},
			{
				"target_is_player",
				HitConditionKind.TargetIsPlayer
			},
			{
				"target_has_status",
				HitConditionKind.TargetHasStatus
			},
			{
				"target_blocking",
				HitConditionKind.TargetBlocking
			},
			{
				"target_farther_than",
				HitConditionKind.TargetFartherThan
			},
			{
				"target_closer_than",
				HitConditionKind.TargetCloserThan
			},
			{
				"target_unaware",
				HitConditionKind.TargetUnaware
			}
		};

		private static readonly Dictionary<string, HitField> FieldNames = new Dictionary<string, HitField>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"damage",
				HitField.Damage
			},
			{
				"stagger",
				HitField.Stagger
			},
			{
				"knockback",
				HitField.Knockback
			},
			{
				"lifesteal",
				HitField.Lifesteal
			},
			{
				"unblockable",
				HitField.Unblockable
			},
			{
				"backstab",
				HitField.Backstab
			}
		};

		internal static bool TryParse(string name, out HitConditionKind kind)
		{
			return Names.TryGetValue(name ?? string.Empty, out kind);
		}

		internal static bool TryParseField(string name, out HitField field)
		{
			return FieldNames.TryGetValue(name ?? string.Empty, out field);
		}

		internal static float Factor(HitModifier modifier, Character target)
		{
			if ((Object)(object)target == (Object)null)
			{
				return 0f;
			}
			switch (modifier.When)
			{
			case HitConditionKind.Any:
				return 1f;
			case HitConditionKind.TargetStaggered:
				if (!target.IsStaggering())
				{
					return 0f;
				}
				return 1f;
			case HitConditionKind.TargetHealthBelow:
				if (!(target.GetHealthPercentage() * 100f < modifier.ConditionValue))
				{
					return 0f;
				}
				return 1f;
			case HitConditionKind.TargetHealthAbove:
				if (!(target.GetHealthPercentage() * 100f > modifier.ConditionValue))
				{
					return 0f;
				}
				return 1f;
			case HitConditionKind.TargetMissingHealth:
				return Mathf.Clamp01(1f - target.GetHealthPercentage());
			case HitConditionKind.TargetIsBoss:
				if (!target.IsBoss())
				{
					return 0f;
				}
				return 1f;
			case HitConditionKind.TargetIsPlayer:
				if (!target.IsPlayer())
				{
					return 0f;
				}
				return 1f;
			case HitConditionKind.TargetBlocking:
				if (!target.IsBlocking())
				{
					return 0f;
				}
				return 1f;
			case HitConditionKind.TargetHasStatus:
				if (!HasStatus(target, modifier.ConditionText))
				{
					return 0f;
				}
				return 1f;
			case HitConditionKind.TargetFartherThan:
				if (!(Distance(target) > modifier.ConditionValue))
				{
					return 0f;
				}
				return 1f;
			case HitConditionKind.TargetCloserThan:
				if (!(Distance(target) <= modifier.ConditionValue))
				{
					return 0f;
				}
				return 1f;
			case HitConditionKind.TargetUnaware:
				if (!Unaware(target))
				{
					return 0f;
				}
				return 1f;
			default:
				return 0f;
			}
		}

		internal static bool Unaware(Character target)
		{
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			BaseAI baseAI = target.GetBaseAI();
			if ((Object)(object)baseAI != (Object)null)
			{
				return !baseAI.IsAlerted();
			}
			return false;
		}

		private static float Distance(Character target)
		{
			//IL_001b: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return 0f;
			}
			return Vector3.Distance(((Component)localPlayer).transform.position, ((Component)target).transform.position);
		}

		private static bool HasStatus(Character target, string fragment)
		{
			if (string.IsNullOrEmpty(fragment))
			{
				return false;
			}
			SEMan sEMan = target.GetSEMan();
			if (sEMan == null)
			{
				return false;
			}
			List<StatusEffect> statusEffects = sEMan.GetStatusEffects();
			if (statusEffects == null)
			{
				return false;
			}
			foreach (StatusEffect item in statusEffects)
			{
				if (item != null && item.m_name != null && item.m_name.IndexOf(fragment, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class HitModifierDriver
	{
		private static readonly Dictionary<string, List<HitModifier>> ByNode = new Dictionary<string, List<HitModifier>>();

		internal static int ModifierCount { get; private set; }

		internal static void Rebuild()
		{
			ByNode.Clear();
			ModifierCount = 0;
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				foreach (PerkNode node in value.Nodes)
				{
					if (node.HitModifiers != null && node.HitModifiers.Count != 0)
					{
						ByNode[node.Id] = node.HitModifiers;
						ModifierCount += node.HitModifiers.Count;
					}
				}
			}
		}

		internal static float Apply(Character target, HitData hit, PerkState state)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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)
			if (ByNode.Count == 0 || (Object)(object)target == (Object)null || hit == null || state == null)
			{
				return 0f;
			}
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			float num5 = 0f;
			float num6 = 0f;
			foreach (KeyValuePair<string, List<HitModifier>> item in ByNode)
			{
				int rank = state.GetRank(item.Key);
				if (rank <= 0)
				{
					continue;
				}
				foreach (HitModifier item2 in item.Value)
				{
					if ((int)item2.Skill != 0 && item2.Skill != hit.m_skill)
					{
						continue;
					}
					float num7 = HitConditions.Factor(item2, target);
					if (!(num7 <= 0f))
					{
						float num8 = item2.ValueAt(rank) * num7;
						switch (item2.Field)
						{
						case HitField.Stagger:
							num2 += num8;
							break;
						case HitField.Knockback:
							num3 += num8;
							break;
						case HitField.Lifesteal:
							num4 += num8;
							break;
						case HitField.Unblockable:
							num5 += num8;
							break;
						case HitField.Backstab:
							num6 += num8;
							break;
						default:
							num += num8;
							break;
						}
					}
				}
			}
			if (num != 0f)
			{
				((DamageTypes)(ref hit.m_damage)).Modify(SafeMultiplier(num));
			}
			if (num2 != 0f)
			{
				hit.m_staggerMultiplier = Scale(hit.m_staggerMultiplier, num2);
			}
			if (num6 != 0f && CanScaleBackstab(hit.m_backstabBonus))
			{
				hit.m_backstabBonus = Scale(hit.m_backstabBonus, num6);
			}
			if (num3 != 0f)
			{
				hit.m_pushForce = Scale(hit.m_pushForce, num3);
			}
			if (num4 != 0f)
			{
				float num9 = hit.GetTotalDamage() * num4 / 100f;
				if (num9 > 0f)
				{
					hit.m_healthReturn += num9;
				}
			}
			return num5;
		}

		internal static float SafeMultiplier(float percent)
		{
			float num = 1f + percent / 100f;
			if (!(num < 0f))
			{
				return num;
			}
			return 0f;
		}

		internal static bool CanScaleBackstab(float current)
		{
			return current > 1f;
		}

		private static float Scale(float value, float percent)
		{
			float num = value * (1f + percent / 100f);
			if (!(num < 0f))
			{
				return num;
			}
			return 0f;
		}

		internal static bool Implements(string nodeId)
		{
			return ByNode.ContainsKey(nodeId);
		}
	}
	internal static class Immunities
	{
		private struct Entry
		{
			internal string Name;

			internal EffectSpec Spec;
		}

		private const float Interval = 0.5f;

		private static float _nextSweep;

		private static readonly List<Entry> Active = new List<Entry>();

		internal static int Count => Active.Count;

		internal static IEnumerable<string> Names
		{
			get
			{
				foreach (Entry item in Active)
				{
					yield return item.Name;
				}
			}
		}

		internal static void Rebuild(PerkState state)
		{
			Active.Clear();
			if (state == null)
			{
				return;
			}
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				foreach (PerkNode node in value.Nodes)
				{
					if (node.Effects == null)
					{
						continue;
					}
					int rank = state.GetRank(node.Id);
					if (rank <= 0)
					{
						continue;
					}
					foreach (EffectSpec effect in node.Effects)
					{
						if (effect.Kind == EffectKind.Immunity && !string.IsNullOrEmpty(effect.ConditionText) && !(effect.ValueAt(rank) <= 0f))
						{
							Active.Add(new Entry
							{
								Name = effect.ConditionText,
								Spec = effect
							});
						}
					}
				}
			}
			if (Active.Count > 0)
			{
				Log.Debug("Immune to " + Active.Count + " status effect(s).");
			}
		}

		internal static void Tick(Player player)
		{
			if ((Object)(object)player == (Object)null || Active.Count == 0 || Time.time < _nextSweep)
			{
				return;
			}
			_nextSweep = Time.time + 0.5f;
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null)
			{
				return;
			}
			foreach (Entry item in Active)
			{
				if (Conditions.Holds(item.Spec, player))
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(item.Name);
					if (sEMan.HaveStatusEffect(stableHashCode))
					{
						sEMan.RemoveStatusEffect(stableHashCode, true);
					}
				}
			}
		}

		internal static void Reset()
		{
			Active.Clear();
			_nextSweep = 0f;
		}
	}
	internal static class PerkEffectDriver
	{
		private const float TickInterval = 0.25f;

		private static float _timer;

		private static SE_Norntastic _prototype;

		private static int _nameHash;

		internal static void Init()
		{
			_prototype = SE_Norntastic.Create();
			_nameHash = StringExtensionMethods.GetStableHashCode("SE_Norntastic");
			PerkEvents.AllocationChanged += OnAllocationChanged;
			TriggerRuntime.Init();
			Log.Debug("Perk status effect prototype created.");
		}

		internal static void Forget()
		{
			PerkEvents.AllocationChanged -= OnAllocationChanged;
			PerkHandlerRegistry.Clear();
			TriggerRuntime.Shutdown();
			_timer = 0f;
		}

		internal static void Tick(Player __instance)
		{
			if ((Object)(object)_prototype == (Object)null)
			{
				return;
			}
			_timer += Time.deltaTime;
			if (_timer < 0.25f)
			{
				return;
			}
			float timer = _timer;
			_timer = 0f;
			PerkState current = PerkState.Current;
			if (!current.Ready)
			{
				return;
			}
			SEMan sEMan = ((Character)__instance).GetSEMan();
			if (sEMan != null)
			{
				if ((Object)(object)sEMan.GetStatusEffect(_nameHash) == (Object)null)
				{
					sEMan.AddStatusEffect((StatusEffect)(object)_prototype, false, 0, 0f, (short)(-1));
					Log.Debug("Perk status effect attached.");
				}
				Conditions.Tick(__instance, timer);
				AuraBroadcast.Tick(__instance, timer);
				AuraReceiver.Tick(__instance, timer);
				GuardianPowers.Tick(__instance, timer);
				EffectAggregator.Rebuild(current, __instance);
				DatabaseGuard.Check();
				Norntastic.Emotes.Emotes.Tick(0.25f);
				PerkHandlerRegistry.Tick(__instance, current, timer);
			}
		}

		internal static void OnCharacterChanged()
		{
			TriggerRuntime.Reset();
			Conditions.Reset();
			AuraBroadcast.Reset();
			AuraReceiver.Reset();
			OffhandStrike.Reset();
			AttackStringDriver.Reset();
			Equipment.Invalidate();
			Offhand.Invalidate();
			GuardianPowers.Reset();
		}

		private static void OnAllocationChanged()
		{
			PerkState current = PerkState.Current;
			PerkHandlerRegistry.Sync(current);
			foreach (KeyValuePair<string, int> item in current.Allocated)
			{
				if (item.Value <= 0)
				{
					TimedBuffs.ClearNode(item.Key);
				}
			}
			EffectAggregator.Rebuild(current, Player.m_localPlayer);
		}
	}
	internal abstract class PerkHandler
	{
		internal abstract string NodeId { get; }

		internal virtual SkillType HitSkill => (SkillType)0;

		internal virtual void OnActivate(int rank)
		{
		}

		internal virtual void OnDeactivate()
		{
		}

		internal virtual void OnTick(Player player, int rank, float dt)
		{
		}

		internal virtual void OnHit(Character target, HitData hit, int rank)
		{
		}
	}
	internal static class PerkHandlerRegistry
	{
		private static readonly Dictionary<string, PerkHandler> Handlers = new Dictionary<string, PerkHandler>();

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

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

		internal static int Count => Handlers.Count;

		internal static void MarkImplemented(string nodeId, string by)
		{
			if (!string.IsNullOrEmpty(nodeId))
			{
				Subsystem[nodeId] = by;
			}
		}

		internal static void Register(PerkHandler handler)
		{
			if (handler != null)
			{
				if (PerkDatabase.Node(handler.NodeId) == null)
				{
					Log.Warn("Handler registered for unknown perk '" + handler.NodeId + "'. Ignored.");
					return;
				}
				Handlers[handler.NodeId] = handler;
				Log.Debug("Registered handler for " + handler.NodeId + ".");
			}
		}

		internal static bool HasHandler(string nodeId)
		{
			if (nodeId != null)
			{
				if (!Handlers.ContainsKey(nodeId))
				{
					return Subsystem.ContainsKey(nodeId);
				}
				return true;
			}
			return false;
		}

		internal static void Sync(PerkState state)
		{
			foreach (KeyValuePair<string, PerkHandler> handler in Handlers)
			{
				int rank = state.GetRank(handler.Key);
				int value;
				int num = (ActiveRanks.TryGetValue(handler.Key, out value) ? value : 0);
				if (rank != num)
				{
					if (rank > 0)
					{
						handler.Value.OnActivate(rank);
					}
					else
					{
						handler.Value.OnDeactivate();
					}
					ActiveRanks[handler.Key] = rank;
				}
			}
		}

		internal static void Hit(Character target, HitData hit, PerkState state)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)
			foreach (KeyValuePair<string, PerkHandler> handler in Handlers)
			{
				int rank = state.GetRank(handler.Key);
				if (rank > 0)
				{
					SkillType hitSkill = handler.Value.HitSkill;
					if ((int)hitSkill == 0 || hitSkill == hit.m_skill)
					{
						handler.Value.OnHit(target, hit, rank);
					}
				}
			}
		}

		internal static void Tick(Player player, PerkState state, float dt)
		{
			foreach (KeyValuePair<string, PerkHandler> handler in Handlers)
			{
				int rank = state.GetRank(handler.Key);
				if (rank > 0)
				{
					handler.Value.OnTick(player, rank, dt);
				}
			}
		}

		internal static void Clear()
		{
			foreach (KeyValuePair<string, PerkHandler> handler in Handlers)
			{
				if (ActiveRanks.TryGetValue(handler.Key, out var value) && value > 0)
				{
					handler.Value.OnDeactivate();
				}
			}
			ActiveRanks.Clear();
		}
	}
	internal sealed class SE_Norntastic : StatusEffect
	{
		internal const string EffectName = "SE_Norntastic";

		internal static SE_Norntastic Create()
		{
			SE_Norntastic sE_Norntastic = ScriptableObject.CreateInstance<SE_Norntastic>();
			((Object)sE_Norntastic).name = "SE_Norntastic";
			((StatusEffect)sE_Norntastic).m_name = "$norntastic_perks";
			((StatusEffect)sE_Norntastic).m_ttl = 0f;
			return sE_Norntastic;
		}

		public override void ModifyHealthRegen(ref float regenMultiplier)
		{
			regenMultiplier *= EffectAggregator.MulAtLeast(EffectKind.HealthRegenPct, 0f);
		}

		public override void ModifyStaminaRegen(ref float staminaRegen)
		{
			staminaRegen *= EffectAggregator.MulAtLeast(EffectKind.StaminaRegenPct, 0f);
		}

		public override void ModifyEitrRegen(ref float eitrRegen)
		{
			eitrRegen *= EffectAggregator.MulAtLeast(EffectKind.EitrRegenPct, 0f);
		}

		public override void ModifyAttackStaminaUsage(float baseStaminaUse, ref float staminaUse)
		{
			staminaUse *= EffectAggregator.MulAtLeast(EffectKind.StaminaAttackPct, ModConfig.CostFloor.Value);
		}

		public override void ModifyBlockStaminaUsage(float baseStaminaUse, ref float staminaUse)
		{
			staminaUse *= EffectAggregator.MulAtLeast(EffectKind.StaminaBlockPct, ModConfig.CostFloor.Value);
		}

		public override void ModifyDodgeStaminaUsage(float baseStaminaUse, ref float staminaUse)
		{
			staminaUse *= EffectAggregator.MulAtLeast(EffectKind.StaminaDodgePct, ModConfig.CostFloor.Value);
		}

		public override void ModifyJumpStaminaUsage(float baseStaminaUse, ref float staminaUse)
		{
			staminaUse *= EffectAggregator.MulAtLeast(EffectKind.StaminaJumpPct, ModConfig.CostFloor.Value);
		}

		public override void ModifySwimStaminaUsage(float baseStaminaUse, ref float staminaUse)
		{
			staminaUse *= EffectAggregator.MulAtLeast(EffectKind.StaminaSwimPct, ModConfig.CostFloor.Value);
		}

		public override void ModifySneakStaminaUsage(float baseStaminaUse, ref float staminaUse)
		{
			staminaUse *= EffectAggregator.MulAtLeast(EffectKind.StaminaSneakPct, ModConfig.CostFloor.Value);
		}

		public override void ModifyRunStaminaDrain(float baseDrain, ref float drain, Vector3 dir)
		{
			drain *= EffectAggregator.MulAtLeast(EffectKind.StaminaRunPct, ModConfig.CostFloor.Value);
		}

		public override void ModifySpeed(float baseSpeed, ref float speed, Character character, Vector3 dir)
		{
			speed *= EffectAggregator.MulAtLeast(EffectKind.SpeedPct, 0f);
		}

		public override void ModifyJump(Vector3 baseJump, ref Vector3 jump)
		{
			//IL_0002: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			jump *= EffectAggregator.MulAtLeast(EffectKind.JumpPct, 0f);
		}

		public override void ModifyFallDamage(float baseDamage, ref float damage)
		{
			damage *= EffectAggregator.MulAtLeast(EffectKind.FallDamagePct, 0f);
		}

		public override void ModifyArmorMods(ref float armor)
		{
			armor *= EffectAggregator.MulAtLeast(EffectKind.ArmorPct, 0f);
			armor += EffectAggregator.Pct(EffectKind.ArmorFlat);
		}

		public override void ModifyStagger(float baseValue, ref float use)
		{
			use *= EffectAggregator.MulAtLeast(EffectKind.StaggerPct, 0f);
		}

		public override void ModifyTimedBlockBonus(ref float timedBlockBonus)
		{
			timedBlockBonus += EffectAggregator.Pct(EffectKind.TimedBlockBonus);
		}

		public override void ModifyAdrenaline(float baseValue, ref float use)
		{
			use *= EffectAggregator.MulAtLeast(EffectKind.AdrenalinePct, 0f);
		}

		public override void ModifyMaxCarryWeight(float baseLimit, ref float limit)
		{
			limit += EffectAggregator.Pct(EffectKind.CarryWeightFlat);
		}

		public override void ModifyNoise(float baseNoise, ref float noise)
		{
			noise *= EffectAggregator.MulAtLeast(EffectKind.NoisePct, 0f);
		}

		public override void ModifyStealth(float baseStealth, ref float stealth)
		{
			stealth *= EffectAggregator.MulAtLeast(EffectKind.StealthPct, 0f);
		}

		public override void ModifyAttack(SkillType skill, ref HitData hitData)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			float num = EffectAggregator.DamageMultiplier(skill);
			if (num != 1f)
			{
				((DamageTypes)(ref hitData.m_damage)).Modify(num);
			}
		}

		public override void ModifySkillLevel(SkillType skill, ref float level)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			level += EffectAggregator.BonusLevels(skill);
		}

		public override void ModifyRaiseSkill(SkillType skill, ref float value)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			value *= EffectAggregator.XpMultiplier(skill);
		}

		public override string GetTooltipString()
		{
			int activeEffectCount = EffectAggregator.ActiveEffectCount;
			int conditionalHeldBack = EffectAggregator.ConditionalHeldBack;
			if (conditionalHeldBack <= 0)
			{
				return $"{activeEffectCount} perk effect(s) active";
			}
			return $"{activeEffectCount} perk effect(s) active, {conditionalHeldBack} waiting on conditions";
		}
	}
	internal sealed class SplashSpec
	{
		internal string NodeId = string.Empty;

		internal SkillType Skill;

		internal HitConditionKind When;

		internal float ConditionValue;

		internal string ConditionText = string.Empty;

		internal int Every = 1;

		internal float[] Radius = new float[0];

		internal float[] Values = new float[0];

		internal float StaggerPct;

		internal float RadiusAt(int rank)
		{
			return At(Radius, rank);
		}

		internal float ValueAt(int rank)
		{
			return At(Values, rank);
		}

		private static float At(float[] values, int rank)
		{
			if (values.Length == 0 || rank <= 0)
			{
				return 0f;
			}
			if (rank < values.Length)
			{
				return values[rank - 1];
			}
			return values[^1];
		}
	}
	internal static class TimedBuffs
	{
		private sealed class Stack
		{
			internal EffectKind Kind;

			internal SkillType Skill;

			internal bool AllSkills;

			internal float PerStack;

			internal int MaxStacks;

			internal float Duration;

			internal readonly List<float> Expiries = new List<float>();

			internal string NodeId;
		}

		private static readonly Dictionary<string, Stack> Active = new Dictionary<string, Stack>();

		internal static int LiveBuffCount
		{
			get
			{
				float time = Time.time;
				int num = 0;
				foreach (KeyValuePair<string, Stack> item in Active)
				{
					Prune(item.Value, time);
					if (item.Value.Expiries.Count > 0)
					{
						num++;
					}
				}
				return num;
			}
		}

		internal static void Grant(string key, string nodeId, EffectKind kind, SkillType skill, bool allSkills, float perStack, int maxStacks, float duration)
		{
			//IL_004b: 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 (!string.IsNullOrEmpty(key) && perStack != 0f && !(duration <= 0f))
			{
				if (!Active.TryGetValue(key, out var value))
				{
					value = new Stack
					{
						NodeId = nodeId
					};
					Active[key] = value;
				}
				value.Kind = kind;
				value.Skill = skill;
				value.AllSkills = allSkills;
				value.PerStack = perStack;
				value.MaxStacks = Mathf.Max(1, maxStacks);
				value.Duration = duration;
				float time = Time.time;
				Prune(value, time);
				if (value.Expiries.Count >= value.MaxStacks)
				{
					value.Expiries.RemoveAt(0);
				}
				value.Expiries.Add(time + duration);
			}
		}

		private static void Prune(Stack stack, float now)
		{
			for (int num = stack.Expiries.Count - 1; num >= 0; num--)
			{
				if (stack.Expiries[num] <= now)
				{
					stack.Expiries.RemoveAt(num);
				}
			}
		}

		internal static void ClearNode(string nodeId)
		{
			if (string.IsNullOrEmpty(nodeId))
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, Stack> item in Active)
			{
				if (item.Value.NodeId == nodeId)
				{
					list.Add(item.Key);
				}
			}
			foreach (string item2 in list)
			{
				Active.Remove(item2);
			}
		}

		internal static void Clear()
		{
			Active.Clear();
		}

		internal static void Contribute(EffectAggregator.Sink sink)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (Active.Count == 0)
			{
				return;
			}
			float time = Time.time;
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, Stack> item in Active)
			{
				Stack value = item.Value;
				Prune(value, time);
				if (value.Expiries.Count == 0)
				{
					list.Add(item.Key);
				}
				else
				{
					sink(value.Kind, value.Skill, value.AllSkills, value.PerStack * (float)value.Expiries.Count);
				}
			}
			foreach (string item2 in list)
			{
				Active.Remove(item2);
			}
		}

		internal static int StacksOf(string key)
		{
			if (!Active.TryGetValue(key, out var value))
			{
				return 0;
			}
			Prune(value, Time.time);
			return value.Expiries.Count;
		}

		internal static IEnumerable<string> Describe()
		{
			float now = Time.time;
			foreach (KeyValuePair<string, Stack> item in Active)
			{
				Stack value = item.Value;
				Prune(value, now);
				if (value.Expiries.Count != 0)
				{
					float num = value.Expiries[value.Expiries.Count - 1] - now;
					yield return $"{item.Key}: {value.Kind} " + $"{value.PerStack * (float)value.Expiries.Count:+0.#;-0.#} " + $"({value.Expiries.Count}/{value.MaxStacks} stacks, {num:0.0}s)";
				}
			}
		}
	}
	internal struct TriggerContext
	{
		internal Character Target;

		internal HitData Hit;

		internal SkillType Skill;

		internal static readonly TriggerContext Empty;
	}
	internal static class TriggerBus
	{
		private static readonly Dictionary<TriggerKind, float> LastFired = new Dictionary<TriggerKind, float>();

		private static readonly List<Action<TriggerKind, TriggerContext>> Listeners = new List<Action<TriggerKind, TriggerContext>>();

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

		internal const float Never = 86400f;

		internal static IEnumerable<KeyValuePair<TriggerKind, int>> Observed => Counts;

		internal static void Subscribe(Action<TriggerKind, TriggerContext> listener)
		{
			if (listener != null && !Listeners.Contains(listener))
			{
				Listeners.Add(listener);
			}
		}

		internal static void Unsubscribe(Action<TriggerKind, TriggerContext> listener)
		{
			Listeners.Remove(listener);
		}

		internal static void Fire(TriggerKind kind)
		{
			Fire(kind, TriggerContext.Empty);
		}

		internal static void Fire(TriggerKind kind, TriggerContext context)
		{
			if (kind == TriggerKind.None)
			{
				return;
			}
			LastFired[kind] = Time.time;
			Counts.TryGetValue(kind, out var value);
			Counts[kind] = value + 1;
			for (int num = Listeners.Count - 1; num >= 0; num--)
			{
				Action<TriggerKind, TriggerContext> action = Listeners[num];
				if (action != null)
				{
					try
					{
						action(kind, context);
					}
					catch (Exception ex)
					{
						Log.Warn($"Trigger listener threw on {kind}: {ex.Message}");
					}
				}
			}
		}

		internal static float SecondsSince(TriggerKind kind)
		{
			if (!LastFired.TryGetValue(kind, out var value))
			{
				return 86400f;
			}
			float num = Time.time - value;
			if (!(num < 0f))
			{
				return num;
			}
			return 86400f;
		}

		internal static bool Within(TriggerKind kind, float seconds)
		{
			return SecondsSince(kind) <= Mathf.Max(0f, seconds);
		}

		internal static int CountOf(TriggerKind kind)
		{
			if (!Counts.TryGetValue(kind, out var value))
			{
				return 0;
			}
			return value;
		}

		internal static void Reset()
		{
			LastFired.Clear();
			Counts.Clear();
		}
	}
	internal enum TriggerKind
	{
		None,
		Hit,
		Kill,
		Backstab,
		Stagger,
		TookDamage,
		Blocked,
		Parried,
		Dodged,
		Jumped,
		TreeFelled,
		VeinMined,
		Harvested,
		Crafted,
		Built,
		PowerUsed,
		Brewed,
		Drank,
		Tamed,
		Bred
	}
	internal enum TriggerPayload
	{
		Buff,
		Health,
		Stamina,
		Eitr,
		HealthPct,
		StaminaPct,
		EitrPct
	}
	internal static class TriggerNames
	{
		private static readonly Dictionary<string, TriggerKind> Kinds = new Dictionary<string, TriggerKind>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"none",
				TriggerKind.None
			},
			{
				"hit",
				TriggerKind.Hit
			},
			{
				"kill",
				TriggerKind.Kill
			},
			{
				"backstab",
				TriggerKind.Backstab
			},
			{
				"stagger",
				TriggerKind.Stagger
			},
			{
				"took_damage",
				TriggerKind.TookDamage
			},
			{
				"blocked",
				TriggerKind.Blocked
			},
			{
				"parried",
				TriggerKind.Parried
			},
			{
				"dodged",
				TriggerKind.Dodged
			},
			{
				"jumped",
				TriggerKind.Jumped
			},
			{
				"tree_felled",
				TriggerKind.TreeFelled
			},
			{
				"vein_mined",
				TriggerKind.VeinMined
			},
			{
				"harvested",
				TriggerKind.Harvested
			},
			{
				"crafted",
				TriggerKind.Crafted
			},
			{
				"built",
				TriggerKind.Built
			},
			{
				"power_used",
				TriggerKind.PowerUsed
			},
			{
				"brewed",
				TriggerKind.Brewed
			},
			{
				"drank",
				TriggerKind.Drank
			},
			{
				"tamed",
				TriggerKind.Tamed
			},
			{
				"bred",
				TriggerKind.Bred
			}
		};

		private static readonly Dictionary<string, TriggerPayload> Payloads = new Dictionary<string, TriggerPayload>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"buff",
				TriggerPayload.Buff
			},
			{
				"health",
				TriggerPayload.Health
			},
			{
				"stamina",
				TriggerPayload.Stamina
			},
			{
				"eitr",
				TriggerPayload.Eitr
			},
			{
				"health_pct",
				TriggerPayload.HealthPct
			},
			{
				"stamina_pct",
				TriggerPayload.StaminaPct
			},
			{
				"eitr_pct",
				TriggerPayload.EitrPct
			}
		};

		internal static bool TryKind(string name, out TriggerKind kind)
		{
			return Kinds.TryGetValue(name ?? string.Empty, out kind);
		}

		internal static bool TryPayload(string name, out TriggerPayload payload)
		{
			return Payloads.TryGetValue(name ?? string.Empty, out payload);
		}
	}
	internal static class TriggerRuntime
	{
		private static bool _subscribed;

		internal static int TriggeredPerkCount
		{
			get
			{
				int num = 0;
				foreach (PerkTree value in PerkDatabase.Trees.Values)
				{
					foreach (PerkNode node in value.Nodes)
					{
						if (node.Effects == null)
						{
							continue;
						}
						foreach (EffectSpec effect in node.Effects)
						{
							if (!effect.IsPending && effect.HasTrigger)
							{
								num++;
								break;
							}
						}
					}
				}
				return num;
			}
		}

		internal static void Init()
		{
			if (!_subscribed)
			{
				TriggerBus.Subscribe(OnTrigger);
				_subscribed = true;
			}
		}

		internal static void Shutdown()
		{
			if (_subscribed)
			{
				TriggerBus.Unsubscribe(OnTrigger);
				_subscribed = false;
				Cadence.Reset();
			}
		}

		internal static void Reset()
		{
			Cadence.Reset();
			TimedBuffs.Clear();
			TriggerBus.Reset();
		}

		private static void OnTrigger(TriggerKind kind, TriggerContext context)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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)
			PerkState current = PerkState.Current;
			if (current == null || !current.Ready)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			foreach (KeyValuePair<string, int> item in current.Allocated)
			{
				int value = item.Value;
				if (value <= 0)
				{
					continue;
				}
				PerkNode perkNode = PerkDatabase.Node(item.Key);
				if (perkNode?.Effects == null)
				{
					continue;
				}
				for (int i = 0; i < perkNode.Effects.Count; i++)
				{
					EffectSpec effectSpec = perkNode.Effects[i];
					if (!effectSpec.IsPending && effectSpec.Trigger == kind && ((int)effectSpec.TriggerSkill == 0 || effectSpec.TriggerSkill == context.Skill))
					{
						string key = perkNode.Id + "#" + i;
						if ((effectSpec.TriggerEvery <= 1 || Cadence.Due(effectSpec, key, context)) && Conditions.Holds(effectSpec, localPlayer) && (!(effectSpec.TriggerChance > 0f) || !(Random.value * 100f > effectSpec.TriggerChance)))
						{
							Apply(effectSpec, key, perkNode.Id, effectSpec.ValueAt(value), localPlayer);
						}
					}
				}
			}
		}

		private static void Apply(EffectSpec spec, string key, string nodeId, float value, Player player)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (value != 0f)
			{
				switch (spec.Payload)
				{
				case TriggerPayload.Buff:
					TimedBuffs.Grant(key, nodeId, spec.Kind, spec.Skill, spec.AppliesToAllSkills, value, spec.TriggerMaxStacks, spec.TriggerDuration);
					break;
				case TriggerPayload.Health:
					((Character)player).Heal(value, true);
					break;
				case TriggerPayload.Stamina:
					((Character)player).AddStamina(value);
					break;
				case TriggerPayload.Eitr:
					((Character)player).AddEitr(value);
					break;
				case TriggerPayload.HealthPct:
					((Character)player).Heal(((Character)player).GetMaxHealth() * value / 100f, true);
					break;
				case TriggerPayload.StaminaPct:
					((Character)player).AddStamina(((Character)player).GetMaxStamina() * value / 100f);
					break;
				case TriggerPayload.EitrPct:
					((Character)player).AddEitr(((Character)player).GetMaxEitr() * value / 100f);
					break;
				}
			}
		}
	}
}
namespace Norntastic.Effects.Handlers
{
	internal static class Bleed
	{
		internal static SE_DamageOverTime On(Character target)
		{
			return DamageOverTime.On(target, DotKind.Bleed);
		}

		internal static void Apply(Character target, float damage, Character source)
		{
			DamageOverTime.Apply(target, DotKind.Bleed, damage, source);
		}
	}
	internal sealed class LodgedDeepHandler : PerkHandler
	{
		internal override string NodeId => "ax4";

		internal override SkillType HitSkill => (SkillType)7;

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			Bleed.Apply(target, (rank >= 2) ? 8f : 4f, hit.GetAttacker());
		}
	}
	internal sealed class BloodGrooveHandler : PerkHandler
	{
		internal override string NodeId => "sw2";

		internal override SkillType HitSkill => (SkillType)1;

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			float num = ((rank >= 3) ? 12f : ((rank == 2) ? 8f : 4f));
			if (rank < 3)
			{
				SE_DamageOverTime sE_DamageOverTime = Bleed.On(target);
				if ((Object)(object)sE_DamageOverTime != (Object)null && sE_DamageOverTime.Remaining >= num)
				{
					return;
				}
			}
			Bleed.Apply(target, num, hit.GetAttacker());
		}
	}
	internal sealed class RedHarvestHandler : PerkHandler
	{
		internal override string NodeId => "sw4";

		internal override SkillType HitSkill => (SkillType)1;

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			SE_DamageOverTime sE_DamageOverTime = Bleed.On(target);
			if (!((Object)(object)sE_DamageOverTime == (Object)null) && !(sE_DamageOverTime.Remaining <= 0f))
			{
				float num = ((rank >= 3) ? 0.18f : ((rank == 2) ? 0.12f : 0.06f));
				hit.ApplyModifier(1f + num);
				if (rank >= 3)
				{
					Bleed.Apply(target, 4f, hit.GetAttacker());
				}
			}
		}
	}
	internal sealed class BloodDebtHandler : PerkHandler
	{
		internal override string NodeId => "sw11";

		internal override void OnActivate(int rank)
		{
			BleedLedger.BleedTicked += OnBleedTick;
		}

		internal override void OnDeactivate()
		{
			BleedLedger.BleedTicked -= OnBleedTick;
		}

		private static void OnBleedTick(Character source, float amount)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)source != (Object)(object)localPlayer) && !(amount <= 0f))
			{
				((Character)localPlayer).Heal(amount * 0.2f, false);
			}
		}
	}
	internal sealed class NineCutsHandler : PerkHandler
	{
		private readonly HitCounter _counter = new HitCounter(9);

		internal override string NodeId => "sw12";

		internal override SkillType HitSkill => (SkillType)1;

		internal override void OnDeactivate()
		{
			_counter.Clear();
		}

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			if (_counter.Advance(target))
			{
				hit.ApplyModifier(2.5f);
				SE_DamageOverTime sE_DamageOverTime = Bleed.On(target);
				if (!((Object)(object)sE_DamageOverTime == (Object)null) && !(sE_DamageOverTime.Remaining <= 0f))
				{
					hit.m_damage.m_slash += sE_DamageOverTime.Remaining;
					sE_DamageOverTime.Consume();
				}
			}
		}
	}
	internal static class ComboCounter
	{
		private const float BreakAfter = 1.6f;

		private static int _count;

		private static float _lastHit = -99f;

		private static SkillType _skill = (SkillType)0;

		internal static int Current
		{
			get
			{
				if (!(Time.time - _lastHit > 1.6f))
				{
					return _count;
				}
				return 0;
			}
		}

		internal static int Advance(SkillType skill)
		{
			//IL_0013: 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_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)
			float time = Time.time;
			if (time - _lastHit > 1.6f || skill != _skill)
			{
				_count = 0;
			}
			_skill = skill;
			_lastHit = time;
			_count++;
			return _count;
		}

		internal static void Reset()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			_count = 0;
			_lastHit = -99f;
			_skill = (SkillType)0;
		}
	}
	internal sealed class LongHaulHandler : PerkHandler
	{
		internal override string NodeId => "ax5";

		internal static bool SparesAxeDurability { get; private set; }

		internal override void OnActivate(int rank)
		{
			SparesAxeDurability = true;
			Log.Debug("The Long Haul active: axes spared durability while chopping.");
		}

		internal override void OnDeactivate()
		{
			SparesAxeDurability = false;
		}
	}
	internal static class Handlers
	{
		internal static void RegisterAll()
		{
			DamageOverTime.Init();
			PerkHandlerRegistry.Register(new LongHaulHandler());
			PerkHandlerRegistry.Register(new LodgedDeepHandler());
			PerkHandlerRegistry.Register(new BloodGrooveHandler());
			PerkHandlerRegistry.Register(new RedHarvestHandler());
			PerkHandlerRegistry.Register(new BloodDebtHandler());
			PerkHandlerRegistry.Register(new NineCutsHandler());
			PerkHandlerRegistry.Register(new ThreeCountHandler());
			PerkHandlerRegistry.Register(new JawWorkHandler());
			PerkHandlerRegistry.Register(new BoneSetterHandler());
			PerkHandlerRegistry.Register(new FollowThroughHandler());
			PerkHandlerRegistry.Register(new ExecutionerHandler());
			PerkHandlerRegistry.Register(new VenomWorkHandler());
			PerkHandlerRegistry.Register(new ShockwaveHandler());
		}
	}
	internal sealed class HitCounter
	{
		private sealed class Entry
		{
			internal int Count;

			internal float LastHit;
		}

		private readonly int _period;

		private readonly float _forgetAfter;

		private readonly Dictionary<int, Entry> _counts = new Dictionary<int, Entry>();

		private float _lastSweep;

		internal HitCounter(int period, float forgetAfter = 20f)
		{
			_period = Mathf.Max(1, period);
			_forgetAfter = forgetAfter;
		}

		internal bool Advance(Character target)
		{
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			Sweep();
			int instanceID = ((Object)target).GetInstanceID();
			float time = Time.time;
			if (!_counts.TryGetValue(instanceID, out var value))
			{
				value = new Entry();
				_counts[instanceID] = value;
			}
			if (time - value.LastHit > _forgetAfter)
			{
				value.Count = 0;
			}
			value.LastHit = time;
			value.Count++;
			if (value.Count < _period)
			{
				return false;
			}
			value.Count = 0;
			return true;
		}

		internal void Clear()
		{
			_counts.Clear();
		}

		private void Sweep()
		{
			float time = Time.time;
			if (time - _lastSweep < 30f)
			{
				return;
			}
			_lastSweep = time;
			List<int> list = null;
			foreach (KeyValuePair<int, Entry> count in _counts)
			{
				if (!(time - count.Value.LastHit <= _forgetAfter))
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(count.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				_counts.Remove(item);
			}
		}
	}
	internal enum DotKind
	{
		Bleed,
		Poison
	}
	internal sealed class SE_DamageOverTime : StatusEffect
	{
		private const float Interval = 1f;

		internal DotKind Kind;

		private float _damageLeft;

		private float _timer;

		internal Character Source;

		internal float Remaining => _damageLeft;

		internal void Consume()
		{
			_damageLeft = 0f;
		}

		internal void AddDamage(float amount, Character source)
		{
			if (!(amount <= 0f))
			{
				_damageLeft += amount;
				Source = source;
			}
		}

		public override void UpdateStatusEffect(float dt)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			((StatusEffect)this).UpdateStatusEffect(dt);
			if ((Object)(object)base.m_character == (Object)null || _damageLeft <= 0f)
			{
				return;
			}
			_timer += dt;
			if (!(_timer < 1f))
			{
				_timer = 0f;
				float num = Mathf.Min(_damageLeft, Mathf.Max(1f, _damageLeft * 0.34f));
				_damageLeft -= num;
				HitData val = new HitData();
				if (Kind == DotKind.Poison)
				{
					val.m_damage.m_poison = num;
				}
				else
				{
					val.m_damage.m_slash = num;
				}
				val.m_point = ((Component)base.m_character).transform.position;
				val.m_dir = Vector3.up;
				val.m_blockable = false;
				val.m_dodgeable = false;
				val.m_skill = (SkillType)0;
				base.m_character.ApplyDamage(val, false, false, (DamageModifier)0);
				if (Kind == DotKind.Bleed)
				{
					BleedLedger.Report(Source, num);
				}
			}
		}

		public override bool IsDone()
		{
			return _damageLeft <= 0f;
		}

		public override string GetTooltipString()
		{
			if (!(_damageLeft > 0f))
			{
				return "";
			}
			return $"{Kind} for {_damageLeft:0} more";
		}
	}
	internal static class DamageOverTime
	{
		private static readonly Dictionary<DotKind, SE_DamageOverTime> Prototypes = new Dictionary<DotKind, SE_DamageOverTime>();

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

		internal static void Init()
		{
			foreach (DotKind value in Enum.GetValues(typeof(DotKind)))
			{
				string text = "SE_Norntastic" + value;
				SE_DamageOverTime sE_DamageOverTime = ScriptableObject.CreateInstance<SE_DamageOverTime>();
				((Object)sE_DamageOverTime).name = text;
				((StatusEffect)sE_DamageOverTime).m_name = "$norntastic_" + value.ToString().ToLowerInvariant();
				((StatusEffect)sE_DamageOverTime).m_ttl = 0f;
				sE_DamageOverTime.Kind = value;
				Prototypes[value] = sE_DamageOverTime;
				Hashes[value] = StringExtensionMethods.GetStableHashCode(text);
			}
		}

		internal static int Hash(DotKind kind)
		{
			if (!Hashes.TryGetValue(kind, out var value))
			{
				return 0;
			}
			return value;
		}

		internal static SE_DamageOverTime On(Character target, DotKind kind)
		{
			SEMan val = ((target != null) ? target.GetSEMan() : null);
			if (val == null)
			{
				return null;
			}
			return val.GetStatusEffect(Hash(kind)) as SE_DamageOverTime;
		}

		internal static void Apply(Character target, DotKind kind, float damage, Character source)
		{
			if ((Object)(object)target == (Object)null || damage <= 0f || !Prototypes.TryGetValue(kind, out var value))
			{
				return;
			}
			SEMan sEMan = target.GetSEMan();
			if (sEMan != null)
			{
				SE_DamageOverTime sE_DamageOverTime = sEMan.GetStatusEffect(Hash(kind)) as SE_DamageOverTime;
				if ((Object)(object)sE_DamageOverTime == (Object)null)
				{
					sE_DamageOverTime = sEMan.AddStatusEffect((StatusEffect)(object)value, false, 0, 0f, (short)(-1)) as SE_DamageOverTime;
				}
				if ((Object)(object)sE_DamageOverTime != (Object)null)
				{
					sE_DamageOverTime.AddDamage(damage, source);
				}
			}
		}
	}
	internal static class BleedLedger
	{
		internal static event Action<Character, float> BleedTicked;

		internal static void Report(Character source, float amount)
		{
			BleedLedger.BleedTicked?.Invoke(source, amount);
		}
	}
	internal sealed class ThreeCountHandler : PerkHandler
	{
		internal override string NodeId => "uw2";

		internal override SkillType HitSkill => (SkillType)11;

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			if (ComboCounter.Current % 3 == 0)
			{
				hit.ApplyModifier((rank >= 2) ? 1.25f : 1.15f);
				if (rank >= 2)
				{
					hit.m_pushForce += 20f;
				}
			}
		}
	}
	internal sealed class JawWorkHandler : PerkHandler
	{
		internal override string NodeId => "uw5";

		internal override SkillType HitSkill => (SkillType)11;

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			float num = ((rank >= 3) ? 0.6f : ((rank == 2) ? 0.4f : 0.2f));
			hit.m_staggerMultiplier += num;
		}
	}
	internal sealed class BoneSetterHandler : PerkHandler
	{
		internal override string NodeId => "uw7";

		internal override SkillType HitSkill => (SkillType)11;

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			float bodyArmor = target.GetBodyArmor();
			if (!(bodyArmor <= 0f))
			{
				float num = bodyArmor * ((rank >= 2) ? 0.3f : 0.15f);
				float totalDamage = hit.GetTotalDamage();
				if (!(totalDamage <= 0f))
				{
					hit.ApplyModifier((totalDamage + num) / totalDamage);
				}
			}
		}
	}
	internal sealed class FollowThroughHandler : PerkHandler
	{
		internal override string NodeId => "uw10";

		internal override SkillType HitSkill => (SkillType)11;

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			if (ComboCounter.Current % 4 == 0)
			{
				hit.ApplyModifier(1.5f);
				hit.m_pushForce += 35f;
				hit.m_staggerMultiplier += 0.5f;
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					((Character)localPlayer).AddStamina(8f);
				}
				Log.Debug($"Follow-Through on punch {ComboCounter.Current}.");
			}
		}
	}
	internal sealed class ExecutionerHandler : PerkHandler
	{
		internal override string NodeId => "ax9";

		internal override SkillType HitSkill => (SkillType)7;

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			if (!((Object)(object)target == (Object)null) && target.IsStaggering())
			{
				hit.ApplyModifier(1f + ((rank >= 3) ? 0.3f : ((rank == 2) ? 0.2f : 0.1f)));
			}
		}
	}
	internal sealed class VenomWorkHandler : PerkHandler
	{
		internal override string NodeId => "kn5";

		internal override SkillType HitSkill => (SkillType)2;

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			DamageOverTime.Apply(target, DotKind.Poison, (rank >= 2) ? 20f : 10f, hit.GetAttacker());
		}
	}
	internal sealed class ShockwaveHandler : PerkHandler
	{
		private const float Radius = 2f;

		internal override string NodeId => "cl5";

		internal override SkillType HitSkill => (SkillType)3;

		internal override void OnHit(Character target, HitData hit, int rank)
		{
			//IL_003d: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00a5: 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_00bc: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			float num = ((rank >= 2) ? 0.4f : 0.25f);
			float num2 = hit.GetTotalDamage() * num;
			if (num2 <= 0f)
			{
				return;
			}
			List<Character> allCharacters = Character.GetAllCharacters();
			if (allCharacters == null)
			{
				return;
			}
			Vector3 position = ((Component)target).transform.position;
			Character attacker = hit.GetAttacker();
			foreach (Character item in allCharacters)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item == (Object)(object)target || item.IsPlayer() || item.IsDead())
				{
					continue;
				}
				Vector3 val = ((Component)item).transform.position - position;
				if (!(((Vector3)(ref val)).sqrMagnitude > 4f))
				{
					HitData val2 = new HitData();
					val2.m_damage.m_blunt = num2;
					val2.m_point = ((Component)item).transform.position;
					val = ((Component)item).transform.position - position;
					val2.m_dir = ((Vector3)(ref val)).normalized;
					val2.m_blockable = false;
					val2.m_dodgeable = false;
					val2.m_skill = (SkillType)0;
					if ((Object)(object)attacker != (Object)null)
					{
						val2.SetAttacker(attacker);
					}
					item.Damage(val2);
				}
			}
		}
	}
}
namespace Norntastic.Data
{
	internal static class DatabaseFingerprint
	{
		internal static string Of(IEnumerable<PerkTree> trees)
		{
			if (trees == null)
			{
				return "0n/0t/00000000";
			}
			List<string> list = new List<string>();
			Dictionary<string, PerkTree> dictionary = new Dictionary<string, PerkTree>();
			foreach (PerkTree tree in trees)
			{
				if (tree != null && tree.Key != null)
				{
					list.Add(tree.Key);
					dictionary[tree.Key] = tree;
				}
			}
			list.Sort(StringComparer.Ordinal);
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			foreach (string item in list)
			{
				PerkTree perkTree = dictionary[item];
				stringBuilder.Append(item).Append('|');
				List<string> list2 = new List<string>();
				Dictionary<string, PerkNode> dictionary2 = new Dictionary<string, PerkNode>();
				foreach (PerkNode node in perkTree.Nodes)
				{
					if (node != null && node.Id != null)
					{
						list2.Add(node.Id);
						dictionary2[node.Id] = node;
					}
				}
				list2.Sort(StringComparer.Ordinal);
				foreach (string item2 in list2)
				{
					num++;
					Describe(stringBuilder, dictionary2[item2]);
				}
			}
			return $"{num}n/{list.Count}t/{Digest(stringBuilder.ToString())}";
		}

		private static void Describe(StringBuilder text, PerkNode node)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			text.Append(node.Id).Append(':').Append(node.MaxRank)
				.Append(':')
				.Append(node.RequiresLevel)
				.Append(':');
			foreach (EffectSpec effect in node.Effects)
			{
				text.Append((int)effect.Kind).Append(',').Append((int)effect.Condition)
					.Append(',')
					.Append((int)effect.Condition2)
					.Append(',')
					.Append((int)effect.Trigger)
					.Append(',')
					.Append((!effect.AppliesToAllSkills) ? ((int)effect.Skill) : 0)
					.Append(',');
				float[] values = effect.Values;
				foreach (float value in values)
				{
					text.Append(value).Append('.');
				}
				text.Append(';');
			}
			foreach (HitModifier hitModifier in node.HitModifiers)
			{
				text.Append('h').Append((int)hitModifier.When).Append(',')
					.Append((int)hitModifier.Field)
					.Append(',');
				float[] values = hitModifier.Values;
				foreach (float value2 in values)
				{
					text.Append(value2).Append('.');
				}
				text.Append(';');
			}
			foreach (SplashSpec splash in node.Splashes)
			{
				text.Append('s').Append((int)splash.When).Append(',')
					.Append(splash.Every)
					.Append(',');
				float[] values = splash.Values;
				foreach (float value3 in values)
				{
					text.Append(value3).Append('.');
				}
				values = splash.Radius;
				foreach (float value4 in values)
				{
					text.Append(value4).Append('.');
				}
				text.Append(';');
			}
			foreach (AfflictionSpec affliction in node.Afflictions)
			{
				text.Append('a').Append(affliction.EffectName).Append(',');
				float[] values = affliction.Chance;
				foreach (float value5 in values)
				{
					text.Append(value5).Append('.');
				}
				text.Append(';');
			}
			text.Append('\n');
		}

		private static string Digest(string text)
		{
			uint num = 2166136261u;
			foreach (char c in text)
			{
				num ^= c;
				num *= 16777619;
			}
			return num.ToString("x8");
		}
	}
	internal static class ForeignSkills
	{
		private static readonly Dictionary<string, string> Declared = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<string> Present = new HashSet<string>();

		internal static IEnumerable<KeyValuePair<string, string>> All => Declared;

		internal static int PresentCount => Present.Count;

		internal static int DeclaredCount => Declared.Count;

		internal static void Clear()
		{
			Declared.Clear();
			Present.Clear();
		}

		internal static SkillType TypeOf(string englishName)
		{
			if (string.IsNullOrEmpty(englishName))
			{
				return (SkillType)0;
			}
			return (SkillType)Math.Abs(StringExtensionMethods.GetStableHashCode(englishName));
		}

		internal static void Declare(string treeKey, string englishName)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(treeKey) && !string.IsNullOrEmpty(englishName))
			{
				Declared[treeKey] = englishName;
				SkillKeys.RegisterCustomKey(TypeOf(englishName), treeKey);
			}
		}

		internal static void NoteRegistered(SkillType type)
		{
			//IL_001c: 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)
			foreach (KeyValuePair<string, string> item in Declared)
			{
				if (TypeOf(item.Value) == type)
				{
					Present.Add(item.Key);
				}
			}
		}

		internal static bool IsPresent(string treeKey)
		{
			if (treeKey != null)
			{
				return Present.Contains(treeKey);
			}
			return false;
		}

		internal static bool IsForeign(string treeKey)
		{
			if (treeKey != null)
			{
				return Declared.ContainsKey(treeKey);
			}
			return false;
		}

		internal static string NameOf(string treeKey)
		{
			if (treeKey == null || !Declared.TryGetValue(treeKey, out var value))
			{
				return null;
			}
			return value;
		}
	}
	internal static class PerkDatabase
	{
		internal const string FileName = "perks.json";

		internal const string ShippedName = "perks.shipped.json";

		private const string EmbeddedName = "Norntastic.perks.json";

		internal static readonly Dictionary<string, PerkTree> Trees = new Dictionary<string, PerkTree>(StringComparer.OrdinalIgnoreCase);

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

		internal static int PointInterval { get; private set; } = 5;

		internal static int DeclaredNodes { get; private set; }

		internal static int DeclaredEffectMapped { get; private set; }

		internal static int DeclaredHandlerBacked { get; private set; }

		internal static int DeclaredStatic { get; private set; }

		internal static int DeclaredPartial { get; private set; }

		internal static int DeclaredTrees { get; private set; }

		internal static bool Loaded { get; private set; }

		internal static string Fingerprint { get; private set; } = "0n/0t/00000000";

		internal static PerkNode Node(string id)
		{
			if (id == null || !AllNodes.TryGetValue(id, out var value))
			{
				return null;
			}
			return value;
		}

		internal static PerkTree Tree(string key)
		{
			if (key == null || !Trees.TryGetValue(key, out var value))
			{
				return null;
			}
			return value;
		}

		internal static void Load(string configDir)
		{
			Trees.Clear();
			AllNodes.Clear();
			ForeignSkills.Clear();
			Loaded = false;
			string text = Path.Combine(configDir, "perks.json");
			try
			{
				Reconcile(configDir, text);
				ParseInto(File.ReadAllText(text));
				Loaded = true;
				Log.Info($"Perk database loaded: {Trees.Count} trees, {AllNodes.Count} nodes, " + $"interval {PointInterval}.");
			}
			catch (Exception ex)
			{
				Log.Error("Failed to load perk database from " + text + ": " + ex.Message);
				Log.Error("Perks are disabled for this session. Points are still tracked, so nothing is lost - fix the file and restart.");
			}
		}

		private static void Reconcile(string configDir, string path)
		{
			string text = ReadEmbedded();
			if (text == null)
			{
				if (!File.Exists(path))
				{
					Log.Error("No perks.json on disk and no embedded copy in the assembly. No trees will be available.");
				}
				return;
			}
			Directory.CreateDirectory(configDir);
			string path2 = Path.Combine(configDir, "perks.shipped.json");
			if (!File.Exists(path))
			{
				File.WriteAllText(path, text);
				File.WriteAllText(path2, text);
				Log.Info("Wrote the default perk database to " + path);
				return;
			}
			string text2 = (File.Exists(path2) ? File.ReadAllText(path2) : null);
			if (!(text2 == text))
			{
				string text3 = File.ReadAllText(path);
				if (text2 != null && text3 == text2)
				{
					File.WriteAllText(path, text);
					File.WriteAllText(path2, text);
					Log.Info("This build ships a newer perk database and yours was unmodified, so it has been updated. Your old copy was identical to the one the last build shipped, so nothing of yours was lost.");
				}
				else
				{
					File.WriteAllText(path2, text);
					Log.Warn("This build ships a newer perk database, and yours differs from the one on record - so yours has been left exactly as it is. If you did not mean to keep it, delete perks.json and restart; the new one is also sitting beside it as perks.shipped.json if you want to compare. In a group, everyone needs the same file: nsg.fingerprint says whether yours matches the server's.");
				}
			}
		}

		private static string ReadEmbedded()
		{
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Norntastic.perks.json");
			if (stream == null)
			{
				return null;
			}
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}

		private static void ParseInto(string text)
		{
			//IL_0174: 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_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			object o = Json.Parse(text);
			object obj = Json.Get(o, "economy");
			if (obj != null)
			{
				PointInterval = Math.Max(1, Json.Int(obj, "pointInterval", 10));
				object obj2 = Json.Get(obj, "coverage");
				if (obj2 != null)
				{
					DeclaredNodes = Json.Int(obj2, "nodes");
					DeclaredEffectMapped = Json.Int(obj2, "effectMapped");
					DeclaredHandlerBacked = Json.Int(obj2, "handlerBacked");
					DeclaredStatic = Json.Int(obj2, "staticallyImplemented");
					DeclaredPartial = Json.Int(obj2, "staticallyPartial");
				}
			}
			Dictionary<string, object> dictionary = Json.Obj(Json.Get(o, "sectors")) ?? new Dictionary<string, object>();
			Dictionary<string, object> obj3 = Json.Obj(Json.Get(o, "trees")) ?? throw new FormatException("perks.json has no 'trees' object");
			DeclaredTrees = obj3.Count;
			foreach (KeyValuePair<string, object> item in obj3)
			{
				string key = item.Key;
				object value = item.Value;
				PerkTree perkTree = new PerkTree
				{
					Key = key,
					Name = Json.Str(value, "name", key),
					Blurb = Json.Str(value, "blurb"),
					Kind = KindOf(Json.Str(value, "kind", "skill"))
				};
				if (Json.Get(value, "vanillaSkillId") is double num)
				{
					perkTree.SkillType = (SkillType)(int)num;
				}
				if (perkTree.Kind == TreeKind.Sector)
				{
					perkTree.Members = Json.StrList(value, "members");
					if (perkTree.Members.Count == 0 && dictionary.TryGetValue(key, out var value2))
					{
						perkTree.Members = Json.StrList(value2, "members");
					}
				}
				perkTree.RevealWith = Json.StrList(value, "revealWith");
				perkTree.AlwaysShown = Json.Bool(value, "alwaysShown");
				string text2 = Json.Str(value, "foreignSkill");
				if (!string.IsNullOrEmpty(text2))
				{
					ForeignSkills.Declare(key, text2);
					perkTree.ForeignSkill = text2;
					perkTree.SkillType = ForeignSkills.TypeOf(text2);
				}
				if (perkTree.Kind == TreeKind.Fork)
				{
					perkTree.ForkFor = Json.Str(value, "forkFor");
					PerkTree perkTree2 = Tree(perkTree.ForkFor);
					if (perkTree2 != null)
					{
						perkTree.SkillType = perkTree2.SkillType;
					}
				}
				if (perkTree.Kind == TreeKind.Style)
				{
					perkTree.StyleFor = Json.Str(value, "styleFor");
					PerkTree perkTree3 = Tree(perkTree.StyleFor);
					if (perkTree3 != null)
					{
						perkTree.SkillType = perkTree3.SkillType;
					}
				}
				List<object> list = Json.Arr(Json.Get(value, "nodes"));
				if (list != null)
				{
					foreach (object item2 in list)
					{
						PerkNode perkNode = new PerkNode
						{
							Id = Json.Str(item2, "id"),
							Name = Json.Str(item2, "name"),
							ImplementedBy = Json.Str(item2, "implementedBy"),
							ImplementedNote = Json.Str(item2, "implementedNote"),
							X = Json.Num(item2, "x"),
							Y = Json.Num(item2, "y"),
							MaxRank = Math.Max(1, Json.Int(item2, "maxRank", 1)),
							RequiresLevel = Json.Int(item2, "requiresLevel"),
							Requires = Json.StrList(item2, "requires"),
							Capstone = Json.Bool(item2, "capstone"),
							ExclusiveGroup = Json.Str(item2, "exclusiveGroup"),
							Flavour = Json.Str(item2, "flavour"),
							Ranks = Json.StrList(item2, "ranks"),
							TreeKey = key
						};
						if (string.IsNullOrEmpty(perkNode.Id))
						{
							Log.Warn("Tree '" + key + "' has a node with no id. Skipped.");
							continue;
						}
						if (AllNodes.ContainsKey(perkNode.Id))
						{
							Log.Warn("Duplicate perk id '" + perkNode.Id + "' in tree '" + key + "'. Skipped - ids must be unique across the whole database.");
							continue;
						}
						List<object> list2 = Json.Arr(Json.Get(item2, "effects"));
						if (list2 != null)
						{
							foreach (object item3 in list2)
							{
								perkNode.Effects.Add(EffectSpec.FromJson(item3, perkNode.MaxRank, perkNode.Id));
							}
						}
						List<object> list3 = Json.Arr(Json.Get(item2, "onHit"));
						if (list3 != null)
						{
							foreach (object item4 in list3)
							{
								HitModifier hitModifier = ReadHitModifier(item4, perkNode.Id);
								if (hitModifier != null)
								{
									perkNode.HitModifiers.Add(hitModifier);
								}
							}
						}
						List<object> list4 = Json.Arr(Json.Get(item2, "splash"));
						if (list4 != null)
						{
							foreach (object item5 in list4)
							{
								SplashSpec splashSpec = ReadSplash(item5, perkNode.Id);
								if (splashSpec != null)
								{
									perkNode.Splashes.Add(splashSpec);
								}
							}
						}
						List<object> list5 = Json.Arr(Json.Get(item2, "applies"));
						if (list5 != null)
						{
							foreach (object item6 in list5)
							{
								AfflictionSpec afflictionSpec = ReadAffliction(item6, perkNode.Id);
								if (afflictionSpec != null)
								{
									perkNode.Afflictions.Add(afflictionSpec);
								}
							}
						}
						if (perkNode.Ranks.Count != perkNode.MaxRank)
						{
							Log.Warn($"Perk '{perkNode.Id}' declares {perkNode.MaxRank} ranks but has " + $"{perkNode.Ranks.Count} rank descriptions.");
						}
						perkTree.Nodes.Add(perkNode);
						AllNodes[perkNode.Id] = perkNode;
					}
				}
				Trees[key] = perkTree;
			}
			ValidateReferences();
			HitModifierDriver.Rebuild();
			Splash.Rebuild();
			Afflictions.Rebuild();
			Fingerprint = DatabaseFingerprint.Of(Trees.Values);
			RegisterSubsystemClaims();
		}

		private static void RegisterSubsystemClaims()
		{
			int num = 0;
			foreach (PerkNode value in AllNodes.Values)
			{
				if (!string.IsNullOrEmpty(value.ImplementedBy))
				{
					PerkHandlerRegistry.MarkImplemented(value.Id, value.ImplementedBy);
					num++;
				}
			}
			if (num > 0)
			{
				Log.Debug($"{num} perks declare a subsystem implementation.");
			}
		}

		private static HitModifier ReadHitModifier(object raw, string nodeId)
		{
			//IL_0144: 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)
			string text = Json.Str(raw, "when", "any");
			if (!HitConditions.TryParse(text, out var kind))
			{
				Log.Warn("Perk '" + nodeId + "' declares unknown hit condition '" + text + "'. Ignored.");
				return null;
			}
			List<object> list = Json.Arr(Json.Get(raw, "values"));
			if (list == null || list.Count == 0)
			{
				Log.Warn("Perk '" + nodeId + "' has an onHit entry with no values. Ignored.");
				return null;
			}
			HitModifier hitModifier = new HitModifier
			{
				When = kind,
				NodeId = nodeId,
				ConditionValue = Json.Num(raw, "percent"),
				ConditionText = Json.Str(raw, "name"),
				Values = new float[list.Count]
			};
			for (int i = 0; i < list.Count; i++)
			{
				hitModifier.Values[i] = ((list[i] is double num) ? ((float)num) : 0f);
			}
			string text2 = Json.Str(raw, "skill", "any");
			if (!string.Equals(text2, "any", StringComparison.OrdinalIgnoreCase) && SkillKeys.TryResolve(text2, out var type))
			{
				hitModifier.Skill = type;
			}
			string text3 = Json.Str(raw, "changes", "damage");
			if (!HitConditions.TryParseField(text3, out var field))
			{
				Log.Warn("Perk '" + nodeId + "' onHit entry changes unknown field '" + text3 + "'. Ignored.");
				return null;
			}
			hitModifier.Field = field;
			return hitModifier;
		}

		private static TreeKind KindOf(string s)
		{
			return s.ToLowerInvariant() switch
			{
				"sector" => TreeKind.Sector, 
				"new" => TreeKind.New, 
				"stub" => TreeKind.Stub, 
				"style" => TreeKind.Style, 
				"fork" => TreeKind.Fork, 
				_ => TreeKind.Skill, 
			};
		}

		private static SplashSpec ReadSplash(object raw, string nodeId)
		{
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			List<object> list = Json.Arr(Json.Get(raw, "values"));
			List<object> list2 = Json.Arr(Json.Get(raw, "radius"));
			if (list == null || list.Count == 0 || list2 == null || list2.Count == 0)
			{
				Log.Warn("Perk '" + nodeId + "' has a splash entry without values or radius. Ignored.");
				return null;
			}
			string text = Json.Str(raw, "when", "any");
			if (!HitConditions.TryParse(text, out var kind))
			{
				Log.Warn("Perk '" + nodeId + "' splash declares unknown condition '" + text + "'. Ignored.");
				return null;
			}
			SplashSpec splashSpec = new SplashSpec
			{
				NodeId = nodeId,
				When = kind,
				ConditionValue = Json.Num(raw, "percent"),
				ConditionText = Json.Str(raw, "name"),
				StaggerPct = Json.Num(raw, "stagger"),
				Every = (int)Json.Num(raw, "every", 1f),
				Values = new float[list.Count],
				Radius = new float[list2.Count]
			};
			if (splashSpec.Every < 1)
			{
				splashSpec.Every = 1;
			}
			for (int i = 0; i < list.Count; i++)
			{
				splashSpec.Values[i] = ((list[i] is double num) ? ((float)num) : 0f);
			}
			for (int j = 0; j < list2.Count; j++)
			{
				splashSpec.Radius[j] = ((list2[j] is double num2) ? ((float)num2) : 0f);
			}
			string text2 = Json.Str(raw, "skill", "any");
			if (!string.Equals(text2, "any", StringComparison.OrdinalIgnoreCase) && SkillKeys.TryResolve(text2, out var type))
			{
				splashSpec.Skill = type;
			}
			return splashSpec;
		}

		private static AfflictionSpec ReadAffliction(object raw, string nodeId)
		{
			//IL_01ab: 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)
			string text = Json.Str(raw, "effect");
			if (string.IsNullOrEmpty(text))
			{
				Log.Warn("Perk '" + nodeId + "' has an applies entry with no effect name. Ignored.");
				return null;
			}
			List<object> list = Json.Arr(Json.Get(raw, "chance"));
			if (list == null || list.Count == 0)
			{
				Log.Warn("Perk '" + nodeId + "' applies '" + text + "' with no chance. Ignored.");
				return null;
			}
			string text2 = Json.Str(raw, "when", "any");
			if (!HitConditions.TryParse(text2, out var kind))
			{
				Log.Warn("Perk '" + nodeId + "' applies declares unknown condition '" + text2 + "'. Ignored.");
				return null;
			}
			AfflictionSpec afflictionSpec = new AfflictionSpec
			{
				NodeId = nodeId,
				EffectName = text,
				When = kind,
				ConditionValue = Json.Num(raw, "percent"),
				ConditionText = Json.Str(raw, "name"),
				ResetTime = Json.Bool(raw, "refresh", fallback: true),
				Chance = new float[list.Count]
			};
			for (int i = 0; i < list.Count; i++)
			{
				afflictionSpec.Chance[i] = ((list[i] is double num) ? ((float)num) : 0f);
			}
			string text3 = Json.Str(raw, "skill", "any");
			if (!string.Equals(text3, "any", StringComparison.OrdinalIgnoreCase) && SkillKeys.TryResolve(text3, out var type))
			{
				afflictionSpec.Skill = type;
			}
			string text4 = Json.Str(raw, "while", "always");
			if (!EffectSpec.TryParseCondition(text4, out var kind2))
			{
				Log.Warn("Perk '" + nodeId + "' applies declares unknown player condition '" + text4 + "'. Ignored.");
				return null;
			}
			afflictionSpec.While = kind2;
			afflictionSpec.WhileValue = Json.Num(raw, "whilePercent");
			afflictionSpec.WhileText = Json.Str(raw, "whileName");
			return afflictionSpec;
		}

		private static void ValidateReferences()
		{
			foreach (PerkTree value in Trees.Values)
			{
				foreach (PerkNode node in value.Nodes)
				{
					for (int num = node.Requires.Count - 1; num >= 0; num--)
					{
						if (value.Node(node.Requires[num]) == null)
						{
							Log.Warn("Perk '" + node.Id + "' requires '" + node.Requires[num] + "', which is not in tree '" + value.Key + "'. Requirement dropped.");
							node.Requires.RemoveAt(num);
						}
					}
				}
				if (!value.IsSector)
				{
					continue;
				}
				for (int num2 = value.Members.Count - 1; num2 >= 0; num2--)
				{
					if (!Trees.ContainsKey(value.Members[num2]))
					{
						Log.Warn("Sector '" + value.Key + "' lists member '" + value.Members[num2] + "', which is not a known tree. Member dropped.");
						value.Members.RemoveAt(num2);
					}
				}
				if (value.Members.Count == 0)
				{
					Log.Warn("Sector '" + value.Key + "' has no valid members. It will never earn points.");
				}
			}
		}

		internal static void AddTree(PerkTree tree)
		{
			Trees[tree.Key] = tree;
			foreach (PerkNode node in tree.Nodes)
			{
				if (!AllNodes.ContainsKey(node.Id))
				{
					AllNodes[node.Id] = node;
				}
			}
		}
	}
	internal sealed class PerkNode
	{
		internal string Id;

		internal string Name;

		internal float X;

		internal float Y;

		internal int MaxRank;

		internal int RequiresLevel;

		internal List<string> Requires = new List<string>();

		internal bool Capstone;

		internal string ExclusiveGroup = string.Empty;

		internal string Flavour;

		internal List<string> Ranks = new List<string>();

		internal List<EffectSpec> Effects = new List<EffectSpec>();

		internal List<HitModifier> HitModifiers = new List<HitModifier>();

		internal List<SplashSpec> Splashes = new List<SplashSpec>();

		internal List<AfflictionSpec> Afflictions = new List<AfflictionSpec>();

		internal string TreeKey;

		internal string ImplementedBy = string.Empty;

		internal string ImplementedNote = string.Empty;

		internal bool IsExclusive => !string.IsNullOrEmpty(ExclusiveGroup);

		internal bool IsImplemented
		{
			get
			{
				if (PerkHandlerRegistry.HasHandler(Id))
				{
					return true;
				}
				if (!string.IsNullOrEmpty(ImplementedBy))
				{
					return true;
				}
				if (HitModifiers != null && HitModifiers.Count > 0)
				{
					return true;
				}
				if (Splashes != null && Splashes.Count > 0)
				{
					return true;
				}
				if (Afflictions != null && Afflictions.Count > 0)
				{
					return true;
				}
				foreach (EffectSpec effect in Effects)
				{
					if (!effect.IsPending)
					{
						return true;
					}
				}
				return false;
			}
		}

		internal bool IsPartial
		{
			get
			{
				if (!IsImplemented || Effects == null)
				{
					return false;
				}
				foreach (EffectSpec effect in Effects)
				{
					if (effect.IsPending)
					{
						return true;
					}
				}
				return false;
			}
		}

		internal string PendingNote
		{
			get
			{
				foreach (EffectSpec effect in Effects)
				{
					if (effect.IsPending && !string.IsNullOrEmpty(effect.Note))
					{
						return effect.Note;
					}
				}
				return "not yet implemented";
			}
		}

		internal string RankText(int rank)
		{
			if (rank < 1 || rank > Ranks.Count)
			{
				return string.Empty;
			}
			return Ranks[rank - 1];
		}
	}
	internal enum TreeKind
	{
		Skill,
		Sector,
		New,
		Stub,
		Style,
		Fork
	}
	internal sealed class PerkTree
	{
		internal string Key;

		internal string Name;

		internal TreeKind Kind;

		internal string Blurb;

		internal SkillType SkillType;

		internal List<string> Members = new List<string>();

		internal List<string> RevealWith = new List<string>();

		internal bool AlwaysShown;

		internal string StyleFor = string.Empty;

		internal string ForkFor = string.Empty;

		internal string ForeignSkill = string.Empty;

		internal List<PerkNode> Nodes = new List<PerkNode>();

		private Dictionary<string, PerkNode> _byId;

		internal bool IsStyle => Kind == TreeKind.Style;

		internal bool IsFork => Kind == TreeKind.Fork;

		internal bool IsForeign => !string.IsNullOrEmpty(ForeignSkill);

		internal bool RidesAnotherSkill
		{
			get
			{
				if (!IsStyle)
				{
					return IsFork;
				}
				return true;
			}
		}

		internal string RidesKey
		{
			get
			{
				if (!IsStyle)
				{
					if (!IsFork)
					{
						return null;
					}
					return ForkFor;
				}
				return StyleFor;
			}
		}

		internal int TotalRanks
		{
			get
			{
				int num = 0;
				foreach (PerkNode node in Nodes)
				{
					num += node.MaxRank;
				}
				return num;
			}
		}

		internal bool IsSector => Kind == TreeKind.Sector;

		internal PerkNode Node(string id)
		{
			if (_byId == null)
			{
				_byId = new Dictionary<string, PerkNode>(Nodes.Count);
				foreach (PerkNode node in Nodes)
				{
					_byId[node.Id] = node;
				}
			}
			if (!_byId.TryGetValue(id, out var value))
			{
				return null;
			}
			return value;
		}
	}
	internal static class StubTreeGenerator
	{
		private static readonly float[,] Lattice = new float[12, 4]
		{
			{ 50f, 93f, 3f, 0f },
			{ 32f, 79f, 3f, 10f },
			{ 68f, 79f, 2f, 10f },
			{ 14f, 65f, 3f, 25f },
			{ 50f, 65f, 2f, 25f },
			{ 86f, 65f, 2f, 25f },
			{ 32f, 51f, 2f, 45f },
			{ 68f, 51f, 2f, 45f },
			{ 14f, 37f, 1f, 60f },
			{ 86f, 37f, 2f, 60f },
			{ 50f, 22f, 1f, 75f },
			{ 50f, 8f, 1f, 100f }
		};

		private static readonly int[][] Edges = new int[12][]
		{
			new int[0],
			new int[1],
			new int[1],
			new int[1] { 1 },
			new int[2] { 1, 2 },
			new int[1] { 2 },
			new int[2] { 3, 4 },
			new int[2] { 4, 5 },
			new int[1] { 6 },
			new int[1] { 7 },
			new int[2] { 8, 9 },
			new int[1] { 10 }
		};

		private static readonly string[] SlotNames = new string[12]
		{
			"Practised Hand", "Steady Effort", "Quick Study", "Deep Groove", "Even Keel", "Second Nature", "Hard Won", "Long Practice", "Unbroken Habit", "Mastery",
			"Beyond Teaching", "Wyrd of the Craft"
		};

		internal static PerkTree Build(SkillType type, string displayName)
		{
			//IL_0000: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			string text = SkillKeys.Key(type);
			PerkTree perkTree = new PerkTree
			{
				Key = text,
				Name = displayName,
				Kind = TreeKind.Stub,
				SkillType = type,
				Blurb = "Auto-generated tree for a skill added by another mod. Generic bonuses, so it never claims to know what this skill does."
			};
			for (int i = 0; i < Lattice.GetLength(0); i++)
			{
				int maxRank = (int)Lattice[i, 2];
				PerkNode perkNode = new PerkNode
				{
					Id = text + "_s" + i,
					Name = SlotNames[i],
					X = Lattice[i, 0],
					Y = Lattice[i, 1],
					MaxRank = maxRank,
					RequiresLevel = (int)Lattice[i, 3],
					Capstone = (i == 11),
					TreeKey = text,
					Flavour = ((i == 0) ? "Generated. Edit perks.json to give it a real identity." : ""),
					Ranks = BuildRanks(i, maxRank, displayName)
				};
				int[] array = Edges[i];
				foreach (int num in array)
				{
					perkNode.Requires.Add(text + "_s" + num);
				}
				perkTree.Nodes.Add(perkNode);
			}
			return perkTree;
		}

		private static List<string> BuildRanks(int slot, int maxRank, string skillName)
		{
			List<string> list = new List<string>(maxRank);
			for (int i = 1; i <= maxRank; i++)
			{
				switch (slot)
				{
				case 0:
				case 3:
					list.Add($"+{i * 4}% effectiveness with {skillName}");
					break;
				case 1:
				case 6:
					list.Add($"-{i * 6}% stamina cost for {skillName} actions");
					break;
				case 2:
				case 5:
					list.Add($"+{i * 8}% {skillName} experience gain");
					break;
				case 4:
				case 7:
					list.Add($"{skillName} counts as {i * 2} levels higher");
					break;
				case 8:
					list.Add(skillName + " no longer degrades on death");
					break;
				case 9:
					list.Add($"+{i * 5}% effectiveness and -{i * 5}% stamina with {skillName}");
					break;
				case 10:
					list.Add(skillName + " gains are doubled while below level 50");
					break;
				default:
					list.Add(skillName + " counts as 10 levels higher, and never falls below 50");
					break;
				}
			}
			return list;
		}
	}
}
namespace Norntastic.Creatures
{
	internal static class Awareness
	{
		private const float Interval = 0.5f;

		private const float MaxRadius = 60f;

		private static float _next;

		internal static bool Available { get; private set; } = true;

		internal static int Shed { get; private set; }

		private static void Disable(string reason)
		{
			if (Available)
			{
				Available = false;
				Log.Warn("Awareness perks turned themselves off: " + reason + ". Everything else keeps working.");
			}
		}

		internal static void Reset()
		{
			Shed = 0;
			_next = 0f;
		}

		internal static void Tick(Player player)
		{
			//IL_0098: 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)
			if (!Available || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer || Time.time < _next)
			{
				return;
			}
			_next = Time.time + 0.5f;
			float num = EffectAggregator.Pct(EffectKind.AggroShedMetres);
			float num2 = EffectAggregator.Pct(EffectKind.FearRadiusMetres);
			if (num <= 0f && num2 <= 0f)
			{
				return;
			}
			float reach = Mathf.Min(60f, Mathf.Max(num, num2));
			List<MonsterAI> list = Hunters(player, reach);
			if (list.Count == 0)
			{
				return;
			}
			foreach (MonsterAI item in list)
			{
				float num3 = Vector3.Distance(((Component)player).transform.position, ((Component)item).transform.position);
				if (num2 > 0f && num3 <= num2)
				{
					Flee(item);
				}
				else if (num > 0f && num3 <= num)
				{
					Forget(item);
				}
			}
		}

		private static List<MonsterAI> Hunters(Player player, float reach)
		{
			//IL_0042: 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)
			List<MonsterAI> list = new List<MonsterAI>();
			List<Character> allCharacters = Character.GetAllCharacters();
			if (allCharacters == null)
			{
				return list;
			}
			foreach (Character item in allCharacters)
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item == (Object)(object)player) && !item.IsPlayer() && !(Vector3.Distance(((Component)player).transform.position, ((Component)item).transform.position) > reach))
				{
					MonsterAI component = ((Component)item).GetComponent<MonsterAI>();
					if (!((Object)(object)component == (Object)null) && !((Object)(object)((BaseAI)component).GetTargetCreature() != (Object)(object)player))
					{
						list.Add(component);
					}
				}
			}
			return list;
		}

		private static void Forget(MonsterAI ai)
		{
			try
			{
				Traverse val = Traverse.Create((object)ai);
				Traverse val2 = val.Method("SetTarget", new Type[1] { typeof(Character) }, (object[])null);
				if (!val2.MethodExists())
				{
					Disable("MonsterAI.SetTarget is not where it used to be");
					return;
				}
				val2.GetValue(new object[1]);
				Traverse val3 = val.Method("SetAlerted", new Type[1] { typeof(bool) }, (object[])null);
				if (val3.MethodExists())
				{
					val3.GetValue(new object[1] { false });
				}
				Shed++;
			}
			catch (Exception ex)
			{
				Disable("clearing a target threw: " + ex.Message);
			}
		}

		private static void Flee(MonsterAI ai)
		{
			//IL_002d: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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)
			Forget(ai);
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				Character component = ((Component)ai).GetComponent<Character>();
				if (!((Object)(object)component == (Object)null))
				{
					Vector3 val = ((Component)component).transform.position - ((Component)localPlayer).transform.position;
					Vector3 normalized = ((Vector3)(ref val)).normalized;
					component.ApplyPushback(normalized, 8f);
				}
			}
		}
	}
}
namespace Norntastic.Core
{
	internal static class DatabaseGuard
	{
		private static string _mine = string.Empty;

		private static string _reported = string.Empty;

		internal static string Mine => _mine;

		internal static void Arm()
		{
			_mine = PerkDatabase.Fingerprint;
			if (ModConfig.DatabaseFingerprint != null)
			{
				ModConfig.DatabaseFingerprint.Value = _mine;
				Log.Info("Perk database fingerprint " + _mine + ".");
			}
		}

		internal static void Check()
		{
			string text = ModConfig.DatabaseFingerprint?.Value;
			if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(_mine) && !(text == _mine) && !(text == _reported))
			{
				_reported = text;
				Log.Error("Your perk database does not match the server's. The server has " + Describe(text) + "; you have " + Describe(_mine) + ". Your perks will not do what the server's owner thinks they do. Copy their config/Norntastic/perks.json over yours and run nsg.reload, or ask them for the file.");
				Announce("Norntastic: your perk database differs from the server's. See the log - your numbers are not theirs.");
			}
		}

		internal static string Describe(string fingerprint)
		{
			if (string.IsNullOrEmpty(fingerprint))
			{
				return "nothing";
			}
			string[] array = fingerprint.Split('/');
			if (array.Length != 3)
			{
				return fingerprint;
			}
			return array[0].TrimEnd('n') + " nodes across " + array[1].TrimEnd('t') + " trees (" + array[2] + ")";
		}

		private static void Announce(string message)
		{
			MessageHud instance = MessageHud.instance;
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				instance.ShowMessage((MessageType)2, message, 0, (Sprite)null, false, false);
			}
		}
	}
	internal static class PerkEvents
	{
		internal static event Action AllocationChanged;

		internal static void RaiseAllocationChanged()
		{
			PerkEvents.AllocationChanged?.Invoke();
		}
	}
	internal sealed class PerkState
	{
		internal readonly Dictionary<string, float> HighWater = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		internal readonly Dictionary<string, int> Allocated = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

		internal readonly Dictionary<string, int> Prestige = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

		private const AttackStyle Styles_Default = AttackStyle.Balanced;

		internal readonly Dictionary<string, AttackStyle> Styles = new Dictionary<string, AttackStyle>(StringComparer.OrdinalIgnoreCase);

		internal int RespecPoints;

		internal bool Ready;

		internal static PerkState Current { get; private set; } = new PerkState();

		internal static void Replace(PerkState state)
		{
			Current = state ?? new PerkState();
		}

		internal static void Reset()
		{
			Current = new PerkState();
		}

		internal float GetHighWater(string skillKey)
		{
			if (!HighWater.TryGetValue(skillKey, out var value))
			{
				return 0f;
			}
			return value;
		}

		internal int GetPrestige(string skillKey)
		{
			if (!Prestige.TryGetValue(skillKey, out var value))
			{
				return 0;
			}
			return value;
		}

		internal AttackStyle GetStyle(string skillKey)
		{
			if (!Styles.TryGetValue(skillKey, out var value))
			{
				return AttackStyle.Balanced;
			}
			return value;
		}

		internal void SetStyle(string skillKey, AttackStyle style)
		{
			if (style == AttackStyle.Balanced)
			{
				Styles.Remove(skillKey);
			}
			else
			{
				Styles[skillKey] = style;
			}
		}

		internal int GetRank(string nodeId)
		{
			if (!Allocated.TryGetValue(nodeId, out var value))
			{
				return 0;
			}
			return value;
		}

		internal void SetRank(string nodeId, int rank)
		{
			if (rank <= 0)
			{
				Allocated.Remove(nodeId);
			}
			else
			{
				Allocated[nodeId] = rank;
			}
		}

		internal bool RaiseHighWater(string skillKey, float level)
		{
			if (string.IsNullOrEmpty(skillKey))
			{
				return false;
			}
			if (HighWater.TryGetValue(skillKey, out var value) && value >= level)
			{
				return false;
			}
			HighWater[skillKey] = level;
			return true;
		}

		internal void SeedFrom(Skills skills)
		{
			//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)
			//IL_0043: 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)
			if ((Object)(object)skills == (Object)null)
			{
				return;
			}
			List<Skill> skillList = skills.GetSkillList();
			if (skillList == null)
			{
				return;
			}
			int num = 0;
			foreach (Skill item in skillList)
			{
				if (item?.m_info != null)
				{
					SkillType skill = item.m_info.m_skill;
					if (SkillKeys.IsRealSkill(skill) && RaiseHighWater(SkillKeys.Key(skill), item.m_level))
					{
						num++;
					}
				}
			}
			Ready = true;
			Log.Info($"Seeded high-water marks for {num} skills. " + $"Retroactive points: {PointMath.Earned(this)}.");
		}

		internal void RatchetAll(Skills skills)
		{
			//IL_003a: 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_0040: 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)
			if ((Object)(object)skills == (Object)null)
			{
				return;
			}
			List<Skill> skillList = skills.GetSkillList();
			if (skillList == null)
			{
				return;
			}
			foreach (Skill item in skillList)
			{
				if (item?.m_info != null)
				{
					SkillType skill = item.m_info.m_skill;
					if (SkillKeys.IsRealSkill(skill))
					{
						RaiseHighWater(SkillKeys.Key(skill), item.m_level);
					}
				}
			}
		}
	}
	internal static class PerkStateStore
	{
		internal const string CustomDataKey = "Norntastic.v1";

		private const string LegacyKey = "NornsLoom.v1";

		private const string Version = "nl1";

		internal static string Serialise(PerkState state)
		{
			StringBuilder stringBuilder = new StringBuilder(256);
			stringBuilder.Append("nl1");
			stringBuilder.Append("|hw:");
			AppendFloats(stringBuilder, state.HighWater);
			stringBuilder.Append("|pk:");
			AppendInts(stringBuilder, state.Allocated);
			stringBuilder.Append("|pz:");
			AppendInts(stringBuilder, state.Prestige);
			stringBuilder.Append("|st:");
			bool flag = true;
			foreach (KeyValuePair<string, AttackStyle> style in state.Styles)
			{
				if (!flag)
				{
					stringBuilder.Append(',');
				}
				flag = false;
				stringBuilder.Append(style.Key).Append('=').Append((int)style.Value);
			}
			stringBuilder.Append("|rp:").Append(state.RespecPoints.ToString(CultureInfo.InvariantCulture));
			return stringBuilder.ToString();
		}

		internal static PerkState Deserialise(string payload)
		{
			PerkState perkState = new PerkState();
			if (string.IsNullOrEmpty(payload))
			{
				return perkState;
			}
			string[] array = payload.Split('|');
			if (array.Length == 0 || array[0] != "nl1")
			{
				Log.Warn("Perk payload has version '" + ((array.Length != 0) ? array[0] : "?") + "', expected 'nl1'. Reading it anyway; unknown sections are ignored.");
			}
			for (int i = 1; i < array.Length; i++)
			{
				string text = array[i];
				int num = text.IndexOf(':');
				if (num < 0)
				{
					continue;
				}
				string text2 = text.Substring(0, num);
				string text3 = text.Substring(num + 1);
				switch (text2)
				{
				case "hw":
					ReadFloats(text3, perkState.HighWater);
					break;
				case "pk":
					ReadInts(text3, perkState.Allocated);
					break;
				case "pz":
					ReadInts(text3, perkState.Prestige);
					break;
				case "st":
					foreach (KeyValuePair<string, string> item in Split(text3))
					{
						if (int.TryParse(item.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
						{
							perkState.SetStyle(item.Key, (AttackStyle)result2);
						}
					}
					break;
				case "rp":
				{
					if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						perkState.RespecPoints = Math.Max(0, result);
					}
					break;
				}
				default:
					Log.Debug("Ignoring unknown perk payload section '" + text2 + "'.");
					break;
				}
			}
			perkState.Ready = true;
			return perkState;
		}

		internal static bool TryLoadInto(Player player, out PerkState state)
		{
			state = null;
			if (player?.m_customData == null)
			{
				return false;
			}
			if (!player.m_customData.TryGetValue("Norntastic.v1", out var value) || string.IsNullOrEmpty(value))
			{
				if (!player.m_customData.TryGetValue("NornsLoom.v1", out value) || string.IsNullOrEmpty(value))
				{
					return false;
				}
				Log.Info("Found perks saved under the old Norntastic key. Migrating - nothing is lost, and the old key is left in place until the next save.");
			}
			try
			{
				state = Deserialise(value);
				return true;
			}
			catch (Exception ex)
			{
				Log.Error("Could not read saved perks: " + ex.Message);
				Log.Error("Leaving the existing payload untouched so nothing is destroyed. Perks will be unavailable until it is fixed or cleared.");
				return false;
			}
		}

		internal static void SaveInto(Player player, PerkState state)
		{
			if (player?.m_customData == null || state == null)
			{
				return;
			}
			try
			{
				player.m_customData["Norntastic.v1"] = Serialise(state);
			}
			catch (Exception ex)
			{
				Log.Error("Could not write perks to the character: " + ex.Message);
			}
		}

		private static void AppendFloats(StringBuilder sb, Dictionary<string, float> map)
		{
			bool flag = true;
			foreach (KeyValuePair<string, float> item in map)
			{
				if (!(item.Value <= 0f))
				{
					if (!flag)
					{
						sb.Append(',');
					}
					flag = false;
					sb.Append(item.Key).Append('=').Append(item.Value.ToString("0.###", CultureInfo.InvariantCulture));
				}
			}
		}

		private static void AppendInts(StringBuilder sb, Dictionary<string, int> map)
		{
			bool flag = true;
			foreach (KeyValuePair<string, int> item in map)
			{
				if (item.Value > 0)
				{
					if (!flag)
					{
						sb.Append(',');
					}
					flag = false;
					sb.Append(item.Key).Append('=').Append(item.Value.ToString(CultureInfo.InvariantCulture));
				}
			}
		}

		private static void ReadFloats(string body, Dictionary<string, float> into)
		{
			foreach (KeyValuePair<string, string> item in Split(body))
			{
				if (float.TryParse(item.Value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					into[item.Key] = result;
				}
			}
		}

		private static void ReadInts(string body, Dictionary<string, int> into)
		{
			foreach (KeyValuePair<string, string> item in Split(body))
			{
				if (int.TryParse(item.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result > 0)
				{
					into[item.Key] = result;
				}
			}
		}

		private static IEnumerable<KeyValuePair<string, string>> Split(string body)
		{
			if (string.IsNullOrEmpty(body))
			{
				yield break;
			}
			string[] array = body.Split(',');
			foreach (string text in array)
			{
				if (text.Length != 0)
				{
					int num = text.IndexOf('=');
					if (num > 0)
					{
						yield return new KeyValuePair<string, string>(text.Substring(0, num), text.Substring(num + 1));
					}
				}
			}
		}
	}
	internal static class PointMath
	{
		internal enum Gate
		{
			Ok,
			AlreadyMaxed,
			LevelTooLow,
			MissingPrerequisite,
			NoPointsAvailable,
			ExclusiveLocked,
			UnknownPerk
		}

		internal static int Earned(PerkState state)
		{
			if (state == null)
			{
				return 0;
			}
			float num = 0f;
			int num2 = 0;
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				if (!value.IsSector && !value.RidesAnotherSkill)
				{
					num += state.GetHighWater(value.Key);
					num2 += state.GetPrestige(value.Key);
				}
			}
			int num3 = Math.Max(1, PerkDatabase.PointInterval);
			return (int)Math.Floor(num / (float)num3) + num2 * Math.Max(0, ModConfig.PrestigePoints.Value);
		}

		internal static int Spent(PerkState state)
		{
			if (state == null)
			{
				return 0;
			}
			int num = 0;
			foreach (KeyValuePair<string, int> item in state.Allocated)
			{
				num += item.Value;
			}
			return num;
		}

		internal static int Available(PerkState state)
		{
			return Earned(state) - Spent(state);
		}

		internal static int SpentIn(PerkState state, PerkTree tree)
		{
			if (state == null || tree == null)
			{
				return 0;
			}
			int num = 0;
			foreach (PerkNode node in tree.Nodes)
			{
				num += state.GetRank(node.Id);
			}
			return num;
		}

		internal static float CombinedLevels(PerkState state)
		{
			if (state == null)
			{
				return 0f;
			}
			float num = 0f;
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				if (!value.IsSector && !value.RidesAnotherSkill)
				{
					num += state.GetHighWater(value.Key);
				}
			}
			return num;
		}

		internal static float ToNextPoint(PerkState state)
		{
			int num = Math.Max(1, PerkDatabase.PointInterval);
			float num2 = CombinedLevels(state);
			return (float)num - num2 % (float)num;
		}

		internal static Gate CanBuy(PerkState state, PerkNode node, out string reason)
		{
			reason = string.Empty;
			if (state == null || node == null)
			{
				reason = "Unknown perk.";
				return Gate.UnknownPerk;
			}
			PerkTree perkTree = PerkDatabase.Tree(node.TreeKey);
			if (perkTree == null)
			{
				reason = "Unknown tree.";
				return Gate.UnknownPerk;
			}
			if (state.GetRank(node.Id) >= node.MaxRank)
			{
				reason = node.Name + " is already at maximum rank.";
				return Gate.AlreadyMaxed;
			}
			float num = LevelFor(state, perkTree);
			if (num < (float)node.RequiresLevel)
			{
				reason = $"{node.Name} needs {perkTree.Name} at {node.RequiresLevel}; you are at {(int)num}.";
				return Gate.LevelTooLow;
			}
			if (node.Requires.Count > 0)
			{
				bool flag = false;
				foreach (string require in node.Requires)
				{
					if (state.GetRank(require) > 0)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					List<string> list = new List<string>();
					foreach (string require2 in node.Requires)
					{
						PerkNode perkNode = perkTree.Node(require2);
						list.Add((perkNode != null) ? perkNode.Name : require2);
					}
					reason = node.Name + " needs at least one rank in " + string.Join(" or ", list) + ".";
					return Gate.MissingPrerequisite;
				}
			}
			PerkNode perkNode2 = ExclusiveBlocker(state, perkTree, node);
			if (perkNode2 != null)
			{
				reason = perkNode2.Name + " is taken. That fork locks the others - refund it to the root to choose differently.";
				return Gate.ExclusiveLocked;
			}
			if (Available(state) <= 0)
			{
				reason = $"No perk points. {ToNextPoint(state):0} more combined skill levels to the next.";
				return Gate.NoPointsAvailable;
			}
			return Gate.Ok;
		}

		internal static PerkNode ExclusiveBlocker(PerkState state, PerkTree tree, PerkNode node)
		{
			if (!node.IsExclusive || state.GetRank(node.Id) > 0)
			{
				return null;
			}
			foreach (PerkNode node2 in tree.Nodes)
			{
				if (node2 != node && string.Equals(node2.ExclusiveGroup, node.ExclusiveGroup, StringComparison.OrdinalIgnoreCase) && state.GetRank(node2.Id) > 0)
				{
					return node2;
				}
			}
			return null;
		}

		internal static float LevelFor(PerkState state, PerkTree tree)
		{
			if (tree.RidesAnotherSkill)
			{
				return state.GetHighWater(tree.RidesKey);
			}
			if (!tree.IsSector)
			{
				return state.GetHighWater(tree.Key);
			}
			if (tree.Members.Count == 0)
			{
				return 0f;
			}
			float num = 0f;
			foreach (string member in tree.Members)
			{
				num += state.GetHighWater(member);
			}
			return num / (float)tree.Members.Count;
		}

		internal static bool TryBuy(PerkState state, PerkNode node, out string message)
		{
			if (CanBuy(state, node, out message) != Gate.Ok)
			{
				return false;
			}
			int num = state.GetRank(node.Id) + 1;
			state.SetRank(node.Id, num);
			message = $"{node.Name} rank {num}: {node.RankText(num)}";
			if (!node.IsImplemented)
			{
				message = message + "   [not yet implemented: " + node.PendingNote + "]";
			}
			PerkEvents.RaiseAllocationChanged();
			Log.Debug($"Bought {node.Id} -> rank {num}");
			return true;
		}
	}
	internal static class Prestige
	{
		internal const float MaxLevel = 100f;

		internal static bool CanPrestige(PerkState state, PerkTree tree, out string reason)
		{
			reason = string.Empty;
			if (state == null || tree == null)
			{
				reason = "Unknown tree.";
				return false;
			}
			if (!ModConfig.PrestigeEnabled.Value)
			{
				reason = "Prestige is disabled on this server.";
				return false;
			}
			if (tree.IsSector)
			{
				reason = "Sectors cannot be prestiged directly - they inherit it from their members.";
				return false;
			}
			if (tree.RidesAnotherSkill)
			{
				PerkTree perkTree = PerkDatabase.Tree(tree.RidesKey);
				reason = tree.Name + " follows " + ((perkTree != null) ? perkTree.Name : tree.RidesKey) + "; prestige that instead.";
				return false;
			}
			int value = ModConfig.PrestigeCap.Value;
			if (state.GetPrestige(tree.Key) >= value)
			{
				reason = $"{tree.Name} is at the prestige cap ({value}).";
				return false;
			}
			float num = LiveLevel(tree);
			if (num < 100f)
			{
				reason = $"{tree.Name} must be at level {100f:0} to prestige; it is at {num:0}.";
				return false;
			}
			return true;
		}

		private static float LiveLevel(PerkTree tree)
		{
			//IL_0010: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (int)tree.SkillType == 0)
			{
				return 0f;
			}
			return ((Character)localPlayer).GetSkills().GetSkillLevel(tree.SkillType);
		}

		internal static bool TryPrestige(PerkState state, PerkTree tree, out string message)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!CanPrestige(state, tree, out message))
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				message = "No local player.";
				return false;
			}
			int num = Respec.ClearTree(state, tree);
			int num2 = state.GetPrestige(tree.Key) + 1;
			state.Prestige[tree.Key] = num2;
			((Character)localPlayer).GetSkills().ResetSkill(tree.SkillType);
			int num3 = ModConfig.PrestigeEffectiveLevels.Value * num2;
			message = $"{tree.Name} prestiged to {num2}. " + string.Format("{0} rank{1} refunded, ", num, (num == 1) ? "" : "s") + $"+{ModConfig.PrestigePoints.Value} points to the pool, " + $"and {tree.Name} now counts as {num3} levels higher, permanently.";
			PerkEvents.RaiseAllocationChanged();
			Log.Info(message);
			return true;
		}

		internal static float EffectiveLevelBonus(PerkState state, SkillType type)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (state == null || !ModConfig.PrestigeEnabled.Value)
			{
				return 0f;
			}
			int prestige = state.GetPrestige(SkillKeys.Key(type));
			if (prestige > 0)
			{
				return prestige * ModConfig.PrestigeEffectiveLevels.Value;
			}
			return 0f;
		}
	}
	internal static class Respec
	{
		internal static bool TryRefund(PerkState state, PerkNode node, out string message)
		{
			message = string.Empty;
			if (state == null || node == null)
			{
				message = "Unknown perk.";
				return false;
			}
			int rank = state.GetRank(node.Id);
			if (rank <= 0)
			{
				message = node.Name + " has no ranks to refund.";
				return false;
			}
			bool flag = ModConfig.FreeRespec != null && ModConfig.FreeRespec.Value;
			if (!flag && state.RespecPoints <= 0)
			{
				message = "No respec points. Craft an Unwoven Thread.";
				return false;
			}
			if (!flag)
			{
				state.RespecPoints--;
			}
			int num = 1;
			state.SetRank(node.Id, rank - 1);
			if (rank == 1)
			{
				num += CascadeFrom(state, node);
			}
			PerkEvents.RaiseAllocationChanged();
			message = ((num == 1) ? ("Refunded one rank of " + node.Name + ".") : ($"Refunded one rank of {node.Name}, plus {num - 1} downstream " + "rank" + ((num == 2) ? "" : "s") + " that depended on it."));
			return true;
		}

		private static int CascadeFrom(PerkState state, PerkNode node)
		{
			PerkTree perkTree = PerkDatabase.Tree(node.TreeKey);
			if (perkTree == null)
			{
				return 0;
			}
			int num = 0;
			bool flag;
			do
			{
				flag = false;
				foreach (PerkNode node2 in perkTree.Nodes)
				{
					int rank = state.GetRank(node2.Id);
					if (rank <= 0 || node2.Requires.Count == 0)
					{
						continue;
					}
					bool flag2 = false;
					foreach (string require in node2.Requires)
					{
						if (state.GetRank(require) > 0)
						{
							flag2 = true;
							break;
						}
					}
					if (!flag2)
					{
						num += rank;
						state.SetRank(node2.Id, 0);
						flag = true;
					}
				}
			}
			while (flag);
			return num;
		}

		internal static int ClearTree(PerkState state, PerkTree tree)
		{
			if (state == null || tree == null)
			{
				return 0;
			}
			int num = 0;
			foreach (PerkNode node in tree.Nodes)
			{
				num += state.GetRank(node.Id);
				state.SetRank(node.Id, 0);
			}
			PerkEvents.RaiseAllocationChanged();
			return num;
		}

		internal static void GrantPoints(PerkState state, int amount)
		{
			if (state != null && amount > 0)
			{
				state.RespecPoints += amount;
				Log.Debug($"Granted {amount} respec points (now {state.RespecPoints}).");
			}
		}
	}
}
namespace Norntastic.Content
{
	internal static class Arsenal
	{
		private static readonly List<string> Built = new List<string>();

		private static readonly Dictionary<string, string> Refused = new Dictionary<string, string>(StringComparer.Ordinal);

		internal static IEnumerable<string> BuiltKeys => Built;

		internal static IReadOnlyDictionary<string, string> RefusedKeys => Refused;

		internal static int BuiltCount => Built.Count;

		internal static void Arm()
		{
			ForgePatches.Register(Build);
			foreach (ArsenalDef item in ArsenalLibrary.All)
			{
				if (item.IsEdible)
				{
					FryGenerator.DeclareIngredient(item.Name);
				}
			}
		}

		private static void Build(Func<string, GameObject> find)
		{
			if (ModConfig.ArsenalEnabled == null || !ModConfig.ArsenalEnabled.Value)
			{
				return;
			}
			foreach (ArsenalDef item in ArsenalLibrary.All)
			{
				try
				{
					BuildOne(item, find);
				}
				catch (Exception ex)
				{
					Refuse(item, "threw while building: " + ex.Message);
					Log.Error("Arsenal item '" + item.Key + "' failed: " + ex);
				}
			}
		}

		private static void BuildOne(ArsenalDef def, Func<string, GameObject> find)
		{
			if (Built.Contains(def.Key))
			{
				return;
			}
			GameObject val = find(def.Source);
			if ((Object)(object)val == (Object)null)
			{
				Refuse(def, def.Source);
				return;
			}
			GameObject val2 = PrefabForge.MakeItem(val, def.Name, derived: false);
			if (!((Object)(object)val2 == (Object)null))
			{
				Dress(val2, def);
				Recipe(val2, def, find);
				Built.Add(def.Key);
				Refused.Remove(def.Key);
			}
		}

		private static void Refuse(ArsenalDef def, string missing)
		{
			if (!Refused.ContainsKey(def.Key))
			{
				Refused[def.Key] = missing;
				Log.Warn("Arsenal item '" + def.Display + "' skipped: no prefab named '" + missing + "'. Everything else still builds.");
			}
		}

		private static void Dress(GameObject go, ArsenalDef def)
		{
			//IL_007e: 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_0087: 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)
			ItemDrop component = go.GetComponent<ItemDrop>();
			SharedData val = (((Object)(object)component == (Object)null || component.m_itemData == null) ? null : component.m_itemData.m_shared);
			if (val == null)
			{
				Log.Warn("'" + def.Name + "' has no ItemDrop - '" + def.Source + "' is not the prefab this expected.");
				return;
			}
			val.m_name = def.Display;
			val.m_description = def.Blurb;
			if ((int)def.Skill != 0)
			{
				val.m_skillType = def.Skill;
			}
			_ = val.m_damages;
			if (def.Blunt > 0f)
			{
				val.m_damages.m_blunt = def.Blunt;
			}
			if (def.Slash > 0f)
			{
				val.m_damages.m_slash = def.Slash;
			}
			if (def.Pierce > 0f)
			{
				val.m_damages.m_pierce = def.Pierce;
			}
			if (def.Armour > 0f)
			{
				val.m_armor = def.Armour;
			}
			if (def.MovementModifier != 0f)
			{
				val.m_movementModifier = def.MovementModifier;
			}
			if (def.IsEdible)
			{
				val.m_food = def.Health;
				val.m_foodStamina = def.Stamina;
				val.m_foodBurnTime = def.Duration;
				val.m_foodRegen = 1f;
			}
		}

		private static void Recipe(GameObject made, ArsenalDef def, Func<string, GameObject> find)
		{
			ItemDrop component = made.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			List<Requirement> list = new List<Requirement>();
			for (int i = 0; i < def.CostItems.Length; i++)
			{
				int amount = ((i >= def.CostAmounts.Length) ? 1 : def.CostAmounts[i]);
				Requirement[] array = PrefabForge.Cost((string n) => PrefabForge.Find(n) ?? find(n), def.CostItems[i], amount);
				if (array.Length == 0)
				{
					Log.Warn("No recipe for '" + def.Display + "': this install has no '" + def.CostItems[i] + "'.");
					return;
				}
				list.Add(array[0]);
			}
			Recipe val = ScriptableObject.CreateInstance<Recipe>();
			((Object)val).name = "Recipe_" + def.Name;
			val.m_item = component;
			val.m_amount = 1;
			val.m_enabled = true;
			val.m_minStationLevel = 1;
			val.m_resources = list.ToArray();
			if (!string.IsNullOrEmpty(def.Station))
			{
				GameObject val2 = find(def.Station);
				CraftingStation val3 = (((Object)(object)val2 == (Object)null) ? null : val2.GetComponent<CraftingStation>());
				if ((Object)(object)val3 == (Object)null)
				{
					Log.Warn("'" + def.Display + "' wanted station '" + def.Station + "', which is not here - it will be craftable bare-handed.");
				}
				else
				{
					val.m_craftingStation = val3;
				}
			}
			PrefabForge.AddRecipe(val);
		}

		internal static void ResetForTests()
		{
			Built.Clear();
			Refused.Clear();
		}
	}
	internal sealed class ArsenalDef
	{
		internal string Key;

		internal string Display;

		internal string Blurb;

		internal string Source;

		internal string[] CostItems;

		internal int[] CostAmounts;

		internal string Station;

		internal float Blunt;

		internal float Slash;

		internal float Pierce;

		internal SkillType Skill;

		internal float Armour;

		internal float MovementModifier;

		internal int Health;

		internal int Stamina;

		internal float Duration;

		internal bool IsEdible
		{
			get
			{
				if (Health <= 0)
				{
					return Stamina > 0;
				}
				return true;
			}
		}

		internal string Name => "nsg_" + Key;
	}
	internal static class ArsenalLibrary
	{
		internal static readonly List<ArsenalDef> All = new List<ArsenalDef>
		{
			new ArsenalDef
			{
				Key = "salami",
				Display = "Salami",
				Blurb = "Cured hard enough to be structural. Dual wield them.",
				Source = "Club",
				Station = "piece_workbench",
				CostItems = new string[2] { "RawMeat", "Thistle" },
				CostAmounts = new int[2] { 4, 2 },
				Blunt = 18f,
				Health = 20,
				Stamina = 14,
				Duration = 1200f
			},
			new ArsenalDef
			{
				Key = "baguette",
				Display = "Baguette",
				Blurb = "Day-old. Astonishingly rigid. Holds an edge, briefly.",
				Source = "SwordBronze",
				Station = "piece_workbench",
				CostItems = new string[2] { "Barley", "Honey" },
				CostAmounts = new int[2] { 6, 2 },
				Slash = 22f,
				Health = 14,
				Stamina = 26,
				Duration = 1000f
			},
			new ArsenalDef
			{
				Key = "carving_fork",
				Display = "Carving Fork",
				Blurb = "Two prongs, for the parts of dinner that argue back.",
				Source = "KnifeCopper",
				Station = "piece_workbench",
				CostItems = new string[2] { "Bronze", "Wood" },
				CostAmounts = new int[2] { 2, 4 },
				Pierce = 20f
			},
			new ArsenalDef
			{
				Key = "chainmail_apron",
				Display = "Chainmail Apron",
				Blurb = "Mail where the splashes land. Open at the back, like all aprons.",
				Source = "ArmorBronzeChest",
				Station = "piece_forge",
				CostItems = new string[2] { "Bronze", "LeatherScraps" },
				CostAmounts = new int[2] { 5, 4 },
				Armour = 8f
			},
			new ArsenalDef
			{
				Key = "chainmail_spaghetti",
				Display = "Chainmail Spaghetti",
				Blurb = "Nobody has explained how these are made. Nobody wants to know.",
				Source = "ArmorBronzeLegs",
				Station = "piece_forge",
				CostItems = new string[2] { "Bronze", "LeatherScraps" },
				CostAmounts = new int[2] { 5, 4 },
				Armour = 8f
			},
			new ArsenalDef
			{
				Key = "clown_boots",
				Display = "Clown Boots",
				Blurb = "Every step lifts the people near you, and tells everything else exactly where you are.",
				Source = "ArmorLeatherLegs",
				Station = "piece_workbench",
				CostItems = new string[2] { "LeatherScraps", "Resin" },
				CostAmounts = new int[2] { 8, 4 },
				Armour = 3f,
				MovementModifier = -0.08f
			}
		};

		internal static ArsenalDef Find(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return null;
			}
			foreach (ArsenalDef item in All)
			{
				if (string.Equals(item.Key, key, StringComparison.OrdinalIgnoreCase))
				{
					return item;
				}
			}
			return null;
		}
	}
	internal class AutoStation : MonoBehaviour
	{
		internal const string LastCycleKey = "nsg.station.cycled";

		internal const string OwedKey = "nsg.station.owed";

		internal const string BonusKey = "nsg.station.bonus";

		internal const string RecipesKey = "nsg.station.recipes";

		internal const int MaxCatchUp = 12;

		private const float PollSeconds = 10f;

		internal StationTier Tier;

		internal float SecondsPerCycle = 600f;

		internal int InputRows = 2;

		internal string SkillId;

		internal readonly List<ConversionDef> Chains = new List<ConversionDef>();

		private ZNetView _nview;

		private Container _container;

		private float _poll;

		internal static int CyclesThisSession { get; private set; }

		internal static void ResetForTests()
		{
			CyclesThisSession = 0;
		}

		private void Awake()
		{
			_nview = ((Component)this).GetComponent<ZNetView>();
			_container = ((Component)this).GetComponent<Container>();
		}

		private void Update()
		{
			_poll += Time.deltaTime;
			if (_poll < 10f)
			{
				return;
			}
			_poll = 0f;
			try
			{
				Run();
			}
			catch (Exception ex)
			{
				Log.Error("Automation station failed: " + ex);
			}
		}

		private void Run()
		{
			if ((Object)(object)_nview == (Object)null || (Object)(object)_container == (Object)null || !_nview.IsValid() || !_nview.IsOwner())
			{
				return;
			}
			ZDO zDO = _nview.GetZDO();
			if (zDO == null)
			{
				return;
			}
			long num = (((Object)(object)ZNet.instance == (Object)null) ? 0 : ZNet.instance.GetTime().Ticks);
			if (num == 0L)
			{
				return;
			}
			long num2 = zDO.GetLong("nsg.station.cycled", 0L);
			if (num2 == 0L)
			{
				zDO.Set("nsg.station.cycled", num);
				return;
			}
			double totalSeconds = new TimeSpan(num - num2).TotalSeconds;
			if (totalSeconds < (double)SecondsPerCycle)
			{
				return;
			}
			int num3 = (int)(totalSeconds / (double)SecondsPerCycle);
			if (num3 > 12)
			{
				num3 = 12;
			}
			Remember(zDO);
			int num4 = 0;
			for (int i = 0; i < num3; i++)
			{
				if (!Cycle(zDO))
				{
					break;
				}
				num4++;
			}
			zDO.Set("nsg.station.cycled", num);
			if (num4 > 0)
			{
				CyclesThisSession += num4;
				Bank(zDO, num4);
			}
		}

		private bool Cycle(ZDO zdo)
		{
			Inventory inventory = _container.GetInventory();
			if (inventory == null)
			{
				return false;
			}
			int num = 1 + (int)zdo.GetFloat("nsg.station.recipes", 0f);
			if (num < 1)
			{
				num = 1;
			}
			int num2 = 0;
			foreach (ConversionDef chain in Chains)
			{
				if (num2 >= num)
				{
					break;
				}
				ItemData val = FindInInputRows(inventory, chain.From);
				if (val == null)
				{
					continue;
				}
				GameObject val2 = (((Object)(object)ObjectDB.instance == (Object)null) ? null : ObjectDB.instance.GetItemPrefab(chain.To));
				if (!((Object)(object)val2 == (Object)null))
				{
					int num3 = OutputFor(zdo);
					if (inventory.AddItem(val2, num3))
					{
						inventory.RemoveOneItem(val);
						num2++;
					}
				}
			}
			return num2 > 0;
		}

		private int OutputFor(ZDO zdo)
		{
			int num = StationTiers.OutputStack(Tier);
			float num2 = zdo.GetFloat("nsg.station.bonus", 0f);
			if (num2 <= 0f)
			{
				return num;
			}
			int num3 = (int)((float)num * (1f + num2 / 100f));
			if (num3 >= num)
			{
				return num3;
			}
			return num;
		}

		private static void Remember(ZDO zdo)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				long num = zdo.GetLong(ZDOVars.s_creator, 0L);
				if (num != 0L && localPlayer.GetPlayerID() == num)
				{
					zdo.Set("nsg.station.bonus", EffectAggregator.Pct(EffectKind.StationOutputPct));
					zdo.Set("nsg.station.recipes", EffectAggregator.Pct(EffectKind.StationRecipesFlat));
				}
			}
		}

		private ItemData FindInInputRows(Inventory inventory, string prefabName)
		{
			List<ItemData> allItems = inventory.GetAllItems();
			if (allItems == null)
			{
				return null;
			}
			for (int i = 0; i < allItems.Count; i++)
			{
				ItemData val = allItems[i];
				if (val != null && val.m_shared != null && IsInputSlot(val.m_gridPos.y, InputRows) && NameMatches(val, prefabName))
				{
					return val;
				}
			}
			return null;
		}

		internal static bool IsInputSlot(int row, int inputRows)
		{
			if (row >= 0)
			{
				return row < inputRows;
			}
			return false;
		}

		private static bool NameMatches(ItemData item, string prefabName)
		{
			if ((Object)(object)item.m_dropPrefab != (Object)null)
			{
				return ((Object)item.m_dropPrefab).name == prefabName;
			}
			ObjectDB instance = ObjectDB.instance;
			GameObject val = (((Object)(object)instance == (Object)null) ? null : instance.GetItemPrefab(prefabName));
			ItemDrop val2 = (((Object)(object)val == (Object)null) ? null : val.GetComponent<ItemDrop>());
			if ((Object)(object)val2 != (Object)null && val2.m_itemData != null && val2.m_itemData.m_shared != null && item.m_shared != null)
			{
				return val2.m_itemData.m_shared.m_name == item.m_shared.m_name;
			}
			return false;
		}

		private void Bank(ZDO zdo, int cycles)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			float num = zdo.GetFloat("nsg.station.owed", 0f) + (float)cycles;
			Player localPlayer = Player.m_localPlayer;
			long num2 = zdo.GetLong(ZDOVars.s_creator, 0L);
			if ((Object)(object)localPlayer == (Object)null || num2 == 0L || localPlayer.GetPlayerID() != num2)
			{
				zdo.Set("nsg.station.owed", num);
				return;
			}
			if (!string.IsNullOrEmpty(SkillId))
			{
				((Character)localPlayer).RaiseSkill(CustomSkills.TypeOf(SkillId), num);
			}
			zdo.Set("nsg.station.owed", 0f);
		}
	}
	internal sealed class AutoStationDef
	{
		internal string Key;

		internal string Display;

		internal string Blurb;

		internal string Source;

		internal string Adopts;

		internal ConversionDef[] OwnChains;

		internal Func<IEnumerable<ConversionDef>> DerivedChains;

		internal string[] CostItems;

		internal int[] CostAmounts;

		internal string SkillId;

		internal float SecondsPerCycle = 600f;

		internal int Width = 6;

		internal int Height = 4;

		internal string NameFor(StationTier tier)
		{
			return "nsg_station_" + Key + "_" + tier.ToString().ToLowerInvariant();
		}

		internal string DisplayFor(StationTier tier)
		{
			return Display + " (" + tier.ToString() + ")";
		}
	}
	internal static class AutoStationLibrary
	{
		internal static readonly List<AutoStationDef> All = new List<AutoStationDef>
		{
			new AutoStationDef
			{
				Key = "cookingchute",
				Display = "Cooking Chute",
				Blurb = "Drops raw food in the top. Takes cooked food out the bottom.",
				Source = "piece_cookingstation",
				Adopts = "piece_cookingstation",
				CostItems = new string[2] { "Wood", "Stone" },
				CostAmounts = new int[2] { 20, 10 },
				SkillId = "dafini.norntastic.automationist",
				SecondsPerCycle = 420f
			},
			new AutoStationDef
			{
				Key = "cauldronsloop",
				Display = "Cauldron Sloop",
				Blurb = "A cauldron that does not need you standing over it.",
				Source = "piece_cauldron",
				Adopts = "piece_cauldron",
				CostItems = new string[2] { "Iron", "Wood" },
				CostAmounts = new int[2] { 8, 20 },
				SkillId = "dafini.norntastic.automationist",
				SecondsPerCycle = 600f,
				Width = 8,
				Height = 4
			},
			new AutoStationDef
			{
				Key = "meadmasher",
				Display = "Mead Masher",
				Blurb = "Barrels, on a rack, unattended. Everything ferments eventually.",
				Source = "fermenter",
				Adopts = "fermenter",
				CostItems = new string[2] { "Bronze", "FineWood" },
				CostAmounts = new int[2] { 6, 20 },
				SkillId = "dafini.norntastic.brewing",
				SecondsPerCycle = 900f
			},
			new AutoStationDef
			{
				Key = "hydroponics",
				Display = "Hydroponics",
				Blurb = "Grows indoors, out of season, and does not care what biome it is in.",
				Source = "piece_chest_wood",
				Adopts = null,
				DerivedChains = HydroponicChains,
				CostItems = new string[3] { "Iron", "Stone", "Wood" },
				CostAmounts = new int[3] { 10, 20, 20 },
				SkillId = "dafini.norntastic.automationist",
				SecondsPerCycle = 1200f,
				Width = 6,
				Height = 6
			},
			new AutoStationDef
			{
				Key = "deepfryer",
				Display = "Deep Fryer Basin",
				Blurb = "Anything that is food goes in. The next kind of it comes out.",
				Source = "piece_cauldron",
				Adopts = null,
				DerivedChains = Fryer.Chains,
				CostItems = new string[2] { "Bronze", "Stone" },
				CostAmounts = new int[2] { 4, 10 },
				SkillId = "dafini.norntastic.deepfry",
				SecondsPerCycle = 300f,
				Width = 6,
				Height = 4
			},
			new AutoStationDef
			{
				Key = "fishfarm",
				Display = "Fish Farm",
				Blurb = "A netted pen. Bait goes in, fish come out, nobody has to stand there.",
				Source = "piece_chest_wood",
				Adopts = null,
				OwnChains = new ConversionDef[1]
				{
					new ConversionDef
					{
						From = "FishingBait",
						To = "FishRaw",
						Note = "bait becomes fish, slowly"
					}
				},
				CostItems = new string[2] { "FineWood", "LeatherScraps" },
				CostAmounts = new int[2] { 20, 10 },
				SkillId = "dafini.norntastic.automationist",
				SecondsPerCycle = 900f
			},
			new AutoStationDef
			{
				Key = "animalhovel",
				Display = "Animal Hovel",
				Blurb = "Feed goes in. What animals produce comes out. No pen to repair.",
				Source = "piece_chest_wood",
				Adopts = null,
				OwnChains = new ConversionDef[2]
				{
					new ConversionDef
					{
						From = "Carrot",
						To = "RawMeat",
						Note = "fed vegetables, returns meat"
					},
					new ConversionDef
					{
						From = "Turnip",
						To = "LeatherScraps",
						Note = "fed vegetables, returns hide"
					}
				},
				CostItems = new string[2] { "Wood", "LeatherScraps" },
				CostAmounts = new int[2] { 30, 15 },
				SkillId = "dafini.norntastic.husbandry",
				SecondsPerCycle = 900f
			}
		};

		internal static IEnumerable<ConversionDef> HydroponicChains()
		{
			List<ConversionDef> list = new List<ConversionDef>();
			foreach (CropDef item in CropLibrary.All)
			{
				list.Add(new ConversionDef
				{
					From = item.PlantingCostName,
					To = item.ItemName,
					Note = item.Display + " grown indoors"
				});
			}
			return list;
		}

		internal static AutoStationDef Find(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return null;
			}
			foreach (AutoStationDef item in All)
			{
				if (string.Equals(item.Key, key, StringComparison.OrdinalIgnoreCase))
				{
					return item;
				}
			}
			return null;
		}
	}
	internal static class ClownBoots
	{
		private const float Radius = 22f;

		private const float Interval = 1.5f;

		private const float StepDistance = 1.2f;

		internal const float ComfortMagnitude = 2f;

		private static float _next;

		private static Vector3 _lastPosition;

		private static bool _hadPosition;

		internal static bool Available { get; private set; } = true;

		internal static int Drawn { get; private set; }

		private static void Disable(string reason)
		{
			if (Available)
			{
				Available = false;
				Log.Warn("The clown boots' squeak turned itself off: " + reason + ". They are still armour, and still lift the people near you.");
			}
		}

		internal static void Reset()
		{
			Drawn = 0;
			_next = 0f;
			_hadPosition = false;
		}

		internal static bool Worn(Player player)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Invalid comparison between Unknown and I4
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			ArsenalDef arsenalDef = ArsenalLibrary.Find("clown_boots");
			if (arsenalDef == null)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			List<ItemData> list = ((inventory == null) ? null : inventory.GetAllItems());
			if (list == null)
			{
				return false;
			}
			for (int i = 0; i < list.Count; i++)
			{
				ItemData val = list[i];
				if (val != null && val.m_equipped)
				{
					SharedData shared = val.m_shared;
					if (shared != null && (int)shared.m_itemType == 11 && shared.m_name == arsenalDef.Display)
					{
						return true;
					}
				}
			}
			return false;
		}

		internal static float ComfortFrom(Player player)
		{
			if (!Worn(player))
			{
				return 0f;
			}
			return 2f;
		}

		internal static void Tick(Player player)
		{
			//IL_0024: 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_0031: 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_005b: 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_0067: 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)
			if (!Available || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			Vector3 position = ((Component)player).transform.position;
			if (!_hadPosition)
			{
				_lastPosition = position;
				_hadPosition = true;
			}
			else if (!(Time.time < _next))
			{
				_next = Time.time + 1.5f;
				float num = Vector3.Distance(position, _lastPosition);
				_lastPosition = position;
				if (!(num < 1.2f) && Worn(player))
				{
					Squeak(player);
				}
			}
		}

		private static void Squeak(Player player)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			List<Character> allCharacters = Character.GetAllCharacters();
			if (allCharacters == null)
			{
				return;
			}
			foreach (Character item in allCharacters)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item == (Object)(object)player || item.IsPlayer() || Vector3.Distance(((Component)player).transform.position, ((Component)item).transform.position) > 22f)
				{
					continue;
				}
				MonsterAI component = ((Component)item).GetComponent<MonsterAI>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)((BaseAI)component).GetTargetCreature() != (Object)null))
				{
					if (!Draw(component, player))
					{
						break;
					}
					Drawn++;
				}
			}
		}

		private static bool Draw(MonsterAI ai, Player player)
		{
			try
			{
				Traverse val = Traverse.Create((object)ai);
				Traverse val2 = val.Method("SetTarget", new Type[1] { typeof(Character) }, (object[])null);
				if (!val2.MethodExists())
				{
					Disable("MonsterAI.SetTarget is not where it used to be");
					return false;
				}
				val2.GetValue(new object[1] { player });
				Traverse val3 = val.Method("SetAlerted", new Type[1] { typeof(bool) }, (object[])null);
				if (val3.MethodExists())
				{
					val3.GetValue(new object[1] { true });
				}
				return true;
			}
			catch (Exception ex)
			{
				Disable("drawing a creature threw: " + ex.Message);
				Log.Error("Clown boot squeak failed: " + ex);
				return false;
			}
		}
	}
	internal sealed class ConversionDef
	{
		internal string Station;

		internal string From;

		internal string To;

		internal int Produced = 1;

		internal float CookTime;

		internal string Note;
	}
	internal static class Conversions
	{
		private static readonly Dictionary<string, string> Refused = new Dictionary<string, string>(StringComparer.Ordinal);

		internal static int Added { get; private set; }

		internal static IReadOnlyDictionary<string, string> RefusedChains => Refused;

		internal static void ResetForTests()
		{
			Added = 0;
			Refused.Clear();
		}

		internal static string KeyOf(ConversionDef def)
		{
			if (def != null)
			{
				return def.From + "->" + def.To + "@" + def.Station;
			}
			return string.Empty;
		}

		internal static void Apply(IEnumerable<ConversionDef> chains, Func<string, GameObject> find)
		{
			if (chains == null || find == null)
			{
				return;
			}
			foreach (ConversionDef chain in chains)
			{
				try
				{
					ApplyOne(chain, find);
				}
				catch (Exception ex)
				{
					Refuse(chain, "threw: " + ex.Message);
					Log.Error("Conversion " + KeyOf(chain) + " failed: " + ex);
				}
			}
		}

		private static void ApplyOne(ConversionDef def, Func<string, GameObject> find)
		{
			if (def == null)
			{
				return;
			}
			GameObject val = find(def.Station);
			if ((Object)(object)val == (Object)null)
			{
				Refuse(def, "no station '" + def.Station + "'");
				return;
			}
			ItemDrop val2 = Resolve(def.From, find);
			if ((Object)(object)val2 == (Object)null)
			{
				Refuse(def, "no item '" + def.From + "'");
				return;
			}
			ItemDrop val3 = Resolve(def.To, find);
			if ((Object)(object)val3 == (Object)null)
			{
				Refuse(def, "no item '" + def.To + "'");
			}
			else if (AddTo(val, val2, val3, def))
			{
				Added++;
				Refused.Remove(KeyOf(def));
			}
		}

		private static ItemDrop Resolve(string name, Func<string, GameObject> find)
		{
			GameObject val = PrefabForge.Find(name) ?? find(name);
			if (!((Object)(object)val == (Object)null))
			{
				return val.GetComponent<ItemDrop>();
			}
			return null;
		}

		private static void Refuse(ConversionDef def, string why)
		{
			string text = KeyOf(def);
			if (!Refused.ContainsKey(text))
			{
				Refused[text] = why;
				Log.Warn("Chain " + text + " skipped: " + why + ". Everything else still works.");
			}
		}

		private static bool AddTo(GameObject station, ItemDrop from, ItemDrop to, ConversionDef def)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: 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_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Expected O, but got Unknown
			Smelter component = station.GetComponent<Smelter>();
			if ((Object)(object)component != (Object)null)
			{
				if (component.m_conversion == null)
				{
					component.m_conversion = new List<ItemConversion>();
				}
				foreach (ItemConversion item in component.m_conversion)
				{
					if (item != null && (Object)(object)item.m_from == (Object)(object)from && (Object)(object)item.m_to == (Object)(object)to)
					{
						return false;
					}
				}
				component.m_conversion.Add(new ItemConversion
				{
					m_from = from,
					m_to = to
				});
				return true;
			}
			CookingStation component2 = station.GetComponent<CookingStation>();
			if ((Object)(object)component2 != (Object)null)
			{
				if (component2.m_conversion == null)
				{
					component2.m_conversion = new List<ItemConversion>();
				}
				foreach (ItemConversion item2 in component2.m_conversion)
				{
					if (item2 != null && (Object)(object)item2.m_from == (Object)(object)from && (Object)(object)item2.m_to == (Object)(object)to)
					{
						return false;
					}
				}
				ItemConversion val = new ItemConversion
				{
					m_from = from,
					m_to = to
				};
				if (def.CookTime > 0f)
				{
					val.m_cookTime = def.CookTime;
				}
				component2.m_conversion.Add(val);
				return true;
			}
			Fermenter component3 = station.GetComponent<Fermenter>();
			if ((Object)(object)component3 != (Object)null)
			{
				if (component3.m_conversion == null)
				{
					component3.m_conversion = new List<ItemConversion>();
				}
				foreach (ItemConversion item3 in component3.m_conversion)
				{
					if (item3 != null && (Object)(object)item3.m_from == (Object)(object)from && (Object)(object)item3.m_to == (Object)(object)to)
					{
						return false;
					}
				}
				component3.m_conversion.Add(new ItemConversion
				{
					m_from = from,
					m_to = to,
					m_producedItems = ((def.Produced <= 0) ? 1 : def.Produced)
				});
				return true;
			}
			Refuse(def, "'" + def.Station + "' converts nothing - it has no Smelter, CookingStation or Fermenter on it");
			return false;
		}
	}
	internal sealed class CropDef
	{
		internal string Key;

		internal string Display;

		internal string Blurb;

		internal string SaplingSource;

		internal string PickableSource;

		internal string ItemSource;

		internal string SeedSource;

		internal Biome WildBiome;

		internal int WildMin;

		internal int WildMax;

		internal Color Tint;

		internal float Scale = 1f;

		internal int Health;

		internal int Stamina;

		internal int Eitr;

		internal float Duration = 1500f;

		internal float Regen = 1f;

		internal float GrowMinutes = 3000f;

		internal bool SelfSeeding => string.IsNullOrEmpty(SeedSource);

		internal string ItemName => "nsg_" + Key;

		internal string SeedName => "nsg_" + Key + "_seed";

		internal string SaplingName => "nsg_sapling_" + Key;

		internal string PickableName => "nsg_pickable_" + Key;

		internal string WildName => "nsg_wild_" + Key;

		internal string SeedDisplay
		{
			get
			{
				if (!SelfSeeding)
				{
					return Display + " Seeds";
				}
				return Display;
			}
		}

		internal string PlantingCostName
		{
			get
			{
				if (!SelfSeeding)
				{
					return SeedName;
				}
				return ItemName;
			}
		}
	}
	internal static class CropLibrary
	{
		internal static readonly List<CropDef> All = new List<CropDef>
		{
			new CropDef
			{
				Key = "wheat",
				Display = "Wheat",
				Blurb = "Threshes into flour. The reason a bakery is worth building.",
				SaplingSource = "sapling_barley",
				PickableSource = "Pickable_Barley",
				ItemSource = "Barley",
				SeedSource = null,
				WildBiome = (Biome)16,
				WildMin = 2,
				WildMax = 5,
				Tint = Rgb(222, 184, 96),
				Scale = 1.05f,
				Health = 8,
				Stamina = 18,
				Duration = 1500f,
				Regen = 1f,
				GrowMinutes = 3000f
			},
			new CropDef
			{
				Key = "sugarcane",
				Display = "Sugar Cane",
				Blurb = "Tall, sweet and faintly ridiculous. Cut low, crush hard.",
				SaplingSource = "sapling_barley",
				PickableSource = "Pickable_Barley",
				ItemSource = "Barley",
				SeedSource = null,
				WildBiome = (Biome)16,
				WildMin = 1,
				WildMax = 4,
				Tint = Rgb(150, 196, 110),
				Scale = 1.35f,
				Health = 6,
				Stamina = 26,
				Duration = 1200f,
				Regen = 1f,
				GrowMinutes = 3300f
			},
			new CropDef
			{
				Key = "boarvine",
				Display = "Boar Vine",
				Blurb = "Boars dig for the roots and leave the vine. So can you.",
				SaplingSource = "sapling_flax",
				PickableSource = "Pickable_Flax",
				ItemSource = "Flax",
				SeedSource = null,
				WildBiome = (Biome)8,
				WildMin = 2,
				WildMax = 6,
				Tint = Rgb(96, 120, 68),
				Scale = 1.1f,
				Health = 14,
				Stamina = 8,
				Duration = 1600f,
				Regen = 2f,
				GrowMinutes = 2700f
			},
			new CropDef
			{
				Key = "beet",
				Display = "Beet",
				Blurb = "Stains everything it touches. Worth it.",
				SaplingSource = "sapling_carrot",
				PickableSource = "Pickable_Carrot",
				ItemSource = "Carrot",
				SeedSource = "CarrotSeeds",
				WildBiome = (Biome)1,
				WildMin = 2,
				WildMax = 5,
				Tint = Rgb(122, 30, 58),
				Scale = 0.95f,
				Health = 16,
				Stamina = 10,
				Duration = 1500f,
				Regen = 2f,
				GrowMinutes = 2400f
			},
			new CropDef
			{
				Key = "cucumber",
				Display = "Cucumber",
				Blurb = "Mostly water, and after a long climb that is the point.",
				SaplingSource = "sapling_carrot",
				PickableSource = "Pickable_Carrot",
				ItemSource = "Carrot",
				SeedSource = "CarrotSeeds",
				WildBiome = (Biome)1,
				WildMin = 1,
				WildMax = 4,
				Tint = Rgb(74, 138, 66),
				Scale = 1.15f,
				Health = 10,
				Stamina = 20,
				Duration = 1400f,
				Regen = 3f,
				GrowMinutes = 2100f
			},
			new CropDef
			{
				Key = "cabbage",
				Display = "Cabbage",
				Blurb = "Keeps through a winter. Tastes like it, too.",
				SaplingSource = "sapling_turnip",
				PickableSource = "Pickable_Turnip",
				ItemSource = "Turnip",
				SeedSource = "TurnipSeeds",
				WildBiome = (Biome)1,
				WildMin = 2,
				WildMax = 4,
				Tint = Rgb(176, 202, 150),
				Scale = 1.2f,
				Health = 20,
				Stamina = 8,
				Duration = 1800f,
				Regen = 2f,
				GrowMinutes = 2700f
			},
			new CropDef
			{
				Key = "pearl",
				Display = "Pearl",
				Blurb = "A fat white root. Biting one is like biting into pure oil.",
				SaplingSource = "sapling_turnip",
				PickableSource = "Pickable_Turnip",
				ItemSource = "Turnip",
				SeedSource = "TurnipSeeds",
				WildBiome = (Biome)8,
				WildMin = 1,
				WildMax = 3,
				Tint = Rgb(238, 232, 214),
				Scale = 0.9f,
				Health = 6,
				Stamina = 42,
				Duration = 2400f,
				Regen = 1f,
				GrowMinutes = 3600f
			},
			new CropDef
			{
				Key = "eggplant",
				Display = "Eggplant",
				Blurb = "Bitter raw, extraordinary fried. The fryer knows what to do.",
				SaplingSource = "sapling_onion",
				PickableSource = "Pickable_Onion",
				ItemSource = "Onion",
				SeedSource = "OnionSeeds",
				WildBiome = (Biome)8,
				WildMin = 1,
				WildMax = 4,
				Tint = Rgb(72, 42, 96),
				Scale = 1.1f,
				Health = 12,
				Stamina = 16,
				Eitr = 6,
				Duration = 1500f,
				Regen = 2f,
				GrowMinutes = 2400f
			}
		};

		private static Color Rgb(int r, int g, int b)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			return new Color((float)r / 255f, (float)g / 255f, (float)b / 255f, 1f);
		}

		internal static CropDef Find(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return null;
			}
			foreach (CropDef item in All)
			{
				if (string.Equals(item.Key, key, StringComparison.OrdinalIgnoreCase))
				{
					return item;
				}
			}
			return null;
		}
	}
	internal static class Crops
	{
		private static readonly List<string> Built = new List<string>();

		private static readonly Dictionary<string, string> Refused = new Dictionary<string, string>(StringComparer.Ordinal);

		internal static IEnumerable<string> BuiltKeys => Built;

		internal static IReadOnlyDictionary<string, string> RefusedKeys => Refused;

		internal static int BuiltCount => Built.Count;

		internal static IEnumerable<string> DonorAssets
		{
			get
			{
				List<string> list = new List<string>();
				foreach (CropDef item in CropLibrary.All)
				{
					Add(list, item.SaplingSource);
					Add(list, item.PickableSource);
					Add(list, item.ItemSource);
					Add(list, item.SeedSource);
				}
				return list;
			}
		}

		private static void Add(List<string> into, string name)
		{
			if (!string.IsNullOrEmpty(name) && !into.Contains(name))
			{
				into.Add(name);
			}
		}

		internal static void Arm()
		{
			ForgePatches.Register(Build);
			foreach (CropDef item in CropLibrary.All)
			{
				FryGenerator.DeclareIngredient(item.ItemName);
			}
		}

		private static void Build(Func<string, GameObject> find)
		{
			if (ModConfig.CropsEnabled == null || !ModConfig.CropsEnabled.Value)
			{
				return;
			}
			foreach (CropDef item in CropLibrary.All)
			{
				try
				{
					BuildOne(item, find);
				}
				catch (Exception ex)
				{
					Refuse(item, "threw while building: " + ex.Message);
					Log.Error("Crop '" + item.Key + "' failed: " + ex);
				}
			}
		}

		private static void BuildOne(CropDef crop, Func<string, GameObject> find)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			if (Built.Contains(crop.Key))
			{
				return;
			}
			GameObject val = find(crop.ItemSource);
			if ((Object)(object)val == (Object)null)
			{
				Refuse(crop, crop.ItemSource);
				return;
			}
			GameObject val2 = PrefabForge.MakeItem(val, crop.ItemName, derived: false);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			DressFood(val2, crop);
			GameObject val3 = null;
			if (!crop.SelfSeeding)
			{
				GameObject val4 = find(crop.SeedSource);
				if ((Object)(object)val4 == (Object)null)
				{
					Refuse(crop, crop.SeedSource);
					return;
				}
				val3 = PrefabForge.MakeItem(val4, crop.SeedName, derived: false);
				if ((Object)(object)val3 == (Object)null)
				{
					return;
				}
				Name(val3, crop.SeedDisplay, "Plant these. " + crop.Blurb);
				Tinting.Dress(val3, crop.Tint, 1f, crop.SeedName);
			}
			GameObject val5 = find(crop.PickableSource);
			if ((Object)(object)val5 == (Object)null)
			{
				Refuse(crop, crop.PickableSource);
				return;
			}
			GameObject val6 = PrefabForge.Make(val5, crop.PickableName, derived: false);
			if ((Object)(object)val6 == (Object)null)
			{
				return;
			}
			DressPickable(val6, crop, val2, wild: false);
			GameObject val7 = find(crop.SaplingSource);
			if ((Object)(object)val7 == (Object)null)
			{
				Refuse(crop, crop.SaplingSource);
				return;
			}
			GameObject val8 = PrefabForge.MakePiece(val7, crop.SaplingName, derived: false, "Cultivator");
			if (!((Object)(object)val8 == (Object)null))
			{
				DressSapling(val8, crop, val6, find);
				GameObject val9 = PrefabForge.Make(val5, crop.WildName, derived: false);
				if ((Object)(object)val9 != (Object)null)
				{
					DressPickable(val9, crop, crop.SelfSeeding ? val2 : val3, wild: true);
				}
				Built.Add(crop.Key);
				Refused.Remove(crop.Key);
			}
		}

		private static void Refuse(CropDef crop, string missing)
		{
			if (!Refused.ContainsKey(crop.Key))
			{
				Refused[crop.Key] = missing;
				Log.Warn("Crop '" + crop.Display + "' skipped: no prefab named '" + missing + "'. Everything else still builds.");
			}
		}

		private static void Name(GameObject go, string display, string description)
		{
			ItemDrop val = (((Object)(object)go == (Object)null) ? null : go.GetComponent<ItemDrop>());
			SharedData val2 = (((Object)(object)val == (Object)null || val.m_itemData == null) ? null : val.m_itemData.m_shared);
			if (val2 != null)
			{
				val2.m_name = display;
				val2.m_description = description;
			}
		}

		private static void DressFood(GameObject item, CropDef crop)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Name(item, crop.Display, crop.Blurb);
			Tinting.Dress(item, crop.Tint, 1f, crop.ItemName);
			ItemDrop component = item.GetComponent<ItemDrop>();
			SharedData val = (((Object)(object)component == (Object)null || component.m_itemData == null) ? null : component.m_itemData.m_shared);
			if (val != null)
			{
				val.m_food = crop.Health;
				val.m_foodStamina = crop.Stamina;
				val.m_foodEitr = crop.Eitr;
				val.m_foodBurnTime = crop.Duration;
				val.m_foodRegen = crop.Regen;
			}
		}

		private static void DressPickable(GameObject go, CropDef crop, GameObject gives, bool wild)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Tinting.Dress(go, crop.Tint, crop.Scale, ((Object)go).name);
			Pickable component = go.GetComponent<Pickable>();
			if ((Object)(object)component == (Object)null)
			{
				Log.Warn("'" + ((Object)go).name + "' has no Pickable - '" + crop.PickableSource + "' is not the prefab this expected.");
				return;
			}
			if ((Object)(object)gives != (Object)null)
			{
				ItemDrop component2 = gives.GetComponent<ItemDrop>();
				if ((Object)(object)component2 != (Object)null)
				{
					component.m_itemPrefab = ((Component)component2).gameObject;
				}
			}
			component.m_overrideName = (wild ? crop.SeedDisplay : crop.Display);
			component.m_amount = (wild ? 1 : 1);
			if (wild && component.m_respawnTimeMinutes <= 0f)
			{
				component.m_respawnTimeMinutes = 600f;
			}
		}

		private static void DressSapling(GameObject sapling, CropDef crop, GameObject grown, Func<string, GameObject> find)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Tinting.Dress(sapling, crop.Tint, crop.Scale, crop.SaplingName);
			Plant component = sapling.GetComponent<Plant>();
			if ((Object)(object)component == (Object)null)
			{
				Log.Warn("'" + crop.SaplingName + "' has no Plant component - '" + crop.SaplingSource + "' is not the prefab this expected.");
			}
			else
			{
				component.m_name = crop.Display;
				component.m_grownPrefabs = (GameObject[])(object)new GameObject[1] { grown };
				component.m_growTime = crop.GrowMinutes * 60f;
				component.m_growTimeMax = crop.GrowMinutes * 60f * 1.35f;
			}
			Piece component2 = sapling.GetComponent<Piece>();
			if ((Object)(object)component2 == (Object)null)
			{
				Log.Warn("'" + crop.SaplingName + "' has no Piece - it cannot be planted.");
				return;
			}
			component2.m_name = crop.Display;
			component2.m_description = crop.Blurb;
			component2.m_enabled = true;
			Requirement[] array = PrefabForge.Cost((string n) => PrefabForge.Find(n) ?? find(n), crop.PlantingCostName, 1);
			if (array.Length != 0)
			{
				array[0].m_recover = false;
				component2.m_resources = array;
			}
		}

		internal static void ResetForTests()
		{
			Built.Clear();
			Refused.Clear();
		}
	}
	internal static class ForgePatches
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		internal static class RegisterWithZNetScene
		{
			[HarmonyPrefix]
			private static void Prefix(ZNetScene __instance)
			{
				if ((Object)(object)__instance == (Object)null || __instance.m_prefabs == null)
				{
					return;
				}
				try
				{
					Dictionary<string, GameObject> byName = new Dictionary<string, GameObject>(StringComparer.Ordinal);
					foreach (GameObject prefab in __instance.m_prefabs)
					{
						if ((Object)(object)prefab != (Object)null && !byName.ContainsKey(((Object)prefab).name))
						{
							byName[((Object)prefab).name] = prefab;
						}
					}
					RunBuilders((string n) => (!byName.TryGetValue(n, out var value)) ? null : value);
					int num = 0;
					foreach (string name in PrefabForge.Names)
					{
						GameObject val = PrefabForge.Find(name);
						if (!((Object)(object)val == (Object)null) && !__instance.m_prefabs.Contains(val))
						{
							__instance.m_prefabs.Add(val);
							num++;
						}
					}
					if (num > 0)
					{
						Log.Info("Registered " + num + " prefab(s) with ZNetScene.");
					}
					DerivedSeal.Settle(PrefabForge.Names);
				}
				catch (Exception ex)
				{
					SafeMode.Trip("prefab registration threw: " + ex.Message);
					Log.Error("ZNetScene registration failed: " + ex);
				}
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "UpdateRegisters")]
		internal static class RegisterWithObjectDB
		{
			[HarmonyPrefix]
			private static void Prefix(ObjectDB __instance)
			{
				if ((Object)(object)__instance == (Object)null || __instance.m_items == null)
				{
					return;
				}
				try
				{
					RunBuilders(delegate(string n)
					{
						GameObject itemPrefab = __instance.GetItemPrefab(n);
						if ((Object)(object)itemPrefab != (Object)null)
						{
							return itemPrefab;
						}
						ZNetScene instance = ZNetScene.instance;
						return (!((Object)(object)instance == (Object)null)) ? instance.GetPrefab(n) : null;
					});
					foreach (GameObject allItem in PrefabForge.AllItems)
					{
						if ((Object)(object)allItem != (Object)null && !__instance.m_items.Contains(allItem))
						{
							__instance.m_items.Add(allItem);
						}
					}
					if (__instance.m_recipes == null)
					{
						return;
					}
					foreach (Recipe allRecipe in PrefabForge.AllRecipes)
					{
						if ((Object)(object)allRecipe != (Object)null && !__instance.m_recipes.Contains(allRecipe))
						{
							__instance.m_recipes.Add(allRecipe);
						}
					}
				}
				catch (Exception ex)
				{
					SafeMode.Trip("item registration threw: " + ex.Message);
					Log.Error("ObjectDB registration failed: " + ex);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Awake")]
		internal static class RegisterPieces
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ObjectDB instance = ObjectDB.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				foreach (string pieceTool in PrefabForge.PieceTools)
				{
					try
					{
						PieceTable val = TableOf(instance, pieceTool);
						if ((Object)(object)val == (Object)null || val.m_pieces == null)
						{
							Log.Warn("No build menu on '" + pieceTool + "' - its pieces cannot be placed this session.");
							continue;
						}
						foreach (GameObject item in PrefabForge.PiecesFor(pieceTool))
						{
							if ((Object)(object)item != (Object)null && !val.m_pieces.Contains(item))
							{
								val.m_pieces.Add(item);
							}
						}
					}
					catch (Exception ex)
					{
						Log.Error("Could not add pieces to '" + pieceTool + "': " + ex);
					}
				}
			}

			private static PieceTable TableOf(ObjectDB db, string tool)
			{
				GameObject itemPrefab = db.GetItemPrefab(tool);
				ItemDrop val = (((Object)(object)itemPrefab == (Object)null) ? null : itemPrefab.GetComponent<ItemDrop>());
				return (((Object)(object)val == (Object)null || val.m_itemData == null) ? null : val.m_itemData.m_shared)?.m_buildPieces;
			}
		}

		private static readonly List<Action<Func<string, GameObject>>> Builders = new List<Action<Func<string, GameObject>>>();

		internal static void Register(Action<Func<string, GameObject>> builder)
		{
			if (builder != null && !Builders.Contains(builder))
			{
				Builders.Add(builder);
			}
		}

		private static void RunBuilders(Func<string, GameObject> find)
		{
			foreach (Action<Func<string, GameObject>> builder in Builders)
			{
				try
				{
					builder(find);
				}
				catch (Exception ex)
				{
					SafeMode.Trip("a content builder threw: " + ex.Message);
					Log.Error("Content builder failed: " + ex);
				}
			}
		}
	}
	internal static class Nursery
	{
		private static GameObject _root;

		internal static Transform Root()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			if ((Object)(object)_root != (Object)null)
			{
				return _root.transform;
			}
			_root = new GameObject("nsg_prefabs");
			_root.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_root);
			return _root.transform;
		}

		internal static GameObject Clone(GameObject source, string name)
		{
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(source, Root());
			((Object)obj).name = name;
			return obj;
		}

		internal static void GiveOwnSharedData(GameObject clone)
		{
			ItemDrop val = (((Object)(object)clone == (Object)null) ? null : clone.GetComponent<ItemDrop>());
			if (!((Object)(object)val == (Object)null) && val.m_itemData != null && val.m_itemData.m_shared != null)
			{
				val.m_itemData.m_shared = CopyShared(val.m_itemData.m_shared);
			}
		}

		private static SharedData CopyShared(SharedData src)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			SharedData val = new SharedData();
			FieldInfo[] fields = typeof(SharedData).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (!fieldInfo.IsLiteral && !fieldInfo.IsInitOnly)
				{
					fieldInfo.SetValue(val, fieldInfo.GetValue(src));
				}
			}
			return val;
		}
	}
	internal static class Pantry
	{
		private static readonly List<string> Built = new List<string>();

		private static readonly Dictionary<string, string> Refused = new Dictionary<string, string>(StringComparer.Ordinal);

		internal static IEnumerable<string> BuiltKeys => Built;

		internal static IReadOnlyDictionary<string, string> RefusedKeys => Refused;

		internal static int BuiltCount => Built.Count;

		internal static void Arm()
		{
			ForgePatches.Register(Build);
			foreach (PantryDef item in PantryLibrary.All)
			{
				if (!item.IsIntermediate)
				{
					FryGenerator.DeclareIngredient(item.Name);
				}
			}
		}

		private static void Build(Func<string, GameObject> find)
		{
			if (ModConfig.PantryEnabled == null || !ModConfig.PantryEnabled.Value)
			{
				return;
			}
			foreach (PantryDef item in PantryLibrary.All)
			{
				try
				{
					BuildOne(item, find);
				}
				catch (Exception ex)
				{
					Refuse(item.Key, "threw while building: " + ex.Message);
					Log.Error("Pantry item '" + item.Key + "' failed: " + ex);
				}
			}
			Conversions.Apply(PantryLibrary.Chains(), find);
		}

		private static void BuildOne(PantryDef def, Func<string, GameObject> find)
		{
			if (Built.Contains(def.Key))
			{
				return;
			}
			GameObject val = find(def.Source);
			if ((Object)(object)val == (Object)null)
			{
				Refuse(def.Key, def.Source);
				return;
			}
			GameObject val2 = PrefabForge.MakeItem(val, def.Name, derived: false);
			if (!((Object)(object)val2 == (Object)null))
			{
				Dress(val2, def);
				if (def.IsCrafted)
				{
					Recipe(val2, def, find);
				}
				Built.Add(def.Key);
				Refused.Remove(def.Key);
			}
		}

		private static void Refuse(string key, string missing)
		{
			if (!Refused.ContainsKey(key))
			{
				Refused[key] = missing;
				Log.Warn("Pantry item '" + key + "' skipped: no prefab named '" + missing + "'. Everything else still builds.");
			}
		}

		private static void Dress(GameObject go, PantryDef def)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			ItemDrop component = go.GetComponent<ItemDrop>();
			SharedData val = (((Object)(object)component == (Object)null || component.m_itemData == null) ? null : component.m_itemData.m_shared);
			if (val == null)
			{
				Log.Warn("'" + def.Name + "' has no ItemDrop - '" + def.Source + "' is not the prefab this expected.");
			}
			else
			{
				val.m_name = def.Display;
				val.m_description = def.Blurb;
				val.m_food = def.Health;
				val.m_foodStamina = def.Stamina;
				val.m_foodEitr = def.Eitr;
				val.m_foodBurnTime = def.Duration;
				val.m_foodRegen = def.Regen;
				Tinting.Dress(go, def.Tint, 1f, def.Name);
			}
		}

		private static void Recipe(GameObject made, PantryDef def, Func<string, GameObject> find)
		{
			ItemDrop component = made.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			List<Requirement> list = new List<Requirement>();
			for (int i = 0; i < def.CostItems.Length; i++)
			{
				int amount = ((i >= def.CostAmounts.Length) ? 1 : def.CostAmounts[i]);
				Requirement[] array = PrefabForge.Cost((string n) => PrefabForge.Find(n) ?? find(n), def.CostItems[i], amount);
				if (array.Length == 0)
				{
					Log.Warn("No recipe for '" + def.Display + "': this install has no '" + def.CostItems[i] + "'.");
					return;
				}
				list.Add(array[0]);
			}
			Recipe val = ScriptableObject.CreateInstance<Recipe>();
			((Object)val).name = "Recipe_" + def.Name;
			val.m_item = component;
			val.m_amount = ((def.Produces <= 0) ? 1 : def.Produces);
			val.m_enabled = true;
			val.m_minStationLevel = 1;
			val.m_resources = list.ToArray();
			if (!string.IsNullOrEmpty(def.Station))
			{
				GameObject val2 = find(def.Station);
				CraftingStation val3 = (((Object)(object)val2 == (Object)null) ? null : val2.GetComponent<CraftingStation>());
				if ((Object)(object)val3 == (Object)null)
				{
					Log.Warn("'" + def.Display + "' wanted station '" + def.Station + "', which is not here - it will be craftable bare-handed.");
				}
				else
				{
					val.m_craftingStation = val3;
				}
			}
			PrefabForge.AddRecipe(val);
		}

		internal static void ResetForTests()
		{
			Built.Clear();
			Refused.Clear();
		}
	}
	internal sealed class PantryDef
	{
		internal string Key;

		internal string Display;

		internal string Blurb;

		internal string Source;

		internal Color Tint;

		internal string Station;

		internal string[] CostItems;

		internal int[] CostAmounts;

		internal int Produces = 1;

		internal bool Milled;

		internal string MillStation;

		internal string MillFrom;

		internal bool Fermented;

		internal string FermentStation;

		internal string FermentFrom;

		internal int Health;

		internal int Stamina;

		internal int Eitr;

		internal float Duration = 1500f;

		internal float Regen = 1f;

		internal string Name => "nsg_" + Key;

		internal bool IsCrafted
		{
			get
			{
				if (!Milled && !Fermented && CostItems != null)
				{
					return CostItems.Length != 0;
				}
				return false;
			}
		}

		internal bool IsIntermediate
		{
			get
			{
				if (Health <= 0 && Stamina <= 0)
				{
					return Duration <= 0f;
				}
				return false;
			}
		}
	}
	internal static class PantryLibrary
	{
		internal static readonly List<PantryDef> All = new List<PantryDef>
		{
			new PantryDef
			{
				Key = "flour",
				Display = "Wheat Flour",
				Blurb = "Ground fine. Keeps badly, bakes beautifully.",
				Source = "BarleyFlour",
				Tint = Rgb(238, 228, 200),
				Milled = true,
				MillStation = "windmill",
				MillFrom = "nsg_wheat",
				Health = 2,
				Stamina = 2,
				Duration = 600f
			},
			new PantryDef
			{
				Key = "bread",
				Display = "Bread",
				Blurb = "The whole point of a field. Best within the hour.",
				Source = "Bread",
				Tint = Rgb(198, 150, 92),
				Milled = true,
				MillStation = "piece_oven",
				MillFrom = "nsg_flour",
				Health = 30,
				Stamina = 30,
				Duration = 1800f,
				Regen = 2f
			},
			new PantryDef
			{
				Key = "sugar",
				Display = "Sugar",
				Blurb = "Crushed, boiled and dried. Worth the Plains.",
				Source = "Honey",
				Tint = Rgb(246, 244, 238),
				Station = "piece_cauldron",
				CostItems = new string[1] { "nsg_sugarcane" },
				CostAmounts = new int[1] { 3 },
				Produces = 2,
				Health = 4,
				Stamina = 20,
				Duration = 900f
			},
			new PantryDef
			{
				Key = "pearl_oil",
				Display = "Pearl Oil",
				Blurb = "Pressed from the fat root. Half a jar is a day's walking.",
				Source = "Honey",
				Tint = Rgb(232, 218, 160),
				Station = "piece_cauldron",
				CostItems = new string[1] { "nsg_pearl" },
				CostAmounts = new int[1] { 2 },
				Health = 4,
				Stamina = 46,
				Duration = 2400f,
				Regen = 1f
			},
			new PantryDef
			{
				Key = "red_brew_base",
				Display = "Red Brew Base",
				Blurb = "Meat, blood and thistle. Do not drink it yet.",
				Source = "MeadBaseTasty",
				Tint = Rgb(96, 18, 28),
				Station = "piece_cauldron",
				CostItems = new string[3] { "RawMeat", "BloodBag", "Thistle" },
				CostAmounts = new int[3] { 4, 2, 2 },
				Produces = 1,
				Health = 0,
				Stamina = 0,
				Duration = 0f
			},
			new PantryDef
			{
				Key = "red_brew",
				Display = "Red Brew",
				Blurb = "Iron-tasting and warm. Sits where a meal would.",
				Source = "MeadTasty",
				Tint = Rgb(126, 24, 34),
				Fermented = true,
				FermentFrom = "nsg_red_brew_base",
				FermentStation = "fermenter",
				Produces = 6,
				Health = 24,
				Stamina = 6,
				Duration = 1500f,
				Regen = 4f
			},
			new PantryDef
			{
				Key = "gore_brew_base",
				Display = "Gore Brew Base",
				Blurb = "Entrails, and something that was recently upset.",
				Source = "MeadBaseTasty",
				Tint = Rgb(64, 30, 40),
				Station = "piece_cauldron",
				CostItems = new string[3] { "Entrails", "BloodBag", "Honey" },
				CostAmounts = new int[3] { 3, 2, 4 },
				Health = 0,
				Stamina = 0,
				Duration = 0f
			},
			new PantryDef
			{
				Key = "gore_brew",
				Display = "Gore Brew",
				Blurb = "Nobody enjoys it. Everybody finishes it.",
				Source = "MeadTasty",
				Tint = Rgb(88, 40, 52),
				Fermented = true,
				FermentFrom = "nsg_gore_brew_base",
				FermentStation = "fermenter",
				Produces = 6,
				Health = 8,
				Stamina = 34,
				Duration = 1500f,
				Regen = 1f
			}
		};

		private static Color Rgb(int r, int g, int b)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			return new Color((float)r / 255f, (float)g / 255f, (float)b / 255f, 1f);
		}

		internal static IEnumerable<ConversionDef> Chains()
		{
			List<ConversionDef> list = new List<ConversionDef>();
			foreach (PantryDef item in All)
			{
				if (item.Milled)
				{
					list.Add(new ConversionDef
					{
						Station = item.MillStation,
						From = item.MillFrom,
						To = item.Name,
						Note = item.Display + " is milled or baked, not crafted"
					});
				}
				if (item.Fermented)
				{
					list.Add(new ConversionDef
					{
						Station = item.FermentStation,
						From = item.FermentFrom,
						To = item.Name,
						Produced = item.Produces,
						Note = item.Display + " ferments like mead"
					});
				}
			}
			return list;
		}

		internal static PantryDef Find(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return null;
			}
			foreach (PantryDef item in All)
			{
				if (string.Equals(item.Key, key, StringComparison.OrdinalIgnoreCase))
				{
					return item;
				}
			}
			return null;
		}
	}
	internal static class PieCounter
	{
		internal const string Name = "nsg_pie_counter";

		internal const string Display = "Pie Counter";

		internal static bool Built { get; private set; }

		internal static void Arm()
		{
			ForgePatches.Register(Build);
		}

		private static void Build(Func<string, GameObject> find)
		{
			if (ModConfig.PiesEnabled == null || !ModConfig.PiesEnabled.Value)
			{
				return;
			}
			if (PrefabForge.Has("nsg_pie_counter"))
			{
				Built = true;
				return;
			}
			try
			{
				Make(find);
			}
			catch (Exception ex)
			{
				Log.Error("Pie counter failed: " + ex);
			}
		}

		private static void Make(Func<string, GameObject> find)
		{
			GameObject val = find("piece_cauldron");
			if ((Object)(object)val == (Object)null)
			{
				Log.Warn("No 'piece_cauldron' to base the Pie Counter on - pies will fall back to whatever Content.PieStation names.");
				return;
			}
			GameObject val2 = PrefabForge.MakePiece(val, "nsg_pie_counter", derived: false);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			CraftingStation component = val2.GetComponent<CraftingStation>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_name = "Pie Counter";
				component.m_craftRequireFire = false;
				component.m_craftRequireRoof = false;
			}
			else
			{
				Log.Warn("'nsg_pie_counter' has no CraftingStation - 'piece_cauldron' is not the prefab this expected, and no pie will be craftable at it.");
			}
			Piece component2 = val2.GetComponent<Piece>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_name = "Pie Counter";
				component2.m_description = "A long bench with a cold slab. Every pie this kitchen knows how to make, in one place.";
				component2.m_enabled = true;
				Func<string, GameObject> find2 = (string n) => PrefabForge.Find(n) ?? find(n);
				Requirement[] array = PrefabForge.Cost(find2, "Wood", 10);
				Requirement[] array2 = PrefabForge.Cost(find2, "Stone", 4);
				if (array.Length != 0 && array2.Length != 0)
				{
					component2.m_resources = (Requirement[])(object)new Requirement[2]
					{
						array[0],
						array2[0]
					};
				}
			}
			Built = true;
		}

		internal static void ResetForTests()
		{
			Built = false;
		}
	}
	internal static class PrefabForge
	{
		private static readonly Dictionary<string, GameObject> Made = new Dictionary<string, GameObject>(StringComparer.Ordinal);

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

		private static readonly Dictionary<string, List<GameObject>> PiecesByTool = new Dictionary<string, List<GameObject>>(StringComparer.Ordinal);

		internal const string Hammer = "Hammer";

		internal const string Cultivator = "Cultivator";

		private static readonly List<Recipe> Recipes = new List<Recipe>();

		internal static IEnumerable<GameObject> AllItems => Items;

		internal static IEnumerable<string> PieceTools => PiecesByTool.Keys;

		internal static IEnumerable<Recipe> AllRecipes => Recipes;

		internal static ICollection<string> Names => Made.Keys;

		internal static int Count => Made.Count;

		internal static IEnumerable<GameObject> PiecesFor(string tool)
		{
			if (tool == null || !PiecesByTool.TryGetValue(tool, out var value))
			{
				return (IEnumerable<GameObject>)(object)new GameObject[0];
			}
			return value;
		}

		internal static GameObject Find(string name)
		{
			if (name == null || !Made.TryGetValue(name, out var value))
			{
				return null;
			}
			return value;
		}

		internal static bool Has(string name)
		{
			if (name != null)
			{
				return Made.ContainsKey(name);
			}
			return false;
		}

		private static bool Sealed(string name, bool derived)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (PrefabRegistry.IsPoison(stableHashCode))
			{
				SafeMode.Trip("'" + name + "' hashes to " + stableHashCode + ", which Valheim deletes on sight - it must never reach a world");
				return false;
			}
			if (!derived)
			{
				if (!PrefabRegistry.Sealed.TryGetValue(name, out var value))
				{
					Log.Error("Refusing to forge '" + name + "': it is not in PrefabRegistry. Authored prefab names must be sealed before they ship - see SAFETY.md.");
					return false;
				}
				if (value != stableHashCode)
				{
					SafeMode.Trip("'" + name + "' hashes to " + stableHashCode + " but " + value + " was sealed - either the name moved or the offline hash function disagrees with the game's");
					return false;
				}
				return true;
			}
			if (!DerivedSeal.Record(name, stableHashCode))
			{
				SafeMode.Trip("derived prefab '" + name + "' hashes differently than it did on a previous run, which should not be possible");
				return false;
			}
			return true;
		}

		internal static GameObject Make(GameObject source, string name, bool derived)
		{
			if (string.IsNullOrEmpty(name) || (Object)(object)source == (Object)null)
			{
				return null;
			}
			if (Made.TryGetValue(name, out var value))
			{
				return value;
			}
			if (SafeMode.Active)
			{
				SafeMode.Allow("forge '" + name + "'");
				return null;
			}
			if (!Sealed(name, derived))
			{
				return null;
			}
			GameObject val = Nursery.Clone(source, name);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Made[name] = val;
			return val;
		}

		internal static GameObject MakeItem(GameObject source, string name, bool derived)
		{
			GameObject val = Make(source, name, derived);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Nursery.GiveOwnSharedData(val);
			if (!Items.Contains(val))
			{
				Items.Add(val);
			}
			return val;
		}

		internal static GameObject MakePiece(GameObject source, string name, bool derived, string tool = "Hammer")
		{
			GameObject val = Make(source, name, derived);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if (string.IsNullOrEmpty(tool))
			{
				tool = "Hammer";
			}
			if (!PiecesByTool.TryGetValue(tool, out var value))
			{
				value = (PiecesByTool[tool] = new List<GameObject>());
			}
			if (!value.Contains(val))
			{
				value.Add(val);
			}
			return val;
		}

		internal static void AddRecipe(Recipe recipe)
		{
			if (!((Object)(object)recipe == (Object)null) && !Recipes.Contains(recipe))
			{
				Recipes.Add(recipe);
			}
		}

		internal static Requirement[] Cost(Func<string, GameObject> find, string itemName, int amount)
		{
			//IL_004e: 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_005a: 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_0069: Expected O, but got Unknown
			GameObject val = find?.Invoke(itemName);
			ItemDrop val2 = (((Object)(object)val == (Object)null) ? null : val.GetComponent<ItemDrop>());
			if ((Object)(object)val2 == (Object)null)
			{
				Log.Warn("No item named '" + itemName + "' to charge for this.");
				return (Requirement[])(object)new Requirement[0];
			}
			return (Requirement[])(object)new Requirement[1]
			{
				new Requirement
				{
					m_resItem = val2,
					m_amount = amount,
					m_recover = true
				}
			};
		}

		internal static void ResetForTests()
		{
			Made.Clear();
			Items.Clear();
			PiecesByTool.Clear();
			Recipes.Clear();
		}
	}
	internal static class SmokeHook
	{
		internal const string HookName = "nsg_smoke_hook";

		internal const string SteelName = "nsg_nordic_steel";

		private const float SmokeSeconds = 1800f;

		internal static bool HookBuilt { get; private set; }

		internal static bool SteelBuilt { get; private set; }

		internal static void Arm()
		{
			ForgePatches.Register(Build);
		}

		private static void Build(Func<string, GameObject> find)
		{
			if (ModConfig.SmokingEnabled != null && ModConfig.SmokingEnabled.Value)
			{
				try
				{
					BuildSteel(find);
					Jerky.Build(find);
					BuildHook(find);
					RefreshChains();
				}
				catch (Exception ex)
				{
					Log.Error("Smoke hook failed: " + ex);
				}
			}
		}

		private static void BuildSteel(Func<string, GameObject> find)
		{
			if (PrefabForge.Has("nsg_nordic_steel"))
			{
				SteelBuilt = true;
				return;
			}
			GameObject val = find("Iron");
			if ((Object)(object)val == (Object)null)
			{
				Log.Warn("No 'Iron' to base Nordic Steel on - the top station tier will keep charging its inputs directly, which costs the same.");
				return;
			}
			GameObject val2 = PrefabForge.MakeItem(val, "nsg_nordic_steel", derived: false);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			ItemDrop component = val2.GetComponent<ItemDrop>();
			SharedData val3 = (((Object)(object)component == (Object)null || component.m_itemData == null) ? null : component.m_itemData.m_shared);
			if (val3 != null)
			{
				val3.m_name = "Nordic Steel";
				val3.m_description = "Iron smelted with bone, which nobody meant to do the first time. Harder than either.";
			}
			Recipe val4 = ScriptableObject.CreateInstance<Recipe>();
			((Object)val4).name = "Recipe_nsg_nordic_steel";
			val4.m_item = component;
			val4.m_amount = 1;
			val4.m_enabled = true;
			val4.m_minStationLevel = 1;
			Func<string, GameObject> find2 = (string n) => PrefabForge.Find(n) ?? find(n);
			Requirement[] array = PrefabForge.Cost(find2, "Iron", 2);
			Requirement[] array2 = PrefabForge.Cost(find2, "BoneFragments", 4);
			if (array.Length == 0 || array2.Length == 0)
			{
				Log.Warn("No recipe for Nordic Steel: this install is missing Iron or BoneFragments.");
				return;
			}
			val4.m_resources = (Requirement[])(object)new Requirement[2]
			{
				array[0],
				array2[0]
			};
			GameObject val5 = find("forge");
			CraftingStation val6 = (((Object)(object)val5 == (Object)null) ? null : val5.GetComponent<CraftingStation>());
			if ((Object)(object)val6 != (Object)null)
			{
				val4.m_craftingStation = val6;
			}
			PrefabForge.AddRecipe(val4);
			SteelBuilt = true;
		}

		private static void BuildHook(Func<string, GameObject> find)
		{
			if (PrefabForge.Has("nsg_smoke_hook"))
			{
				HookBuilt = true;
				return;
			}
			GameObject val = find("piece_chest_wood");
			if ((Object)(object)val == (Object)null)
			{
				Log.Warn("No 'piece_chest_wood' to base the smoke hook on.");
				return;
			}
			GameObject val2 = PrefabForge.MakePiece(val, "nsg_smoke_hook", derived: false);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			Piece component = val2.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_name = "Smoke Hook";
				component.m_description = "Hang meat on it. Come back much later. Cheap enough to build a wall of them.";
				component.m_enabled = true;
				Func<string, GameObject> find2 = (string n) => PrefabForge.Find(n) ?? find(n);
				Requirement[] array = PrefabForge.Cost(find2, "Wood", 3);
				Requirement[] array2 = PrefabForge.Cost(find2, "LeatherScraps", 1);
				if (array.Length != 0 && array2.Length != 0)
				{
					component.m_resources = (Requirement[])(object)new Requirement[2]
					{
						array[0],
						array2[0]
					};
				}
			}
			Container obj = val2.GetComponent<Container>() ?? val2.AddComponent<Container>();
			obj.m_name = "Smoke Hook";
			obj.m_width = 2;
			obj.m_height = 2;
			AutoStation obj2 = val2.GetComponent<AutoStation>() ?? val2.AddComponent<AutoStation>();
			obj2.Tier = StationTier.Stone;
			obj2.SecondsPerCycle = 1800f;
			obj2.InputRows = 1;
			obj2.SkillId = "dafini.norntastic.smokemaster";
			HookBuilt = true;
		}

		private static void RefreshChains()
		{
			GameObject val = PrefabForge.Find("nsg_smoke_hook");
			AutoStation autoStation = (((Object)(object)val == (Object)null) ? null : val.GetComponent<AutoStation>());
			if ((Object)(object)autoStation == (Object)null)
			{
				return;
			}
			autoStation.Chains.Clear();
			foreach (ConversionDef item in Jerky.Chains())
			{
				autoStation.Chains.Add(item);
			}
		}

		internal static void ResetForTests()
		{
			HookBuilt = false;
			SteelBuilt = false;
		}
	}
	internal static class Sow
	{
		[HarmonyPatch(typeof(ZoneSystem), "PlaceVegetation")]
		internal static class PlaceVegetationPatch
		{
			[HarmonyPrefix]
			private static void Prefix(ZoneSystem __instance)
			{
				if (Available)
				{
					Ensure(__instance);
				}
			}
		}

		internal static bool Available { get; private set; } = true;

		internal static int Sown { get; private set; }

		internal static bool Ran { get; private set; }

		private static void Disable(string reason)
		{
			if (Available)
			{
				Available = false;
				Log.Warn("Wild crops turned themselves off: " + reason + ". Planting still works; they just will not grow on their own.");
			}
		}

		internal static void Ensure(ZoneSystem zones)
		{
			if (!Available || (Object)(object)zones == (Object)null || zones.m_vegetation == null || ModConfig.WildCropsEnabled == null || !ModConfig.WildCropsEnabled.Value)
			{
				return;
			}
			Ran = true;
			try
			{
				int num = 0;
				foreach (CropDef item in CropLibrary.All)
				{
					GameObject val = PrefabForge.Find(item.WildName);
					if (!((Object)(object)val == (Object)null) && !Holds(zones, val))
					{
						zones.m_vegetation.Add(Entry(item, val));
						num++;
					}
				}
				if (num > 0)
				{
					Sown += num;
					Log.Info("Sowed " + num + " crop(s) into world generation. They will appear in land generated from here on, not in ground you have already explored.");
				}
			}
			catch (Exception ex)
			{
				Disable("appending to the vegetation table threw: " + ex.Message);
				Log.Error("Sow failed: " + ex);
			}
		}

		private static bool Holds(ZoneSystem zones, GameObject prefab)
		{
			List<ZoneVegetation> vegetation = zones.m_vegetation;
			for (int i = 0; i < vegetation.Count; i++)
			{
				if (vegetation[i] != null && (Object)(object)vegetation[i].m_prefab == (Object)(object)prefab)
				{
					return true;
				}
			}
			return false;
		}

		private static ZoneVegetation Entry(CropDef crop, GameObject prefab)
		{
			//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_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_002c: 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_003b: 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_0045: 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_0053: 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_0065: 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_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_0091: 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_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_00b9: 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_00cb: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			return new ZoneVegetation
			{
				m_name = crop.WildName,
				m_prefab = prefab,
				m_enable = true,
				m_min = crop.WildMin,
				m_max = crop.WildMax,
				m_biome = crop.WildBiome,
				m_biomeArea = (BiomeArea)3,
				m_blockCheck = true,
				m_forcePlacement = false,
				m_scaleMin = 0.9f,
				m_scaleMax = 1.1f,
				m_randTilt = 6f,
				m_chanceToUseGroundTilt = 1f,
				m_minAltitude = 1f,
				m_maxAltitude = 1000f,
				m_maxTilt = 25f,
				m_minTilt = 0f,
				m_groupSizeMin = 2,
				m_groupSizeMax = 5,
				m_groupRadius = 6f,
				m_inForest = true,
				m_forestTresholdMin = 0f,
				m_forestTresholdMax = 1.15f
			};
		}

		internal static void ResetForTests()
		{
			Available = true;
			Sown = 0;
			Ran = false;
		}
	}
	internal static class StationPolicy
	{
		internal static readonly IReadOnlyDictionary<string, string> RequiresOurs = new Dictionary<string, string>
		{
			{ "nsg_pie_counter", "the pies - forty of them, and a cauldron menu they were burying" },
			{ "nsg_smoke_hook", "the jerky - a hook IS the smoking, so there is nothing to gate behind" },
			{ "nsg_station_deepfryer_stone", "the fried food - 'any food becomes the next kind' is what the basin DOES, and there is no vanilla building that does it" }
		};

		internal const int MaxGated = 3;

		internal static int GatedCount => RequiresOurs.Count;
	}
	internal static class Stations
	{
		private static readonly List<string> Built = new List<string>();

		private static readonly Dictionary<string, string> Refused = new Dictionary<string, string>(StringComparer.Ordinal);

		internal static IEnumerable<string> BuiltNames => Built;

		internal static IReadOnlyDictionary<string, string> RefusedStations => Refused;

		internal static int BuiltCount => Built.Count;

		internal static int AdoptedChains { get; private set; }

		internal static void Arm()
		{
			ForgePatches.Register(Build);
		}

		private static void Build(Func<string, GameObject> find)
		{
			if (ModConfig.StationsEnabled == null || !ModConfig.StationsEnabled.Value)
			{
				return;
			}
			foreach (AutoStationDef item in AutoStationLibrary.All)
			{
				foreach (StationTier value in Enum.GetValues(typeof(StationTier)))
				{
					try
					{
						BuildOne(item, value, find);
					}
					catch (Exception ex)
					{
						Refuse(item.NameFor(value), "threw: " + ex.Message);
						Log.Error("Station '" + item.NameFor(value) + "' failed: " + ex);
					}
				}
			}
		}

		private static void BuildOne(AutoStationDef def, StationTier tier, Func<string, GameObject> find)
		{
			string text = def.NameFor(tier);
			if (Built.Contains(text))
			{
				return;
			}
			GameObject val = find(def.Source);
			if ((Object)(object)val == (Object)null)
			{
				Refuse(text, "no prefab '" + def.Source + "'");
				return;
			}
			GameObject val2 = PrefabForge.MakePiece(val, text, derived: false);
			if (!((Object)(object)val2 == (Object)null) && Dress(val2, def, tier, find))
			{
				Built.Add(text);
				Refused.Remove(text);
			}
		}

		private static void Refuse(string name, string why)
		{
			if (!Refused.ContainsKey(name))
			{
				Refused[name] = why;
				Log.Warn("Station '" + name + "' skipped: " + why + ". The others still build.");
			}
		}

		private static bool Dress(GameObject go, AutoStationDef def, StationTier tier, Func<string, GameObject> find)
		{
			bool result = DressPiece(go, def, tier, find);
			Container container = DressContainer(go, def);
			DressDriver(go, def, tier, container, find);
			return result;
		}

		private static bool DressPiece(GameObject go, AutoStationDef def, StationTier tier, Func<string, GameObject> find)
		{
			Piece component = go.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null)
			{
				Log.Warn("'" + def.NameFor(tier) + "' has no Piece - '" + def.Source + "' is not the prefab this expected.");
				return true;
			}
			component.m_name = def.DisplayFor(tier);
			component.m_description = def.Blurb + "  " + StationTiers.Describe(tier);
			component.m_enabled = true;
			component.m_resources = CostOf(def, tier, find, out var complete);
			return complete;
		}

		private static Requirement[] CostOf(AutoStationDef def, StationTier tier, Func<string, GameObject> find, out bool complete)
		{
			int num = (int)(1 + tier);
			List<Requirement> list = new List<Requirement>();
			complete = true;
			Func<string, GameObject> find2 = (string n) => PrefabForge.Find(n) ?? find(n);
			for (int num2 = 0; num2 < def.CostItems.Length; num2++)
			{
				int amount = ((num2 >= def.CostAmounts.Length) ? 1 : def.CostAmounts[num2]) * num;
				Requirement[] array = PrefabForge.Cost(find2, def.CostItems[num2], amount);
				if (array.Length != 0)
				{
					list.Add(array[0]);
				}
				else
				{
					complete = false;
				}
			}
			string text = MetalFor(tier);
			if (text != null)
			{
				Requirement[] array2 = PrefabForge.Cost(find2, text, 5 * num);
				if (array2.Length != 0)
				{
					list.Add(array2[0]);
				}
				else if (text.StartsWith("nsg_", StringComparison.Ordinal))
				{
					complete = false;
				}
			}
			return list.ToArray();
		}

		private static string MetalFor(StationTier tier)
		{
			return tier switch
			{
				StationTier.Stone => "Stone", 
				StationTier.Bronze => "Bronze", 
				StationTier.Iron => "Iron", 
				StationTier.NordicSteel => "nsg_nordic_steel", 
				_ => null, 
			};
		}

		private static Container DressContainer(GameObject go, AutoStationDef def)
		{
			Container val = go.GetComponent<Container>() ?? go.AddComponent<Container>();
			val.m_name = def.Display;
			val.m_width = def.Width;
			int num = def.Height;
			if (num % 2 != 0)
			{
				Log.Warn("'" + def.Key + "' asked for " + num + " rows, which cannot be split evenly into input and output. Using " + (num + 1) + ".");
				num++;
			}
			val.m_height = num;
			return val;
		}

		private static void DressDriver(GameObject go, AutoStationDef def, StationTier tier, Container container, Func<string, GameObject> find)
		{
			AutoStation autoStation = go.GetComponent<AutoStation>() ?? go.AddComponent<AutoStation>();
			autoStation.Tier = tier;
			autoStation.SecondsPerCycle = StationTiers.SecondsPerCycle(tier, def.SecondsPerCycle);
			autoStation.InputRows = (((Object)(object)container == (Object)null) ? 2 : (container.m_height / 2));
			autoStation.SkillId = def.SkillId;
			autoStation.Chains.Clear();
			if (def.OwnChains != null)
			{
				ConversionDef[] ownChains = def.OwnChains;
				foreach (ConversionDef item in ownChains)
				{
					autoStation.Chains.Add(item);
				}
			}
			if (def.DerivedChains != null)
			{
				foreach (ConversionDef item2 in def.DerivedChains())
				{
					autoStation.Chains.Add(item2);
				}
			}
			if (!string.IsNullOrEmpty(def.Adopts))
			{
				Adopt(autoStation, def.Adopts, find);
			}
		}

		private static void Adopt(AutoStation driver, string stationName, Func<string, GameObject> find)
		{
			GameObject val = find(stationName);
			if ((Object)(object)val == (Object)null)
			{
				Log.Warn("Cannot adopt from '" + stationName + "' - it is not in this install, so that station has only its own chains.");
				return;
			}
			int count = driver.Chains.Count;
			CookingStation component = val.GetComponent<CookingStation>();
			if ((Object)(object)component != (Object)null && component.m_conversion != null)
			{
				foreach (ItemConversion item in component.m_conversion)
				{
					Take(driver, item?.m_from, item?.m_to);
				}
			}
			Fermenter component2 = val.GetComponent<Fermenter>();
			if ((Object)(object)component2 != (Object)null && component2.m_conversion != null)
			{
				foreach (ItemConversion item2 in component2.m_conversion)
				{
					Take(driver, item2?.m_from, item2?.m_to);
				}
			}
			Smelter component3 = val.GetComponent<Smelter>();
			if ((Object)(object)component3 != (Object)null && component3.m_conversion != null)
			{
				foreach (ItemConversion item3 in component3.m_conversion)
				{
					Take(driver, item3?.m_from, item3?.m_to);
				}
			}
			AdoptedChains += driver.Chains.Count - count;
		}

		private static void Take(AutoStation driver, ItemDrop from, ItemDrop to)
		{
			if ((Object)(object)from == (Object)null || (Object)(object)to == (Object)null)
			{
				return;
			}
			ConversionDef conversionDef = new ConversionDef
			{
				From = ((Object)((Component)from).gameObject).name,
				To = ((Object)((Component)to).gameObject).name,
				Note = "adopted"
			};
			foreach (ConversionDef chain in driver.Chains)
			{
				if (chain.From == conversionDef.From && chain.To == conversionDef.To)
				{
					return;
				}
			}
			driver.Chains.Add(conversionDef);
		}

		internal static void ResetForTests()
		{
			Built.Clear();
			Refused.Clear();
			AdoptedChains = 0;
		}
	}
	internal enum StationTier
	{
		Stone,
		Bronze,
		Iron,
		NordicSteel
	}
	internal static class StationTiers
	{
		private static readonly int[] Stacks = new int[4] { 1, 2, 3, 5 };

		internal static int Count => Stacks.Length;

		internal static int OutputStack(StationTier tier)
		{
			if (tier < StationTier.Stone || (int)tier >= Stacks.Length)
			{
				return Stacks[0];
			}
			return Stacks[(int)tier];
		}

		internal static bool WaivesOneInput(StationTier tier)
		{
			return tier == StationTier.NordicSteel;
		}

		internal static float SecondsPerCycle(StationTier tier, float baseSeconds)
		{
			return baseSeconds;
		}

		internal static string Describe(StationTier tier)
		{
			return tier.ToString() + " - " + OutputStack(tier) + "x output" + (WaivesOneInput(tier) ? ", ignores one ingredient" : string.Empty);
		}

		internal static StationTier Parse(string name)
		{
			foreach (StationTier value in Enum.GetValues(typeof(StationTier)))
			{
				if (string.Equals(value.ToString(), name, StringComparison.OrdinalIgnoreCase))
				{
					return value;
				}
			}
			return StationTier.Stone;
		}
	}
	internal static class Tinting
	{
		private static readonly string[] ColourProperties = new string[4] { "_Color", "_MainColor", "_BaseColor", "_TintColor" };

		internal static int Apply(GameObject prefab, Color tint)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)prefab == (Object)null)
			{
				return 0;
			}
			int num = 0;
			Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
			if (componentsInChildren == null)
			{
				return 0;
			}
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					continue;
				}
				Material[] array2 = (Material[])(object)new Material[sharedMaterials.Length];
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					if ((Object)(object)sharedMaterials[j] == (Object)null)
					{
						array2[j] = null;
						continue;
					}
					Material val2 = new Material(sharedMaterials[j]);
					string[] colourProperties = ColourProperties;
					foreach (string text in colourProperties)
					{
						if (val2.HasProperty(text))
						{
							val2.SetColor(text, tint);
							num++;
						}
					}
					array2[j] = val2;
				}
				val.sharedMaterials = array2;
			}
			return num;
		}

		internal static void Rescale(GameObject prefab, float scale)
		{
			//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)
			if (!((Object)(object)prefab == (Object)null) && !(scale <= 0f) && !Mathf.Approximately(scale, 1f))
			{
				Transform transform = prefab.transform;
				transform.localScale *= scale;
			}
		}

		internal static void Dress(GameObject prefab, Color tint, float scale, string what)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)prefab == (Object)null))
			{
				int num = Apply(prefab, tint);
				Rescale(prefab, scale);
				if (num == 0)
				{
					Log.Warn("Nothing on '" + what + "' took a colour - its shader has none of the properties we know about, so it will look like what it was cloned from.");
				}
			}
		}
	}
}
namespace Norntastic.Config
{
	internal static class ModConfig
	{
		internal static ConfigEntry<int> PointInterval;

		internal static ConfigEntry<bool> PrestigeEnabled;

		internal static ConfigEntry<int> PrestigeCap;

		internal static ConfigEntry<int> PrestigeEffectiveLevels;

		internal static ConfigEntry<int> PrestigePoints;

		internal static ConfigEntry<bool> FreeRespec;

		internal static ConfigEntry<int> RespecPointsPerItem;

		internal static ConfigEntry<string> DatabaseFingerprint;

		internal static ConfigEntry<bool> GenerateStubTrees;

		internal static ConfigEntry<string> Intoxicants;

		internal const string DefaultIntoxicants = "mead,ale,wine,tar,drunk,brew";

		internal static ConfigEntry<string> Utensils;

		internal const string DefaultUtensils = "fork,ladle,spoon,pan,pot,skewer,rolling pin,cleaver,baguette,salami,pie,apron";

		internal static ConfigEntry<bool> PiesEnabled;

		internal static ConfigEntry<string> FavouriteTrees;

		internal static ConfigEntry<float> RailScrollSpeed;

		internal static ConfigEntry<float> RailGlide;

		internal static ConfigEntry<bool> BrawlerSpareHotbar;

		internal static ConfigEntry<string> BrawlerFavouriteKeys;

		internal static ConfigEntry<string> PieBaseItem;

		internal static ConfigEntry<string> PieStation;

		internal const string DefaultPieStation = "nsg_pie_counter";

		internal static ConfigEntry<bool> SmokingEnabled;

		internal static ConfigEntry<bool> StationsEnabled;

		internal static ConfigEntry<bool> PantryEnabled;

		internal static ConfigEntry<bool> ArsenalEnabled;

		internal static ConfigEntry<bool> CropsEnabled;

		internal static ConfigEntry<bool> WildCropsEnabled;

		internal static ConfigEntry<bool> BakeryEnabled;

		internal static ConfigEntry<string> BakeryCounterSource;

		internal static ConfigEntry<string> BakeryPieSource;

		internal static ConfigEntry<string> BakeryCounterCost;

		internal static ConfigEntry<string> BakeryPieCost;

		internal static ConfigEntry<string> PieMeats;

		internal static ConfigEntry<string> PieVegetables;

		internal static ConfigEntry<int> PieLimit;

		internal static ConfigEntry<float> CostFloor;

		internal static ConfigEntry<bool> DualWieldEnabled;

		internal static ConfigEntry<int> DualWieldCadence;

		internal static ConfigEntry<bool> AttackStringsEnabled;

		internal static ConfigEntry<float> IdolCooldownCap;

		internal static ConfigEntry<float> UiScale;

		internal static ConfigEntry<bool> HideUnlearnedSkills;

		internal static ConfigEntry<float> TreeZoom;

		internal static ConfigEntry<bool> Verbose;

		internal const string RespecItemName = "Unwoven Thread";

		private static string[] _intoxicantCache;

		private static string _intoxicantRaw;

		internal static void Bind(ConfigFile cfg)
		{
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Expected O, but got Unknown
			//IL_04c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ce: Expected O, but got Unknown
			PointInterval = Synced(cfg, "Progression", "PointInterval", 10, "COMBINED skill levels per perk point, summed across every skill. Points go into one pool and spend in any tree, so breadth pays as well as depth - and because a point goes anywhere, it costs more than it would if it were locked to one skill. Derived from high-water marks, so lowering this retroactively grants more.");
			PrestigeEnabled = Synced(cfg, "Prestige", "Enabled", value: true, "Allow prestiging a skill once it reaches level 100.");
			PrestigeCap = Synced(cfg, "Prestige", "Cap", 5, "Maximum prestiges per skill. Uncapped effective-level bonuses stack into the Skyrim legendary-skill exploit, so this defaults low.");
			PrestigeEffectiveLevels = Synced(cfg, "Prestige", "EffectiveLevelsPerRank", 2, "Permanent effective skill levels granted per prestige, applied through StatusEffect.ModifySkillLevel.");
			PrestigePoints = Synced(cfg, "Prestige", "PointsPerRank", 2, "Permanent perk points granted per prestige. They land in the shared pool like every other point, so they spend anywhere.");
			FreeRespec = Synced(cfg, "Respec", "FreeRespec", value: true, "Refunds cost nothing. Intended for testing; turn off for release and let the Unwoven Thread be the only way to respec.");
			RespecPointsPerItem = Synced(cfg, "Respec", "PointsPerItem", 2, "Respec points granted by one Unwoven Thread. One point refunds one rank.");
			CostFloor = Synced(cfg, "Combat", "CostFloor", 0.1f, "The least a stamina cost can be reduced to, as a fraction of its base. 0.1 means an attack can never cost less than a tenth of normal however many reduction perks are stacked. This exists because the reductions in the database total -565%, which unclamped inverts the sign and makes attacking restore stamina. Raise it to make deep stamina builds less extreme; do not set it to zero.");
			DualWieldEnabled = Synced(cfg, "Combat", "DualWield", value: true, "Offhand weapons, shields and torches contribute to your attacks. The offhand is NOT separately animated - Valheim's dual-wield weapons are a single item carrying both models, and a second animated swing would need an asset bundle rebuilt for every Unity version. Turning this off leaves the perks bought but inert.");
			AttackStringsEnabled = Synced(cfg, "Combat", "AttackStrings", value: true, "Blows landed in an unbroken string escalate: the second is cheaper, the third hits harder. The effect is proportional to the weapon skill, so a novice barely notices it and a veteran fights in phrases. Pausing or switching weapon type breaks the string.");
			IdolCooldownCap = Synced(cfg, "Combat", "IdolCooldownCap", 45f, "Largest percentage the Idol Usage tree may cut from a guardian power's cooldown. Capped short of free on purpose: a power you can hold up permanently stops being a moment and becomes a passive.");
			DualWieldCadence = Synced(cfg, "Combat", "DualWieldCadence", 3, "Every Nth blow lands an offhand strike on top of the passive share. Lower is more frequent and more damage.");
			FavouriteTrees = cfg.Bind<string>("Interface", "FavouriteTrees", "", "Tree keys pinned to the front of the rail, comma separated. Right-click a tab to pin it. A pinned tree appears at the front AND stays where it was, so learning where something lives still pays off.");
			RailScrollSpeed = cfg.Bind<float>("Interface", "RailScrollSpeed", 2600f, "How hard one notch of the wheel throws the skill rail. The old value was roughly 160 and it was a crawl on a long rail.");
			RailGlide = cfg.Bind<float>("Interface", "RailGlide", 0.16f, "How long the rail keeps sliding after you let go, 0 to 0.5. This is Unity's deceleration rate: it is the fraction of speed KEPT each second, so higher is a longer skid. Set 0 to stop dead.");
			BrawlerSpareHotbar = cfg.Bind<bool>("Tavern Brawler", "SpareHotbar", true, "Leave everything on the hotbar row alone when cycling. Valheim has no inventory favourites to read, and the hotbar is where people keep the things they do not want thrown. Pointing at an item with the mouse overrides this - an explicit gesture is not second-guessed.");
			BrawlerFavouriteKeys = cfg.Bind<string>("Tavern Brawler", "FavouriteKeys", "favorit,favourit,lock,pin,quickslot", "Comma-separated fragments. An item is left alone if any key in its custom data contains one of these. Mods that add item favouriting store their flag there, and this mod cannot know which key yours uses - so if yours is missed, add its key name here.");
			PieBaseItem = Synced(cfg, "Content", "PieBaseItem", "QueensJam", "Which existing food every generated pie is cloned from. It supplies the mesh, the icon and the eating animation; the food values are overwritten per pie.");
			PieStation = Synced(cfg, "Content", "PieStation", "nsg_pie_counter", "Which buildable's crafting station pies are made at. Defaults to this mod's own Pie Counter - forty pies on the base cauldron is a menu you scroll past to find the soup. Set it to piece_cauldron to put them back.");
			SmokingEnabled = Synced(cfg, "Content", "Smoking", value: true, "Smoke Hooks and Nordic Steel. A hook is a cheap two-by-two station: hang meat in the top row, take jerky from the bottom, half an hour later. Jerky is generated for every meat this modlist has rather than a fixed list, so a mod that adds a meat gets jerky for it. Nordic Steel is bones and iron, and is what the top station tier is named after.");
			StationsEnabled = Synced(cfg, "Content", "Stations", value: true, "The six automation buildings - Cooking Chute, Cauldron Sloop, Mead Masher, Hydroponics, Fish Farm and Animal Hovel - in Stone, Bronze, Iron and Nordic Steel. Each is one Container split top-to-bottom: put inputs in the upper rows, take outputs from the lower ones. Tiers scale OUTPUT, never speed. They keep working while you are away and pay their experience to whoever built them the next time that person is standing there.");
			PantryEnabled = Synced(cfg, "Content", "Pantry", value: true, "What the crops turn into: Wheat Flour and Bread, Sugar, Pearl Oil, and the Red and Gore brews. Flour and bread are MILLED and BAKED rather than crafted - you load a windmill or an oven and walk away - and the brews ferment in a barrel like mead, which is also what keeps them compatible with Drunken Fist. Needs Crops on for the chains that start at a crop.");
			ArsenalEnabled = Synced(cfg, "Content", "Arsenal", value: true, "The cooking arsenal: Salami, Baguette, Carving Fork, Chainmail Apron, Chainmail Spaghetti and Clown Boots. Cloned from vanilla weapons and armour, so they arrive already animated and balanced; three of them are also food. Swinging any of them trains Cooking rather than Brawler, which is what the Chef Paladin archetype has been waiting for.");
			CropsEnabled = Synced(cfg, "Content", "Crops", value: true, "Eight new crops - Wheat, Sugar Cane, Beet, Cucumber, Cabbage, Pearl, Eggplant and Boar Vine - each planted with the cultivator and grown into a harvest. They wear vanilla plants' art, recoloured and rescaled, so they cost no new models. Turning this off stops them being created; it does not remove ones already planted in a world, which go dormant and come back if you turn it on again.");
			WildCropsEnabled = Synced(cfg, "Content", "WildCrops", value: true, "Whether the new crops also grow on their own. They are added to world generation, which decides vegetation once per zone when that land is first created - so they appear in ground generated from here on, including land you walk into during a session, and never rewrite ground you have already explored. Needs Crops on.");
			BakeryEnabled = Synced(cfg, "Content", "Bakery", value: false, "The prefab test. Adds a Bakery Counter buildable costing one Wood, and a Raspberry Pie made from one Raspberry at it. Both are clones of things the game already ships - it is not meant to be good, it is meant to prove this mod can create a prefab at all, which nothing else in the content plan can proceed without. Single player first.");
			BakeryCounterSource = Synced(cfg, "Content", "BakeryCounterSource", "piece_cauldron", "Which existing buildable the Bakery Counter is cloned from. It needs a Piece and a CraftingStation on it.");
			BakeryPieSource = Synced(cfg, "Content", "BakeryPieSource", "QueensJam", "Which existing item the Raspberry Pie is cloned from. Any food works.");
			BakeryCounterCost = Synced(cfg, "Content", "BakeryCounterCost", "Wood", "What one of builds the counter.");
			BakeryPieCost = Synced(cfg, "Content", "BakeryPieCost", "Raspberry", "What one of makes a pie.");
			PiesEnabled = Synced(cfg, "Content", "Pies", value: false, "Bake the generated pies as real items. OFF by default, and that is deliberate: everything else in this mod changes numbers on things the game already has, while this creates new item prefabs - the one kind of change that can leave a mark on a save. Turn it on in single player first, with somebody watching. nsg.pies shows what it would make without baking anything.");
			PieMeats = Synced(cfg, "Content", "PieMeats", "Meat,Fish,Serpent,Chicken,Bacon,Ham,Sausage,Lox,Neck,Boar,Deer,Wolf,Hare", "Name fragments that count as the meat half of a pie. Matched against prefab names, so anything a mod adds joins in without a rebuild.");
			PieVegetables = Synced(cfg, "Content", "PieVegetables", "Carrot,Turnip,Onion,Mushroom,Barley,Flax,Berries,Raspberry,Blueberry,Cloudberry,Dandelion,Thistle,Magecap,Jotun,Seed", "Name fragments that count as the other half. Same matching as PieMeats.");
			PieLimit = Synced(cfg, "Content", "PieLimit", 40, "How many pies to keep. Crossing everything with everything runs past a hundred and fifty, and a player scrolling a cauldron full of near-identical pies is worse off than one with forty good ones. The best are kept, not the first found.");
			Utensils = Synced(cfg, "Content", "Utensils", "fork,ladle,spoon,pan,pot,skewer,rolling pin,cleaver,baguette,salami,pie,apron", "Comma-separated name fragments that count as kitchen gear. Swinging one trains Cooking instead of Tavern Brawler, which is what makes the Chef Paladin a discipline rather than a joke about being drunk. Food needs no list - the game already marks it - so this is only for the things you cook WITH. Add new items here the moment they are installed; no rebuild.");
			Intoxicants = Synced(cfg, "Content", "Intoxicants", "mead,ale,wine,tar,drunk,brew", "Comma-separated name fragments that count as being drunk, for Drunken Fist and anything else gated on 'intoxicated'. Valheim has no drunk state and no flag marking a consumable as alcohol - meads are ordinary food with ordinary status effects - so this is a list of names, matched case-insensitively against active status effects. Add a modded mead's status effect name here and it works immediately.");
			DatabaseFingerprint = Synced(cfg, "Content", "DatabaseFingerprint", "", "Set automatically. The server's copy of this is pushed to everyone and compared against their own perks.json; a mismatch means somebody is playing with different numbers. Do not edit it by hand - it is recomputed from the database every load.");
			GenerateStubTrees = Synced(cfg, "Content", "GenerateStubTrees", value: true, "Build a generic 12-node tree for any skill registered by another mod that has no authored tree of its own.");
			UiScale = cfg.Bind<float>("UI", "Scale", 1.35f, new ConfigDescription("Scales the whole perk panel. The panel lays itself out in virtual pixels and then scales up, so 2.0 gives genuinely larger text rather than the same text with more padding. 1.35 is a sensible floor on 4K.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.8f, 2.5f), Array.Empty<object>()));
			HideUnlearnedSkills = cfg.Bind<bool>("UI", "HideUnlearnedSkills", true, "Hide a skill's tree until the skill has been levelled at least once. A sector tree shows as soon as any of its members has been levelled. Nothing is lost by hiding - the high-water mark still tracks - and the rail goes from 33 entries to the handful you actually play.");
			TreeZoom = cfg.Bind<float>("UI", "TreeZoom", 1.35f, new ConfigDescription("Starting zoom for the tree canvas. The view opens centred on where you left it, or on your deepest perk, rather than fitting the whole lattice into the window at unreadable size.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.45f, 2.5f), Array.Empty<object>()));
			Verbose = cfg.Bind<bool>("Debug", "Verbose", false, "Log every point grant, purchase and refund.");
		}

		internal static bool IsIntoxicantName(string name)
		{
			return MatchesFragment(name, Intoxicants?.Value);
		}

		internal static bool MatchesFragment(string name, string fragments)
		{
			if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(fragments))
			{
				return false;
			}
			string[] array = fragments.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length != 0 && name.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		internal static string[] IntoxicantNames()
		{
			string text = ((Intoxicants != null) ? Intoxicants.Value : string.Empty);
			if (_intoxicantCache != null && _intoxicantRaw == text)
			{
				return _intoxicantCache;
			}
			_intoxicantRaw = text;
			string[] array = (text ?? string.Empty).Split(',');
			List<string> list = new List<string>(array.Length);
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string text2 = array2[i].Trim();
				if (text2.Length > 0)
				{
					list.Add(text2);
				}
			}
			_intoxicantCache = list.ToArray();
			return _intoxicantCache;
		}

		private static ConfigEntry<T> Synced<T>(ConfigFile cfg, string section, string key, T value, string description)
		{
			return cfg.Bind<T>(section, key, value, description);
		}
	}
}
namespace Norntastic.Commands
{
	internal sealed class ArsenalCommand : ConsoleCommand
	{
		public override string Name => "nsg.arsenal";

		public override string Help => "The cooking arsenal: what was built, and what each piece was cloned from.";

		public override void Run(string[] args)
		{
			Output.Print("--- Norntastic arsenal ---");
			if (SafeMode.Active)
			{
				Output.Print("  SAFE MODE - nothing was made. Reasons:");
				{
					foreach (string item in SafeMode.Why)
					{
						Output.Print("    " + item);
					}
					return;
				}
			}
			Output.Print("  " + Arsenal.BuiltCount + " of " + ArsenalLibrary.All.Count + " piece(s) built.");
			foreach (ArsenalDef item2 in ArsenalLibrary.All)
			{
				if (Arsenal.RefusedKeys.TryGetValue(item2.Key, out var value))
				{
					Output.Print($"  {item2.Display,-22} NO    needs a prefab named " + "'" + value + "', which this install does not have");
				}
				else if (!PrefabForge.Has(item2.Name))
				{
					Output.Print($"  {item2.Display,-22} -     not built yet - run this in a world");
				}
				else
				{
					Output.Print($"  {item2.Display,-22} ok    from {item2.Source}, {Trains(item2)}");
				}
			}
			Output.Print("  boots      " + (ClownBoots.Available ? (ClownBoots.Drawn + " creature(s) drawn by the squeak this session") : "OFF - MonsterAI moved; they are still armour and still help allies"));
			Output.Print("  The donor names above are Unity assets and are the one part of this nothing offline can check. A 'NO' is one config line.");
		}

		private static string Trains(ArsenalDef def)
		{
			if (!(def.Blunt > 0f) && !(def.Slash > 0f) && !(def.Pierce > 0f))
			{
				return "worn, not swung";
			}
			if (!def.IsEdible)
			{
				return "trains Cooking (name is on the utensil list)";
			}
			return "trains Cooking (it is food)";
		}
	}
	internal sealed class BakeryCommand : ConsoleCommand
	{
		public override string Name => "nsg.bakery";

		public override string Help => "Prefab test readout: did the counter and the pie get made, registered and listed.";

		public override void Run(string[] args)
		{
			Output.Print("--- Norntastic bakery test ---");
			if (ModConfig.BakeryEnabled == null || !ModConfig.BakeryEnabled.Value)
			{
				Output.Print("  OFF. Set Content.Bakery = true and restart.");
				return;
			}
			if (SafeMode.Active)
			{
				Output.Print("  SAFE MODE - nothing was registered. Reasons:");
				{
					foreach (string item in SafeMode.Why)
					{
						Output.Print("    " + item);
					}
					return;
				}
			}
			ZNetScene instance = ZNetScene.instance;
			ObjectDB instance2 = ObjectDB.instance;
			Output.Print("  1. clone sources");
			Output.Print("     counter from '" + (ModConfig.BakeryCounterSource?.Value ?? "?") + "'   " + Found((Object)(object)instance != (Object)null && (Object)(object)instance.GetPrefab(ModConfig.BakeryCounterSource?.Value ?? "") != (Object)null));
			Output.Print("     pie from     '" + (ModConfig.BakeryPieSource?.Value ?? "?") + "'   " + Found((Object)(object)instance2 != (Object)null && (Object)(object)instance2.GetItemPrefab(ModConfig.BakeryPieSource?.Value ?? "") != (Object)null));
			Output.Print("  2. registration");
			GameObject val = (((Object)(object)instance == (Object)null) ? null : instance.GetPrefab("nsg_bakery_counter"));
			GameObject val2 = (((Object)(object)instance == (Object)null) ? null : instance.GetPrefab("nsg_raspberry_pie"));
			Output.Print("     ZNetScene knows nsg_bakery_counter   " + Found((Object)(object)val != (Object)null));
			Output.Print("     ZNetScene knows nsg_raspberry_pie    " + Found((Object)(object)val2 != (Object)null));
			Output.Print("     ObjectDB knows  nsg_raspberry_pie    " + Found((Object)(object)instance2 != (Object)null && (Object)(object)instance2.GetItemPrefab("nsg_raspberry_pie") != (Object)null));
			Output.Print("  3. reachable");
			GameObject val3 = (((Object)(object)instance2 == (Object)null) ? null : instance2.GetItemPrefab("Hammer"));
			ItemDrop val4 = (((Object)(object)val3 == (Object)null) ? null : val3.GetComponent<ItemDrop>());
			PieceTable val5 = (((Object)(object)val4 == (Object)null || val4.m_itemData == null || val4.m_itemData.m_shared == null) ? null : val4.m_itemData.m_shared.m_buildPieces);
			Output.Print("     on the hammer                " + Found((Object)(object)val5 != (Object)null && (Object)(object)val != (Object)null && val5.m_pieces.Contains(val)));
			List<Recipe> list = (((Object)(object)instance2 == (Object)null) ? null : instance2.m_recipes);
			bool ok = false;
			if (list != null)
			{
				foreach (Recipe item2 in list)
				{
					if ((Object)(object)item2 != (Object)null && (Object)(object)item2.m_item != (Object)null && (Object)(object)((Component)item2.m_item).gameObject == (Object)(object)val2)
					{
						ok = true;
					}
				}
			}
			Output.Print("     recipe in the database       " + Found(ok));
			if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
			{
				Output.Print("  Prefab creation works. Build the counter, stand at it, craft a pie.");
			}
			else
			{
				Output.Print("  Prefab creation did NOT work. The first line above that says no is why.");
			}
		}

		private static string Found(bool ok)
		{
			if (!ok)
			{
				return "NO";
			}
			return "yes";
		}
	}
	internal sealed class CheckCommand : ConsoleCommand
	{
		private static readonly EffectKind[] YieldKinds = new EffectKind[4]
		{
			EffectKind.YieldTreePct,
			EffectKind.YieldOrePct,
			EffectKind.YieldForagePct,
			EffectKind.YieldKillPct
		};

		private static readonly EffectKind[] FlightKinds = new EffectKind[4]
		{
			EffectKind.ProjectileDamagePct,
			EffectKind.ProjectileSpeedPct,
			EffectKind.ProjectileDropPct,
			EffectKind.ProjectilePiercePct
		};

		private const string LineFormat = "  {0,-10} {1,-6}{2,5}{3,6}   {4}";

		public override string Name => "nsg.check";

		public override string Help => "The first-run checklist: which subsystems are armed, and which have fired.";

		public override void Run(string[] args)
		{
			Output.Print("--- Norntastic check ---");
			string mine = DatabaseGuard.Mine;
			string text = ModConfig.DatabaseFingerprint?.Value;
			if (string.IsNullOrEmpty(text) || text == mine)
			{
				Output.Print("  database   OK      " + DatabaseGuard.Describe(mine));
			}
			else
			{
				Output.Print("  database   MISMATCH server has " + DatabaseGuard.Describe(text) + ", you have " + DatabaseGuard.Describe(mine) + " - see nsg.fingerprint");
			}
			Output.Print(DualWieldEquip.Available ? "  dualwield  armed" : "  dualwield  OFF     it could not find what it needed and disabled itself");
			Output.Print(Durability.Available ? "  durability armed" : "  durability OFF     Valheim's drain methods changed shape");
			Output.Print(ArmourPen.Available ? "  armourpen  armed" : "  armourpen  OFF     HitData.ApplyArmor changed shape");
			Output.Print(HarvestDamage.Available ? "  harvest    armed" : "  harvest    OFF     a Damage method changed shape");
			Output.Print(StationReach.Available ? "  stations   armed" : "  stations   OFF     CraftingStation's range statics changed shape");
			Output.Print(CraftRefund.Available ? ("  refunds    armed   " + CraftRefund.Refunded + " material(s) back") : "  refunds    OFF     Player.ConsumeResources changed shape");
			Output.Print(Awareness.Available ? ("  awareness  armed   " + Awareness.Shed + " pursuer(s) shed") : "  awareness  OFF     MonsterAI.SetTarget moved");
			Output.Print(Guard.ParryWindowAvailable ? "  parry      armed" : "  parry      OFF     window widening disabled itself; other block perks fine");
			int num = 0;
			int num2 = 0;
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				foreach (PerkNode node in value.Nodes)
				{
					num++;
					if (node.Effects != null)
					{
						num2 += node.Effects.Count;
					}
				}
			}
			Output.Print((PerkDatabase.Trees.Count > 0) ? $"  database   {PerkDatabase.Trees.Count} tree(s), {num} node(s), {num2} effect clause(s)" : "  database   EMPTY - no trees loaded, so every line below is meaningless. This is the fault, not the subsystems.");
			Output.Print(string.Format("  {0,-10} {1,-6}{2,5}{3,6}   {4}", "", "state", "ship", "yours", "evidence"));
			Report("triggers", TriggerRuntime.TriggeredPerkCount, LiveTriggers(), TriggerCount(), "chop a tree, land a parry, tap a fermenter");
			Report("splash", Splash.ClauseCount, Splash.LiveCount, Splash.HitsThisSession, "hit something with a crowd behind it");
			Report("afflict", Afflictions.ClauseCount, Afflictions.LiveCount, Afflictions.AppliedThisSession, "land a knife hit with Venom Work");
			Report("yields", YieldClauses(), LiveYields(), Yields.GrantedThisSession, "mine a vein with Rich Seam");
			Report("flight", FlightClauses(), LiveFlight(), Projectiles.ShotsShapedThisSession, "loose an arrow with Long Shot");
			int count = EmoteLibrary.All.Count;
			int performedThisSession = Norntastic.Emotes.Emotes.PerformedThisSession;
			Output.Print(string.Format("  {0,-10} {1,-6}{2,5}{3,6}   {4}", "emotes", (performedThisSession > 0) ? "done" : "quiet", count, "-", (performedThisSession > 0) ? (performedThisSession + " performed this session") : "none yet - try nsg.emote rawr"));
			Output.Print(Pies.Scanned ? ($"  pies       {Pies.Count,3}  planned from this " + "modlist's ingredients - nsg.pies to see them") : "  pies       larder not read yet - run this in a world");
			int num3 = Afflictions.UnresolvedCount();
			if (num3 > 0)
			{
				Output.Print($"  effects    {num3} affliction clause(s) name a status effect " + "this game does not have. Run nsg.effects and fix the name in perks.json.");
			}
			Output.Print("Only ABSENT is a fault. 'unused' means you have not bought a perk that uses it; 'quiet' means you have and have not used it yet. 'ship' is what the mod declares, 'yours' is what this character has taken.");
		}

		private static int TriggerCount()
		{
			int num = 0;
			foreach (KeyValuePair<TriggerKind, int> item in TriggerBus.Observed)
			{
				if (item.Value > 0)
				{
					num++;
				}
			}
			return num;
		}

		private static int LiveTriggers()
		{
			PerkState current = PerkState.Current;
			if (current == null)
			{
				return 0;
			}
			int num = 0;
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				foreach (PerkNode node in value.Nodes)
				{
					if (node.Effects == null || current.GetRank(node.Id) <= 0)
					{
						continue;
					}
					foreach (EffectSpec effect in node.Effects)
					{
						if (!effect.IsPending && effect.HasTrigger)
						{
							num++;
							break;
						}
					}
				}
			}
			return num;
		}

		private static int YieldClauses()
		{
			return ClausesNaming(YieldKinds);
		}

		private static int FlightClauses()
		{
			return ClausesNaming(FlightKinds);
		}

		private static int LiveYields()
		{
			return KindsInPlay(YieldKinds);
		}

		private static int LiveFlight()
		{
			return KindsInPlay(FlightKinds);
		}

		private static int ClausesNaming(EffectKind[] kinds)
		{
			int num = 0;
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				foreach (PerkNode node in value.Nodes)
				{
					if (node.Effects == null)
					{
						continue;
					}
					foreach (EffectSpec effect in node.Effects)
					{
						if (effect.IsPending)
						{
							continue;
						}
						for (int i = 0; i < kinds.Length; i++)
						{
							if (effect.Kind == kinds[i])
							{
								num++;
								break;
							}
						}
					}
				}
			}
			return num;
		}

		private static int KindsInPlay(EffectKind[] kinds)
		{
			int num = 0;
			for (int i = 0; i < kinds.Length; i++)
			{
				if (EffectAggregator.Pct(kinds[i]) != 0f)
				{
					num++;
				}
			}
			return num;
		}

		private static void Report(string label, int armed, int live, int fired, string how)
		{
			if (fired > 0)
			{
				Output.Print(string.Format("  {0,-10} {1,-6}{2,5}{3,6}   {4}", label, "FIRED", armed, live, fired + " so far"));
			}
			else if (armed <= 0)
			{
				Output.Print(string.Format("  {0,-10} {1,-6}{2,5}{3,6}   {4}", label, "ABSENT", armed, live, "this database declares no clauses for it - that is a fault in the mod, not in your save"));
			}
			else if (live <= 0)
			{
				Output.Print(string.Format("  {0,-10} {1,-6}{2,5}{3,6}   {4}", label, "unused", armed, live, "working, but you have taken no perk that uses it - buy one and this goes quiet, then FIRED"));
			}
			else
			{
				Output.Print(string.Format("  {0,-10} {1,-6}{2,5}{3,6}   {4}", label, "quiet", armed, live, "not seen yet - " + how));
			}
		}
	}
	internal sealed class CropCommand : ConsoleCommand
	{
		public override string Name => "nsg.crops";

		public override string Help => "Which crops were built, and which vanilla plants they needed.";

		public override void Run(string[] args)
		{
			Output.Print("--- Norntastic crops ---");
			if (SafeMode.Active)
			{
				Output.Print("  SAFE MODE - no crops were made. Reasons:");
				{
					foreach (string item in SafeMode.Why)
					{
						Output.Print("    " + item);
					}
					return;
				}
			}
			int builtCount = Crops.BuiltCount;
			int count = CropLibrary.All.Count;
			Output.Print("  " + builtCount + " of " + count + " crop(s) built.");
			foreach (CropDef item2 in CropLibrary.All)
			{
				if (Crops.RefusedKeys.TryGetValue(item2.Key, out var value))
				{
					Output.Print($"  {item2.Display,-12} NO     needs a prefab named " + "'" + value + "', which this install does not have");
				}
				else
				{
					Output.Print(PrefabForge.Has(item2.ItemName) ? $"  {item2.Display,-12} ok     {Chain(item2)}" : $"  {item2.Display,-12} -      not built yet - run this in a world");
				}
			}
			Output.Print("  wild       " + ((!Sow.Available) ? "OFF - the vegetation table changed shape; planting still works" : ((!Sow.Ran) ? "not asked for yet - world generation has not built a new zone since you loaded. Walk somewhere you have never been and run this again." : (Sow.Sown + " sown into world generation"))));
			Output.Print("  The plant names above are Unity assets and are the only part of this nothing offline can check. A 'NO' is one line in the config.");
		}

		private static string Chain(CropDef crop)
		{
			string text = (crop.SelfSeeding ? "replants itself" : ("seeds from " + crop.SeedSource));
			return crop.SaplingSource + " -> " + crop.PickableSource + ", " + text;
		}
	}
	internal sealed class ForgeCommand : ConsoleCommand
	{
		public override string Name => "nsg.forge";

		public override string Help => "Every prefab this mod created, and any it used to create and no longer does.";

		public override void Run(string[] args)
		{
			Output.Print("--- Norntastic forge ---");
			if (SafeMode.Active)
			{
				Output.Print("  SAFE MODE - nothing was forged. Reasons:");
				{
					foreach (string item in SafeMode.Why)
					{
						Output.Print("    " + item);
					}
					return;
				}
			}
			Output.Print("  " + PrefabForge.Count + " prefab(s) made this session.");
			int num = 0;
			foreach (GameObject allItem in PrefabForge.AllItems)
			{
				_ = allItem;
				num++;
			}
			int num2 = 0;
			foreach (Recipe allRecipe in PrefabForge.AllRecipes)
			{
				_ = allRecipe;
				num2++;
			}
			Output.Print("    items    " + num);
			foreach (string pieceTool in PrefabForge.PieceTools)
			{
				int num3 = 0;
				foreach (GameObject item2 in PrefabForge.PiecesFor(pieceTool))
				{
					_ = item2;
					num3++;
				}
				Output.Print("    pieces   " + num3 + " on the " + pieceTool.ToLowerInvariant());
			}
			Output.Print("    recipes  " + num2);
			if (args != null && args.Length > 1 && args[1].Equals("all", StringComparison.OrdinalIgnoreCase))
			{
				foreach (string name in PrefabForge.Names)
				{
					Output.Print("      " + name);
				}
			}
			else if (PrefabForge.Count > 0)
			{
				Output.Print("    (nsg.forge all to list them)");
			}
			if (DerivedSeal.Missing.Count == 0)
			{
				Output.Print("  Nothing this install has made before has stopped being made.");
				return;
			}
			Output.Print("  " + DerivedSeal.Missing.Count + " prefab(s) this install has made before are NOT being made now:");
			foreach (string item3 in DerivedSeal.Missing)
			{
				Output.Print("    " + item3);
			}
			Output.Print("  Anything built from these in the world is dormant, not destroyed, and");
			Output.Print("  comes back if whatever they were derived from comes back. Items sitting");
			Output.Print("  in inventories and chests are the exception and do not survive a save.");
		}
	}
	internal sealed class StatusCommand : ConsoleCommand
	{
		public override string Name => "nsg.status";

		public override string Help => "Perk points earned, spent and open across every tree.";

		public override void Run(string[] args)
		{
			PerkState current = PerkState.Current;
			if (!current.Ready)
			{
				Output.Print("No character loaded yet.");
				return;
			}
			Output.Print($"--- Norntastic Skill Growth --- {PointMath.CombinedLevels(current):0} combined " + $"skill levels / {PerkDatabase.PointInterval} = {PointMath.Earned(current)} points, " + $"{PointMath.Spent(current)} spent, " + $"<{PointMath.Available(current)} to spend anywhere>, " + $"{current.RespecPoints} respec point(s). " + $"{PointMath.ToNextPoint(current):0} levels to the next point.");
			TreeKind[] array = new TreeKind[4]
			{
				TreeKind.Skill,
				TreeKind.New,
				TreeKind.Sector,
				TreeKind.Stub
			};
			foreach (TreeKind treeKind in array)
			{
				List<string> list = new List<string>();
				foreach (PerkTree value in PerkDatabase.Trees.Values)
				{
					if (value.Kind == treeKind)
					{
						int num = PointMath.SpentIn(current, value);
						int prestige = current.GetPrestige(value.Key);
						if (num != 0 || prestige != 0)
						{
							list.Add($"  {value.Name,-18} {num,3} spent" + ((prestige > 0) ? $"   prestige {prestige}" : ""));
						}
					}
				}
				if (list.Count == 0)
				{
					continue;
				}
				Output.Print($"[{treeKind}]");
				foreach (string item in list)
				{
					Output.Print(item);
				}
			}
		}
	}
	internal sealed class TreesCommand : ConsoleCommand
	{
		public override string Name => "nsg.trees";

		public override string Help => "List every tree key, kind and size.";

		public override void Run(string[] args)
		{
			PerkState current = PerkState.Current;
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				string arg = (value.IsSector ? ("  members: " + string.Join(",", value.Members)) : "");
				Output.Print($"{value.Key,-14} {value.Kind,-7} {value.Nodes.Count,2} nodes / " + $"{value.TotalRanks,2} ranks  " + $"{TreeVisibility.Describe(value, current),-26} {value.Name}{arg}");
			}
		}
	}
	internal static class TreeVisibility
	{
		internal static string Describe(PerkTree tree, PerkState state)
		{
			if (SkillRail.Visible(tree, state))
			{
				if (!tree.AlwaysShown)
				{
					return "shown";
				}
				return "shown (always)";
			}
			if (tree.IsForeign)
			{
				return "hidden: mod not installed";
			}
			if (tree.IsSector)
			{
				return "hidden: no member levelled";
			}
			if (tree.RidesAnotherSkill)
			{
				return "hidden: needs " + tree.RidesKey;
			}
			if (tree.RevealWith.Count > 0)
			{
				return "hidden: needs " + string.Join("/", tree.RevealWith.ToArray());
			}
			return "hidden: needs " + tree.Key;
		}
	}
	internal sealed class TreeCommand : ConsoleCommand
	{
		public override string Name => "nsg.tree";

		public override string Help => "nsg.tree <key> - every node in a tree with its current state.";

		public override void Run(string[] args)
		{
			if (args.Length < 1)
			{
				Output.Print(((ConsoleCommand)this).Help);
				return;
			}
			PerkTree perkTree = PerkDatabase.Tree(args[0]);
			if (perkTree == null)
			{
				Output.Print("No tree '" + args[0] + "'. Try nsg.trees.");
				return;
			}
			PerkState current = PerkState.Current;
			Output.Print($"--- {perkTree.Name} --- level {PointMath.LevelFor(current, perkTree):0}, " + $"{PointMath.SpentIn(current, perkTree)} spent here, " + $"{PointMath.Available(current)} available from the shared pool");
			foreach (PerkNode node in perkTree.Nodes)
			{
				int rank = current.GetRank(node.Id);
				string reason;
				PointMath.Gate gate = PointMath.CanBuy(current, node, out reason);
				string text = ((rank < node.MaxRank) ? ((rank <= 0) ? ((gate != PointMath.Gate.Ok) ? "[ -- ]" : "[open]") : ("[ " + rank + "  ]")) : "[MAX]");
				string arg = ((rank > 0 && PointMath.LevelFor(current, perkTree) < (float)node.RequiresLevel) ? "  (held below requirement, still applying)" : "");
				Output.Print($" {text} {node.Id,-12} lv{node.RequiresLevel,3}  {node.Name} " + $"({rank}/{node.MaxRank}){arg}");
			}
		}
	}
	internal sealed class TriggersCommand : ConsoleCommand
	{
		public override string Name => "nsg.triggers";

		public override string Help => "Which trigger hooks have fired this session, and how long ago.";

		public override void Run(string[] args)
		{
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			foreach (TriggerKind value in Enum.GetValues(typeof(TriggerKind)))
			{
				int num = TriggerBus.CountOf(value);
				if (num == 0)
				{
					list2.Add(value.ToString());
					continue;
				}
				float num2 = TriggerBus.SecondsSince(value);
				list.Add($"  {value,-14} {num,4}x   last {num2:0.0}s ago");
			}
			if (list.Count == 0)
			{
				Output.Print("Nothing has fired yet. Chop a tree, land a parry, tap a fermenter.");
			}
			else
			{
				Output.Print($"--- fired this session --- {list.Count} of " + $"{list.Count + list2.Count} trigger kinds");
				foreach (string item in list)
				{
					Output.Print(item);
				}
			}
			if (list2.Count > 0)
			{
				Output.Print("silent: " + string.Join(", ", list2.ToArray()));
			}
			Output.Print("yield bonus items granted this session: " + $"{Yields.GrantedThisSession}");
			Output.Print("status effects applied to targets this session: " + $"{Afflictions.AppliedThisSession} " + $"({Afflictions.LiveCount} clause(s) yours, " + $"{Afflictions.ClauseCount} shipped)");
			Output.Print("shots shaped in flight this session: " + $"{Projectiles.ShotsShapedThisSession}");
			Output.Print("splash hits thrown this session: " + $"{Splash.HitsThisSession} " + $"({Splash.LiveCount} clause(s) yours, " + $"{Splash.ClauseCount} shipped)");
		}
	}
	internal sealed class PatchesCommand : ConsoleCommand
	{
		private const int ConsoleLineCap = 60;

		public override string Name => "nsg.patches";

		public override string Help => "nsg.patches [text] - which mods have patched which methods. Filter by method or GUID.";

		public override void Run(string[] args)
		{
			string filter = ((args != null && args.Length != 0) ? args[0] : null);
			List<string> list = PatchMap.Report("dafini.norntastic", filter);
			int num = 0;
			foreach (string item in list)
			{
				if (num >= 60)
				{
					Output.Print($"... {list.Count - num} more line(s). " + "The full map is in config/Norntastic/patchmap.txt, or narrow it: nsg.patches <text>.");
					break;
				}
				Output.Print(item);
				num++;
			}
		}
	}
	internal sealed class EffectsCommand : ConsoleCommand
	{
		public override string Name => "nsg.effects";

		public override string Help => "nsg.effects [text] - every status effect name this game has, for perks.json.";

		public override void Run(string[] args)
		{
			List<string> list = Afflictions.KnownNames();
			if (list.Count == 0)
			{
				Output.Print("No status effects visible. ObjectDB is not loaded yet - run this in a world rather than at the main menu.");
				return;
			}
			string text = (PieCounter.Built ? "Pie Counter - build one to make any of these" : "NOT BUILT - no pie is craftable until the Pie Counter exists");
			Output.Print("  made at    " + text);
			string text2 = ((args != null && args.Length != 0) ? args[0].ToLowerInvariant() : null);
			int num = 0;
			foreach (string item in list)
			{
				if (text2 == null || item.ToLowerInvariant().IndexOf(text2) >= 0)
				{
					Output.Print("  " + item);
					num++;
				}
			}
			Output.Print((text2 == null) ? ($"{list.Count} status effect(s). Use any of these names in an " + "\"applies\" clause in perks.json.") : $"{num} of {list.Count} match '{text2}'.");
		}
	}
	internal sealed class FingerprintCommand : ConsoleCommand
	{
		public override string Name => "nsg.fingerprint";

		public override string Help => "Which perk database this client has, and whether it matches the server's.";

		public override void Run(string[] args)
		{
			string mine = DatabaseGuard.Mine;
			string text = ModConfig.DatabaseFingerprint?.Value;
			Output.Print("yours:  " + DatabaseGuard.Describe(mine));
			if (string.IsNullOrEmpty(text))
			{
				Output.Print("server: nothing received. Either you are playing alone, or the server has not pushed its config yet.");
				return;
			}
			Output.Print("server: " + DatabaseGuard.Describe(text));
			Output.Print((text == mine) ? "These agree. Everyone is playing the same perks." : "These DISAGREE. Your perks do not do what the server's owner thinks they do. Copy their config/Norntastic/perks.json over yours, then run nsg.reload.");
		}
	}
	internal sealed class EmoteShortCommand : ConsoleCommand
	{
		private readonly EmoteDef _emote;

		public override string Name => _emote.Name;

		public override string Help => _emote.Blurb;

		internal EmoteShortCommand(EmoteDef emote)
		{
			_emote = emote;
		}

		public override void Run(string[] args)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !Norntastic.Emotes.Emotes.Perform(localPlayer, _emote))
			{
				Output.Print("Not right now - mid-swing, sitting, or in the air.");
			}
		}
	}
	internal sealed class EmoteCommand : ConsoleCommand
	{
		public override string Name => "nsg.emote";

		public override string Help => "nsg.emote <name> [animation] - perform an emote. No name lists them.";

		public override void Run(string[] args)
		{
			if (args == null || args.Length == 0)
			{
				Output.Print("--- emotes ---");
				foreach (EmoteDef item in EmoteLibrary.All)
				{
					Output.Print($"  {item.Name,-10} {item.Blurb}  " + $"(rides '{item.RidesAnimation}', heard {item.Range:0}m away)");
				}
				Output.Print("Sound files live beside perks.json. Replace one to change the noise; they are never overwritten.");
				return;
			}
			EmoteDef emoteDef = EmoteLibrary.Find(args[0]);
			if (emoteDef == null)
			{
				Output.Print("No emote called '" + args[0] + "'. Run nsg.emote with no name for the list.");
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				Output.Print("No character loaded.");
				return;
			}
			string ridesAnimation = emoteDef.RidesAnimation;
			if (args.Length > 1)
			{
				emoteDef.RidesAnimation = args[1];
			}
			if (!Norntastic.Emotes.Emotes.Perform(localPlayer, emoteDef))
			{
				Output.Print("The game refused '" + emoteDef.RidesAnimation + "'. Either you are mid-swing, sitting or in the air - or that is not an emote this build has.");
				Output.Print("Names known to be real: " + string.Join(", ", EmoteLibrary.KnownVanilla));
				Output.Print("Try: nsg.emote " + emoteDef.Name + " cheer");
			}
			emoteDef.RidesAnimation = ridesAnimation;
		}
	}
	internal sealed class PiesCommand : ConsoleCommand
	{
		public override string Name => "nsg.pies";

		public override string Help => "nsg.pies [text] - every pie the installed game's ingredients would make.";

		public override void Run(string[] args)
		{
			if (!Pies.Scanned)
			{
				Output.Print("The larder has not been read yet - that happens when the item database loads. Run this in a world rather than at the main menu.");
				return;
			}
			string text = ((args != null && args.Length != 0) ? args[0].ToLowerInvariant() : null);
			int num = 0;
			foreach (PieRecipe recipe in Pies.Recipes)
			{
				if (text == null || recipe.DisplayName.ToLowerInvariant().IndexOf(text) >= 0)
				{
					Output.Print("  " + recipe.Describe());
					num++;
					if (num >= 60)
					{
						Output.Print("  ... narrow it: nsg.pies <text>");
						break;
					}
				}
			}
			int count = Pies.Count;
			bool flag = ModConfig.PiesEnabled != null && ModConfig.PiesEnabled.Value;
			Output.Print($"{count} pie(s) planned from what this modlist has. " + (flag ? "Baking is ON." : "Baking is OFF - these are not real items yet. Turn on Content.Pies to bake them, in single player first."));
		}
	}
	internal sealed class FryerCommand : ConsoleCommand
	{
		public override string Name => "nsg.fryer";

		public override string Help => "nsg.fryer [text] - what the deep fryer would turn each food into. nsg.fryer skipped - what it refused, and why.";

		public override void Run(string[] args)
		{
			if (!Fryer.Planned_)
			{
				Output.Print("The larder has not been read yet - that happens when the item database loads. Run this in a world rather than at the main menu.");
				return;
			}
			Output.Print("--- deep fryer ---");
			Output.Print("  " + Fryer.BuiltCount + " of " + Fryer.Count + " made; the rest are planned only. Build a Deep Fryer Basin to use them.");
			Output.Print("Frying is a trade, not an upgrade: +35% health and stamina, and 30% of the duration gone. Harder and shorter.");
			Output.Print("Eitr passes through untouched - a building made of bones should not be a shortcut to a progression tier.");
			string text = ((args != null && args.Length != 0) ? args[0].ToLowerInvariant() : null);
			if (text == "skipped")
			{
				Output.Print(Fryer.SkippedCount + " food(s) left out:");
				{
					foreach (string item in Fryer.Skipped)
					{
						Output.Print("  " + item);
					}
					return;
				}
			}
			int num = 0;
			foreach (FryResult result in Fryer.Results)
			{
				if (text == null || result.DisplayName.ToLowerInvariant().IndexOf(text, StringComparison.Ordinal) >= 0 || result.SourceName.ToLowerInvariant().IndexOf(text, StringComparison.Ordinal) >= 0)
				{
					Output.Print("  " + result.Describe());
					num++;
				}
			}
			Output.Print(num + " of " + Fryer.Count + " shown. Nothing is built yet - the basin is still station work.");
		}
	}
	internal sealed class MartialCommand : ConsoleCommand
	{
		public override string Name => "nsg.martial";

		public override string Help => "Your grip, your current art, and the animation vocabulary this install has.";

		public override void Run(string[] args)
		{
			Output.Print("--- martial arts ---");
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				Output.Print("  No character loaded.");
				return;
			}
			Grip grip = Grips.Of(localPlayer);
			Output.Print("  grip        " + Grips.Describe(grip));
			Output.Print("  running     " + KataRunner.Describe());
			Output.Print("  vocabulary  " + AnimationVocabulary.KnownTriggers.Length + " literal trigger(s), " + AnimationVocabulary.HarvestedCount + " harvested from items");
			if (AnimationVocabulary.HarvestedCount == 0)
			{
				Output.Print("  NOTE: nothing harvested - the item database had not loaded when this ran. Every beat will fall back to a literal trigger.");
			}
			Output.Print("  arts:");
			foreach (Kata item in KataLibrary.All)
			{
				string text = ((item.Grip == grip) ? " <- yours" : string.Empty);
				Output.Print("    " + item.Name + " (" + Grips.Describe(item.Grip) + ", " + item.Length + " beats" + (string.IsNullOrEmpty(item.RequiresPerk) ? ", free" : (", needs " + item.RequiresPerk)) + ")" + text);
				if (args == null || args.Length < 1 || !args[0].Equals("all", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				foreach (KataStep step in item.Steps)
				{
					Output.Print("        " + step.Describe());
				}
			}
			Output.Print("  abilities:");
			Kata kata = AbilityInput.Selected(localPlayer);
			foreach (Kata item2 in AbilityLibrary.All)
			{
				float num = AbilityInput.Remaining(item2);
				Output.Print("    " + item2.Name + " (" + item2.RequiresPerk + ", " + item2.Cooldown.ToString("0") + "s cd" + ((num > 0f) ? (", " + num.ToString("0.0") + "s left") : string.Empty) + ")" + ((item2 == kata) ? " <- selected" : string.Empty));
			}
			Output.Print("  nsg.martial all to see every beat.");
		}
	}
	internal sealed class BuyCommand : ConsoleCommand
	{
		public override string Name => "nsg.buy";

		public override string Help => "nsg.buy <perkId> - spend a point on one rank.";

		public override void Run(string[] args)
		{
			if (args.Length < 1)
			{
				Output.Print(((ConsoleCommand)this).Help);
				return;
			}
			PerkNode perkNode = PerkDatabase.Node(args[0]);
			if (perkNode == null)
			{
				Output.Print("No perk '" + args[0] + "'.");
			}
			else
			{
				Output.Print(PointMath.TryBuy(PerkState.Current, perkNode, out var message) ? message : ("Blocked: " + message));
			}
		}
	}
	internal sealed class RefundCommand : ConsoleCommand
	{
		public override string Name => "nsg.refund";

		public override string Help => "nsg.refund <perkId> - refund one rank, cascading anything downstream.";

		public override void Run(string[] args)
		{
			if (args.Length < 1)
			{
				Output.Print(((ConsoleCommand)this).Help);
				return;
			}
			PerkNode perkNode = PerkDatabase.Node(args[0]);
			if (perkNode == null)
			{
				Output.Print("No perk '" + args[0] + "'.");
			}
			else
			{
				Output.Print(Respec.TryRefund(PerkState.Current, perkNode, out var message) ? message : ("Blocked: " + message));
			}
		}
	}
	internal sealed class ClearCommand : ConsoleCommand
	{
		public override string Name => "nsg.clear";

		public override string Help => "nsg.clear <treeKey> - refund a whole tree for free.";

		public override bool IsCheat => true;

		public override void Run(string[] args)
		{
			if (args.Length < 1)
			{
				Output.Print(((ConsoleCommand)this).Help);
				return;
			}
			PerkTree perkTree = PerkDatabase.Tree(args[0]);
			if (perkTree == null)
			{
				Output.Print("No tree '" + args[0] + "'.");
				return;
			}
			int num = Respec.ClearTree(PerkState.Current, perkTree);
			Output.Print($"Cleared {num} rank(s) from {perkTree.Name}.");
		}
	}
	internal sealed class PrestigeCommand : ConsoleCommand
	{
		public override string Name => "nsg.prestige";

		public override string Help => "nsg.prestige <treeKey> - at level 100, reset the live skill for permanent bonuses.";

		public override void Run(string[] args)
		{
			if (args.Length < 1)
			{
				Output.Print(((ConsoleCommand)this).Help);
				return;
			}
			PerkTree perkTree = PerkDatabase.Tree(args[0]);
			if (perkTree == null)
			{
				Output.Print("No tree '" + args[0] + "'.");
			}
			else
			{
				Output.Print(Prestige.TryPrestige(PerkState.Current, perkTree, out var message) ? message : ("Blocked: " + message));
			}
		}
	}
	internal sealed class GrantRespecCommand : ConsoleCommand
	{
		public override string Name => "nsg.rp";

		public override string Help => "nsg.rp [n] - grant respec points. Stands in for the Unwoven Thread until the item exists.";

		public override bool IsCheat => true;

		public override void Run(string[] args)
		{
			int amount = ModConfig.RespecPointsPerItem.Value;
			if (args.Length >= 1 && int.TryParse(args[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				amount = result;
			}
			Respec.GrantPoints(PerkState.Current, amount);
			Output.Print($"Respec points: {PerkState.Current.RespecPoints}");
		}
	}
	internal sealed class SetHighWaterCommand : ConsoleCommand
	{
		public override string Name => "nsg.sethw";

		public override string Help => "nsg.sethw <skillKey> <level> - set a high-water mark for testing.";

		public override bool IsCheat => true;

		public override void Run(string[] args)
		{
			if (args.Length < 2)
			{
				Output.Print(((ConsoleCommand)this).Help);
				return;
			}
			if (!float.TryParse(args[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				Output.Print("'" + args[1] + "' is not a number.");
				return;
			}
			string text = args[0].ToLowerInvariant();
			PerkState current = PerkState.Current;
			current.HighWater[text] = result;
			PerkTree perkTree = PerkDatabase.Tree(text);
			Output.Print((perkTree == null) ? $"High-water for '{text}' set to {result:0}. No tree by that key, so no points." : ($"{perkTree.Name} high-water {result:0} -> {PointMath.Earned(current)} points " + $"({PointMath.Available(current)} open)."));
		}
	}
	internal sealed class ReloadCommand : ConsoleCommand
	{
		public override string Name => "nsg.reload";

		public override string Help => "Re-read perks.json from the config folder.";

		public override bool IsCheat => true;

		public override void Run(string[] args)
		{
			PerkDatabase.Load(Plugin.ConfigDirectory);
			Output.Print(PerkDatabase.Loaded ? $"Reloaded: {PerkDatabase.Trees.Count} trees." : "Reload failed - see the BepInEx log.");
			Log.Info("Perk database reloaded from console.");
		}
	}
	internal sealed class OpenPanelCommand : ConsoleCommand
	{
		public override string Name => "nsg.panel";

		public override string Help => "Open the perk panel. Same as the hotkey.";

		public override void Run(string[] args)
		{
			PerkPanel.Toggle();
		}
	}
	internal sealed class StyleCommand : ConsoleCommand
	{
		public override string Name => "nsg.style";

		public override string Help => "nsg.style [<skill> <wide|narrow|balanced>] - how you swing. No arguments lists them.";

		public override void Run(string[] args)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			AttackStyle style2;
			if (args.Length < 2)
			{
				Output.Print("Attack styles - they grow more pronounced as the skill does:");
				string[] styleableSkills = StyleDirector.StyleableSkills;
				foreach (string text in styleableSkills)
				{
					AttackStyle style = PerkState.Current.GetStyle(text);
					SkillType type;
					float num = (((Object)(object)localPlayer != (Object)null && SkillKeys.TryResolve(text, out type)) ? ((Character)localPlayer).GetSkills().GetSkillLevel(type) : 0f);
					StyleProfile styleProfile = StyleProfile.For(style, num);
					string text2 = (styleProfile.HasSplash ? $"{styleProfile.PrimaryDamage:0.00}x primary, {styleProfile.SplashShare:0.00}x to {styleProfile.SplashRadius:0.0}m" : $"{styleProfile.PrimaryDamage:0.00}x primary, no splash");
					Output.Print($"  {text,-11} {style,-9} lv{num,3:0}   {text2}");
				}
			}
			else if (!StyleDirector.IsStyleable(args[0]))
			{
				Output.Print("'" + args[0] + "' has no styles. Weapon skills only.");
			}
			else if (!StyleDirector.TryParse(args[1], out style2))
			{
				Output.Print("'" + args[1] + "' is not a style. Use wide, narrow or balanced.");
			}
			else
			{
				StyleDirector.SetStyle(args[0], style2);
				Output.Print($"{args[0]} is now fought {style2}.");
			}
		}
	}
	internal static class Output
	{
		internal static void Print(string message)
		{
			if (message == null)
			{
				message = string.Empty;
			}
			Log.Info(message);
			Console instance = Console.instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.Print(message);
				return;
			}
			Chat instance2 = Chat.instance;
			if ((Object)(object)instance2 != (Object)null)
			{
				((Terminal)instance2).AddString(message);
			}
		}
	}
	internal sealed class PantryCommand : ConsoleCommand
	{
		public override string Name => "nsg.pantry";

		public override string Help => "What the crops turn into: the items, and the mill, oven and barrel chains.";

		public override void Run(string[] args)
		{
			Output.Print("--- Norntastic pantry ---");
			if (SafeMode.Active)
			{
				Output.Print("  SAFE MODE - nothing was made. Reasons:");
				{
					foreach (string item in SafeMode.Why)
					{
						Output.Print("    " + item);
					}
					return;
				}
			}
			Output.Print("  " + Pantry.BuiltCount + " of " + PantryLibrary.All.Count + " item(s) built.");
			foreach (PantryDef item2 in PantryLibrary.All)
			{
				if (Pantry.RefusedKeys.TryGetValue(item2.Key, out var value))
				{
					Output.Print($"  {item2.Display,-16} NO    needs '{value}', " + "which this install does not have");
				}
				else
				{
					Output.Print(PrefabForge.Has(item2.Name) ? $"  {item2.Display,-16} ok    {Route(item2)}" : $"  {item2.Display,-16} -     not built yet - run this in a world");
				}
			}
			Output.Print("  chains     " + Conversions.Added + " added to stations");
			IReadOnlyDictionary<string, string> refusedChains = Conversions.RefusedChains;
			if (refusedChains.Count == 0)
			{
				Output.Print("  Every mill, oven and barrel chain went in.");
				return;
			}
			Output.Print("  " + refusedChains.Count + " chain(s) did not:");
			foreach (KeyValuePair<string, string> item3 in refusedChains)
			{
				Output.Print("    " + item3.Key + "  ->  " + item3.Value);
			}
		}

		private static string Route(PantryDef def)
		{
			if (def.Milled)
			{
				return "milled from " + def.MillFrom + " at " + def.MillStation;
			}
			if (def.Fermented)
			{
				return "fermented from " + def.FermentFrom;
			}
			return "crafted at " + (def.Station ?? "bare hands");
		}
	}
	internal static class PerkConsole
	{
		private static CommandManager _manager;

		internal static readonly List<string> Registered = new List<string>();

		private static void Add(ConsoleCommand command)
		{
			if (command != null)
			{
				_manager.AddConsoleCommand(command);
				Registered.Add(command.Name);
			}
		}

		internal static void Register()
		{
			_manager = CommandManager.Instance;
			Registered.Clear();
			Add((ConsoleCommand)(object)new StatusCommand());
			Add((ConsoleCommand)(object)new TreesCommand());
			Add((ConsoleCommand)(object)new TreeCommand());
			Add((ConsoleCommand)(object)new BuyCommand());
			Add((ConsoleCommand)(object)new RefundCommand());
			Add((ConsoleCommand)(object)new ClearCommand());
			Add((ConsoleCommand)(object)new PrestigeCommand());
			Add((ConsoleCommand)(object)new GrantRespecCommand());
			Add((ConsoleCommand)(object)new SetHighWaterCommand());
			Add((ConsoleCommand)(object)new ReloadCommand());
			Add((ConsoleCommand)(object)new OpenPanelCommand());
			Add((ConsoleCommand)(object)new StyleCommand());
			Add((ConsoleCommand)(object)new TriggersCommand());
			Add((ConsoleCommand)(object)new PatchesCommand());
			Add((ConsoleCommand)(object)new EffectsCommand());
			Add((ConsoleCommand)(object)new FingerprintCommand());
			Add((ConsoleCommand)(object)new CheckCommand());
			Add((ConsoleCommand)(object)new EmoteCommand());
			foreach (EmoteDef item in EmoteLibrary.All)
			{
				Add((ConsoleCommand)(object)new EmoteShortCommand(item));
			}
			Add((ConsoleCommand)(object)new PiesCommand());
			Add((ConsoleCommand)(object)new BakeryCommand());
			Add((ConsoleCommand)(object)new ForgeCommand());
			Add((ConsoleCommand)(object)new CropCommand());
			Add((ConsoleCommand)(object)new ArsenalCommand());
			Add((ConsoleCommand)(object)new PantryCommand());
			Add((ConsoleCommand)(object)new StationCommand());
			Add((ConsoleCommand)(object)new SmokeCommand());
			Add((ConsoleCommand)(object)new FryerCommand());
			Add((ConsoleCommand)(object)new MartialCommand());
			Log.Info("Console commands registered (" + Registered.Count + "): " + string.Join(", ", Registered.ToArray()));
			Log.Info("After a fight, run 'nsg.check'.");
		}
	}
	internal sealed class SmokeCommand : ConsoleCommand
	{
		public override string Name => "nsg.smoke";

		public override string Help => "The smoke hooks: which meats can be hung, and which were left out.";

		public override void Run(string[] args)
		{
			Output.Print("--- Norntastic smoking ---");
			if (SafeMode.Active)
			{
				Output.Print("  SAFE MODE - nothing was made. Reasons:");
				{
					foreach (string item in SafeMode.Why)
					{
						Output.Print("    " + item);
					}
					return;
				}
			}
			if (!Jerky.Scanned)
			{
				Output.Print("  larder not read yet - run this in a world.");
				return;
			}
			Output.Print("  hook       " + (SmokeHook.HookBuilt ? "built" : "NOT built"));
			Output.Print("  steel      " + (SmokeHook.SteelBuilt ? "built - the Nordic Steel tier is priced in it" : "NOT built - the top station tier drops that cost instead"));
			Output.Print("  " + Jerky.Count + " meat(s) can be hung:");
			foreach (PieIngredient item2 in Jerky.All)
			{
				string arg = (PrefabForge.Has(Jerky.NameFor(item2)) ? "ok " : "-  ");
				Output.Print($"    {arg} {Jerky.DisplayFor(item2),-22} from {item2.DisplayName}");
			}
			IReadOnlyDictionary<string, string> skippedMeats = Jerky.SkippedMeats;
			if (skippedMeats.Count == 0)
			{
				Output.Print("  Nothing was left out.");
			}
			else
			{
				Output.Print("  " + skippedMeats.Count + " left out:");
				foreach (KeyValuePair<string, string> item3 in skippedMeats)
				{
					Output.Print("    " + item3.Key + "  ->  " + item3.Value);
				}
			}
			Output.Print("  A hook is two by two: meat in the top row, jerky in the bottom. Build more rather than bigger.");
		}
	}
	internal sealed class StationCommand : ConsoleCommand
	{
		public override string Name => "nsg.stations";

		public override string Help => "The automation stations: what built, what they adopted, what they have run.";

		public override void Run(string[] args)
		{
			Output.Print("--- Norntastic stations ---");
			if (SafeMode.Active)
			{
				Output.Print("  SAFE MODE - nothing was made. Reasons:");
				{
					foreach (string item in SafeMode.Why)
					{
						Output.Print("    " + item);
					}
					return;
				}
			}
			int num = AutoStationLibrary.All.Count * StationTiers.Count;
			Output.Print("  " + Stations.BuiltCount + " of " + num + " buildable(s) made.");
			foreach (AutoStationDef item2 in AutoStationLibrary.All)
			{
				int num2 = 0;
				foreach (StationTier value in Enum.GetValues(typeof(StationTier)))
				{
					if (PrefabForge.Has(item2.NameFor(value)))
					{
						num2++;
					}
				}
				Output.Print($"  {item2.Display,-16} {num2}/4 tiers   {Source(item2)}");
			}
			Output.Print("  adopted    " + Stations.AdoptedChains + " conversion(s) copied from this install's own stations");
			Output.Print("  cycles     " + AutoStation.CyclesThisSession + " batch(es) finished this session");
			IReadOnlyDictionary<string, string> refusedStations = Stations.RefusedStations;
			if (refusedStations.Count > 0)
			{
				Output.Print("  " + refusedStations.Count + " did not build:");
				foreach (KeyValuePair<string, string> item3 in refusedStations)
				{
					Output.Print("    " + item3.Key + "  ->  " + item3.Value);
				}
			}
			Output.Print("  Top rows are input, bottom rows are output. Tiers scale how MUCH a batch makes, never how fast - that is deliberate.");
		}

		private static string Source(AutoStationDef def)
		{
			if (!string.IsNullOrEmpty(def.Adopts))
			{
				return "adopts " + def.Adopts;
			}
			return "its own chains, from " + def.Source;
		}
	}
}
namespace Norntastic.Combat
{
	internal static class ArmourPen
	{
		[HarmonyPatch(typeof(HitData), "ApplyArmor")]
		internal static class Pierce
		{
			[HarmonyPrefix]
			private static void Prefix(HitData __instance, ref float __0)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				if (!Available || __instance == null || __0 <= 0f)
				{
					return;
				}
				try
				{
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null || (Object)(object)__instance.GetAttacker() != (Object)(object)localPlayer)
					{
						return;
					}
					float num = EffectAggregator.Pct(EffectKind.ArmourPenPct, __instance.m_skill);
					if (!(num <= 0f))
					{
						if (num > 90f)
						{
							num = 90f;
						}
						__0 *= 1f - num / 100f;
					}
				}
				catch (Exception ex)
				{
					Disable("ApplyArmor changed shape: " + ex.Message);
				}
			}
		}

		private const float MaxPenetration = 90f;

		internal static bool Available { get; private set; } = true;

		private static void Disable(string reason)
		{
			if (Available)
			{
				Available = false;
				Log.Warn("Armour penetration turned itself off: " + reason + ".");
			}
		}
	}
	internal struct StringLink
	{
		internal float Damage;

		internal float Stamina;

		internal bool IsFinisher;

		internal static readonly StringLink Neutral = new StringLink
		{
			Damage = 1f,
			Stamina = 1f
		};

		internal bool IsNeutral
		{
			get
			{
				if (Mathf.Approximately(Damage, 1f) && Mathf.Approximately(Stamina, 1f))
				{
					return !IsFinisher;
				}
				return false;
			}
		}
	}
	internal static class AttackString
	{
		internal const int Length = 3;

		internal static int Position => ComboCounter.Current;

		internal static bool NextFinishes => Position % 3 + 1 == 3;

		internal static StringLink LinkAt(int position, float skillLevel, AttackStyleWeight weight)
		{
			if (position <= 0 || !ModConfig.AttackStringsEnabled.Value)
			{
				return StringLink.Neutral;
			}
			float num = Mathf.Clamp01(skillLevel / 100f);
			return ((position - 1) % 3 + 1) switch
			{
				1 => new StringLink
				{
					Damage = 1f,
					Stamina = 1f
				}, 
				2 => new StringLink
				{
					Damage = 1f + 0.1f * num * weight.Escalation,
					Stamina = 1f - 0.2f * num * weight.Economy
				}, 
				_ => new StringLink
				{
					Damage = 1f + 0.35f * num * weight.Escalation,
					Stamina = 1.1f,
					IsFinisher = true
				}, 
			};
		}
	}
	internal struct AttackStyleWeight
	{
		internal float Escalation;

		internal float Economy;

		internal static readonly AttackStyleWeight Even = new AttackStyleWeight
		{
			Escalation = 1f,
			Economy = 1f
		};
	}
	internal static class AttackStringDriver
	{
		internal static float PendingStaminaScale { get; private set; } = 1f;

		internal static void Reset()
		{
			PendingStaminaScale = 1f;
		}

		internal static void Apply(Player player, HitData hit, int position)
		{
			//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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null) && hit != null)
			{
				float skillLevel = ((Character)player).GetSkillLevel(hit.m_skill);
				StringLink stringLink = AttackString.LinkAt(position, skillLevel, WeightFor(hit.m_skill));
				PendingStaminaScale = stringLink.Stamina;
				if (!Mathf.Approximately(stringLink.Damage, 1f))
				{
					((DamageTypes)(ref hit.m_damage)).Modify(stringLink.Damage);
				}
				if (stringLink.IsFinisher)
				{
					TriggerBus.Fire(TriggerKind.Stagger, new TriggerContext
					{
						Hit = hit,
						Skill = hit.m_skill
					});
				}
			}
		}

		private static AttackStyleWeight WeightFor(SkillType skill)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return StyleDirector.StyleFor(skill) switch
			{
				AttackStyle.Narrow => new AttackStyleWeight
				{
					Escalation = 1.35f,
					Economy = 0.7f
				}, 
				AttackStyle.Wide => new AttackStyleWeight
				{
					Escalation = 0.7f,
					Economy = 1.35f
				}, 
				_ => AttackStyleWeight.Even, 
			};
		}

		internal static float BonusForNode(string nodeId, int position)
		{
			int rank = PerkState.Current.GetRank(nodeId);
			if (rank <= 0)
			{
				return 0f;
			}
			if ((position - 1) % 3 + 1 != 3)
			{
				return 0f;
			}
			if (!(nodeId == "kn6"))
			{
				if (nodeId == "uw12")
				{
					return 0f;
				}
				return 0f;
			}
			if (rank != 1)
			{
				return 35f;
			}
			return 20f;
		}
	}
	[HarmonyPatch(typeof(Attack), "GetAttackStamina")]
	internal static class AttackStringStamina
	{
		[HarmonyPostfix]
		private static void Postfix(Attack __instance, ref float __result)
		{
			//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_0056: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			if (__result <= 0f || !ModConfig.AttackStringsEnabled.Value)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			Character value = Traverse.Create((object)__instance).Field<Character>("m_character").Value;
			if ((Object)(object)value == (Object)null || (Object)(object)value != (Object)(object)localPlayer)
			{
				return;
			}
			SkillType val = SkillOfCurrentWeapon(localPlayer);
			if ((int)val != 0)
			{
				StringLink stringLink = AttackString.LinkAt(ComboCounter.Current + 1, ((Character)localPlayer).GetSkillLevel(val), WeightFor(val));
				if (!Mathf.Approximately(stringLink.Stamina, 1f))
				{
					__result *= stringLink.Stamina;
				}
			}
		}

		private static SkillType SkillOfCurrentWeapon(Player player)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			ItemData currentWeapon = ((Humanoid)player).GetCurrentWeapon();
			if (currentWeapon?.m_shared != null)
			{
				return currentWeapon.m_shared.m_skillType;
			}
			return (SkillType)0;
		}

		private static AttackStyleWeight WeightFor(SkillType skill)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return StyleDirector.StyleFor(skill) switch
			{
				AttackStyle.Narrow => new AttackStyleWeight
				{
					Escalation = 1.35f,
					Economy = 0.7f
				}, 
				AttackStyle.Wide => new AttackStyleWeight
				{
					Escalation = 0.7f,
					Economy = 1.35f
				}, 
				_ => AttackStyleWeight.Even, 
			};
		}
	}
	internal static class CraftRefund
	{
		[HarmonyPatch(typeof(Player), "ConsumeResources")]
		internal static class Rebate
		{
			[HarmonyPostfix]
			private static void Postfix(Player __instance, Requirement[] requirements, int qualityLevel)
			{
				if (!Available || (Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || requirements == null)
				{
					return;
				}
				try
				{
					float num = EffectAggregator.Pct(EffectKind.MaterialRefundPct);
					if (num <= 0f)
					{
						return;
					}
					if (num > 90f)
					{
						num = 90f;
					}
					Inventory inventory = ((Humanoid)__instance).GetInventory();
					if (inventory == null)
					{
						return;
					}
					foreach (Requirement val in requirements)
					{
						if (val == null || (Object)(object)val.m_resItem == (Object)null)
						{
							continue;
						}
						int amount = val.GetAmount(qualityLevel);
						if (amount <= 0)
						{
							continue;
						}
						int num2 = 0;
						for (int j = 0; j < amount; j++)
						{
							if (Random.value * 100f < num)
							{
								num2++;
							}
						}
						if (num2 > 0)
						{
							inventory.AddItem(((Component)val.m_resItem).gameObject, num2);
							Refunded += num2;
						}
					}
				}
				catch (Exception ex)
				{
					Disable("ConsumeResources changed shape: " + ex.Message);
				}
			}
		}

		internal static bool Available { get; private set; } = true;

		internal static int Refunded { get; private set; }

		internal static void Reset()
		{
			Refunded = 0;
		}

		private static void Disable(string reason)
		{
			if (Available)
			{
				Available = false;
				Log.Warn("Crafting refunds turned themselves off: " + reason + ".");
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "EquipItem")]
	internal static class DualWieldEquip
	{
		private static bool _unavailable;

		internal static bool Available => !_unavailable;

		[HarmonyPostfix]
		private static void Postfix(Humanoid __instance, ItemData item, bool __result)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Invalid comparison between Unknown and I4
			if (_unavailable || !__result || item?.m_shared == null || !ModConfig.DualWieldEnabled.Value)
			{
				return;
			}
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)Player.m_localPlayer || (int)item.m_shared.m_itemType != 3 || PerkState.Current.GetRank("dw1") <= 0)
			{
				return;
			}
			Traverse val2 = Traverse.Create((object)val);
			Traverse val3 = val2.Field("m_leftItem");
			if (!val3.FieldExists())
			{
				Disable("Humanoid.m_leftItem is not where it used to be");
			}
			else
			{
				if (val3.GetValue<ItemData>() != null)
				{
					return;
				}
				ItemData val4 = FindDisplacedWeapon(val, item);
				if (val4 != null)
				{
					val4.m_equipped = true;
					val3.SetValue((object)val4);
					Traverse val5 = val2.Method("SetupEquipment", Array.Empty<object>());
					if (!val5.MethodExists())
					{
						val3.SetValue((object)null);
						val4.m_equipped = false;
						Disable("Humanoid.SetupEquipment is not where it used to be");
					}
					else
					{
						val5.GetValue();
						Equipment.Invalidate();
						Offhand.Invalidate();
						Log.Debug("Dual wield: " + val4.m_shared.m_name + " moved to the offhand.");
					}
				}
			}
		}

		private static ItemData FindDisplacedWeapon(Player player, ItemData justEquipped)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			Inventory inventory = ((Humanoid)player).GetInventory();
			List<ItemData> list = ((inventory != null) ? inventory.GetAllItems() : null);
			if (list == null)
			{
				return null;
			}
			ItemData result = null;
			float num = -1f;
			foreach (ItemData item in list)
			{
				if (item != null && item.m_shared != null && item != justEquipped && !item.m_equipped && (int)item.m_shared.m_itemType == 3)
				{
					float weight = item.GetWeight(item.m_stack);
					if (!(weight <= num))
					{
						num = weight;
						result = item;
					}
				}
			}
			return result;
		}

		private static void Disable(string why)
		{
			_unavailable = true;
			Log.Warn("Dual wield turned itself off: " + why + ". Everything else is unaffected; shields and torches in the offhand still work.");
		}
	}
	internal static class Durability
	{
		[HarmonyPatch(typeof(Humanoid), "DrainEquipedItemDurability")]
		internal static class HeldGear
		{
			[HarmonyPrefix]
			private static bool Prefix(Humanoid __instance, ItemData __0, ref float __1)
			{
				if (!Available)
				{
					return true;
				}
				try
				{
					if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
					{
						return true;
					}
					float num = HeldMultiplier(__0);
					if (Mathf.Approximately(num, 1f))
					{
						return true;
					}
					if (num <= 0f)
					{
						return false;
					}
					__1 *= num;
					return true;
				}
				catch (Exception ex)
				{
					Disable("DrainEquipedItemDurability changed shape: " + ex.Message);
					return true;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "DamageArmorDurability")]
		internal static class Armour
		{
			private static readonly List<ItemData> Watched = new List<ItemData>();

			private static readonly List<float> Before = new List<float>();

			[HarmonyPrefix]
			private static void Prefix(Player __instance)
			{
				Watched.Clear();
				Before.Clear();
				if (!Available)
				{
					return;
				}
				try
				{
					if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || Mathf.Approximately(ArmourMultiplier(), 1f))
					{
						return;
					}
					Inventory inventory = ((Humanoid)__instance).GetInventory();
					List<ItemData> list = ((inventory != null) ? inventory.GetAllItems() : null);
					if (list == null)
					{
						return;
					}
					foreach (ItemData item in list)
					{
						if (item != null && item.m_equipped && item.m_shared != null && item.m_shared.m_useDurability)
						{
							Watched.Add(item);
							Before.Add(item.m_durability);
						}
					}
				}
				catch (Exception ex)
				{
					Disable("reading armour durability threw: " + ex.Message);
				}
			}

			[HarmonyPostfix]
			private static void Postfix()
			{
				if (Watched.Count == 0)
				{
					return;
				}
				try
				{
					float num = 1f - ArmourMultiplier();
					if (num <= 0f)
					{
						return;
					}
					for (int i = 0; i < Watched.Count && i < Before.Count; i++)
					{
						ItemData val = Watched[i];
						if (val == null)
						{
							continue;
						}
						float num2 = Before[i] - val.m_durability;
						if (!(num2 <= 0f))
						{
							val.m_durability += num2 * num;
							if (val.m_durability > Before[i])
							{
								val.m_durability = Before[i];
							}
						}
					}
				}
				catch (Exception ex)
				{
					Disable("restoring armour durability threw: " + ex.Message);
				}
				finally
				{
					Watched.Clear();
					Before.Clear();
				}
			}
		}

		internal static bool Available { get; private set; } = true;

		private static void Disable(string reason)
		{
			if (Available)
			{
				Available = false;
				Log.Warn("Durability perks turned themselves off: " + reason + ". Everything else keeps working; nsg.check reports this.");
			}
		}

		private static float HeldMultiplier(ItemData item)
		{
			//IL_0017: 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_001f: 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_0041: Invalid comparison between Unknown and I4
			SkillType skill = (SkillType)((item?.m_shared != null) ? ((int)item.m_shared.m_skillType) : 0);
			float num = EffectAggregator.Pct(EffectKind.DurabilityLossPct, skill);
			if (item?.m_shared != null && (int)item.m_shared.m_itemType == 15)
			{
				num += EffectAggregator.Pct(EffectKind.TorchFuelPct);
			}
			float num2 = 1f + num / 100f;
			if (!(num2 < 0f))
			{
				return num2;
			}
			return 0f;
		}

		private static float ArmourMultiplier()
		{
			float num = EffectAggregator.Pct(EffectKind.ArmourDurabilityLossPct);
			float num2 = 1f + num / 100f;
			if (!(num2 < 0f))
			{
				return num2;
			}
			return 0f;
		}
	}
	internal static class Guard
	{
		[HarmonyPatch(typeof(ItemData), "GetBlockPower", new Type[]
		{
			typeof(int),
			typeof(float)
		})]
		internal static class BlockPowerPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ItemData __instance, ref float __result)
			{
				if (!(__result <= 0f))
				{
					float num = EffectAggregator.Pct(EffectKind.BlockPowerPct);
					if (num != 0f && IsOurs(__instance))
					{
						float num2 = __result * (1f + num / 100f);
						__result = ((num2 < 0f) ? 0f : num2);
					}
				}
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetDeflectionForce", new Type[] { typeof(int) })]
		internal static class DeflectionPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ItemData __instance, ref float __result)
			{
				if (!(__result <= 0f))
				{
					float num = EffectAggregator.Pct(EffectKind.DeflectionPct);
					if (num != 0f && IsOurs(__instance))
					{
						float num2 = __result * (1f + num / 100f);
						__result = ((num2 < 0f) ? 0f : num2);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "BlockAttack", new Type[]
		{
			typeof(HitData),
			typeof(Character)
		})]
		internal static class ParryWindowPatch
		{
			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static void Prefix(Humanoid __instance)
			{
				if (_windowUnavailable)
				{
					return;
				}
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)Player.m_localPlayer)
				{
					return;
				}
				float num = EffectAggregator.Pct(EffectKind.ParryWindowPct);
				if (!(num <= 0f) && (!(_interval < 0f) || ReadInterval()))
				{
					Traverse<float> val2 = Traverse.Create((object)val).Field<float>("m_blockTimer");
					float value = val2.Value;
					if (!(value < 0f) && !(value <= _interval) && value <= _interval * (1f + num / 100f))
					{
						val2.Value = 0f;
					}
				}
			}

			private static bool ReadInterval()
			{
				Traverse val = Traverse.Create(typeof(Humanoid)).Field("m_perfectBlockInterval");
				if (!val.FieldExists())
				{
					_windowUnavailable = true;
					Log.Warn("Parry window widening turned itself off: Humanoid.m_perfectBlockInterval is not where it used to be. Every other block perk is unaffected.");
					return false;
				}
				_interval = val.GetValue<float>();
				if (_interval > 0f)
				{
					return true;
				}
				_windowUnavailable = true;
				Log.Warn("Parry window widening turned itself off: the game reports a parry window of " + _interval + ", which cannot be widened.");
				return false;
			}
		}

		private static bool _windowUnavailable;

		private static float _interval = -1f;

		internal static bool ParryWindowAvailable => !_windowUnavailable;

		private static bool IsOurs(ItemData item)
		{
			if (item == null)
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			if (item != Offhand.ItemOf(localPlayer))
			{
				return item == ((Humanoid)localPlayer).GetCurrentWeapon();
			}
			return true;
		}

		internal static void ApplyUnblockable(HitData hit, float chance)
		{
			if (hit != null && !(chance <= 0f) && (!(chance < 100f) || !(Random.Range(0f, 100f) >= chance)))
			{
				hit.m_blockable = false;
			}
		}
	}
	internal static class HarvestDamage
	{
		[HarmonyPatch(typeof(TreeBase), "Damage")]
		internal static class Trees
		{
			[HarmonyPrefix]
			private static void Prefix(HitData hit)
			{
				if (!Available)
				{
					return;
				}
				try
				{
					Boost(hit, EffectKind.ChopDamagePct);
				}
				catch (Exception ex)
				{
					Disable("TreeBase.Damage changed shape: " + ex.Message);
				}
			}
		}

		[HarmonyPatch(typeof(TreeLog), "Damage")]
		internal static class Logs
		{
			[HarmonyPrefix]
			private static void Prefix(HitData hit)
			{
				if (!Available)
				{
					return;
				}
				try
				{
					Boost(hit, EffectKind.ChopDamagePct);
				}
				catch (Exception ex)
				{
					Disable("TreeLog.Damage changed shape: " + ex.Message);
				}
			}
		}

		[HarmonyPatch(typeof(MineRock5), "Damage")]
		internal static class Veins
		{
			[HarmonyPrefix]
			private static void Prefix(HitData hit)
			{
				if (!Available)
				{
					return;
				}
				try
				{
					Boost(hit, EffectKind.MineDamagePct);
				}
				catch (Exception ex)
				{
					Disable("MineRock5.Damage changed shape: " + ex.Message);
				}
			}
		}

		internal static bool Available { get; private set; } = true;

		private static void Disable(string reason)
		{
			if (Available)
			{
				Available = false;
				Log.Warn("Harvest damage perks turned themselves off: " + reason + ".");
			}
		}

		private static void Boost(HitData hit, EffectKind kind)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (hit == null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)hit.GetAttacker() != (Object)(object)localPlayer)
			{
				return;
			}
			float num = EffectAggregator.Pct(kind, hit.m_skill);
			if (num != 0f)
			{
				float num2 = 1f + num / 100f;
				if (num2 < 0f)
				{
					num2 = 0f;
				}
				hit.m_damage.m_chop *= num2;
				hit.m_damage.m_pickaxe *= num2;
			}
		}
	}
	internal static class IncomingDamage
	{
		internal static void Apply(Player player, HitData hit)
		{
			if (!((Object)(object)player == (Object)null) && hit != null && !Deflected(player, hit))
			{
				Thorns(player, hit);
				Reduce(hit);
				Cap(player, hit);
			}
		}

		private static bool Deflected(Player player, HitData hit)
		{
			float num = EffectAggregator.Pct(EffectKind.DeflectChancePct);
			if (num <= 0f)
			{
				return false;
			}
			if (Random.value * 100f > num)
			{
				return false;
			}
			((DamageTypes)(ref hit.m_damage)).Modify(0f);
			hit.m_pushForce = 0f;
			((Character)player).Message((MessageType)1, "Deflected", 0, (Sprite)null, false);
			TriggerBus.Fire(TriggerKind.Blocked, new TriggerContext
			{
				Hit = hit
			});
			return true;
		}

		private static void Thorns(Player player, HitData hit)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//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_006d: 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_007d: 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_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)
			float num = EffectAggregator.Pct(EffectKind.ThornsPct);
			if (num <= 0f)
			{
				return;
			}
			Character attacker = hit.GetAttacker();
			if (!((Object)(object)attacker == (Object)null) && !((Object)(object)attacker == (Object)(object)player))
			{
				float num2 = hit.GetTotalDamage() * num / 100f;
				if (!(num2 <= 0f))
				{
					HitData val = new HitData();
					val.m_damage.m_blunt = num2;
					val.m_point = ((Component)attacker).transform.position;
					Vector3 val2 = ((Component)attacker).transform.position - ((Component)player).transform.position;
					val.m_dir = ((Vector3)(ref val2)).normalized;
					val.SetAttacker((Character)(object)player);
					val.m_dodgeable = false;
					val.m_blockable = false;
					attacker.Damage(val);
					Log.Debug("Thorns returned " + num2.ToString("0.0") + ".");
				}
			}
		}

		private static void Reduce(HitData hit)
		{
			float num = EffectAggregator.Pct(EffectKind.DamageTakenPct);
			if (num != 0f)
			{
				float num2 = 1f + num / 100f;
				((DamageTypes)(ref hit.m_damage)).Modify((num2 < 0f) ? 0f : num2);
			}
		}

		private static void Cap(Player player, HitData hit)
		{
			float num = EffectAggregator.Pct(EffectKind.DamageCapPct);
			if (num <= 0f)
			{
				return;
			}
			float num2 = ((Character)player).GetMaxHealth() * num / 100f;
			if (!(num2 <= 0f))
			{
				float totalDamage = hit.GetTotalDamage();
				if (!(totalDamage <= num2))
				{
					((DamageTypes)(ref hit.m_damage)).Modify(num2 / totalDamage);
					Log.Debug("Capped a " + totalDamage.ToString("0") + " hit to " + num2.ToString("0") + ".");
				}
			}
		}

		internal static bool ForgiveShortFall(HitData hit)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			if (hit == null || (int)hit.m_hitType != 3)
			{
				return false;
			}
			float num = EffectAggregator.Pct(EffectKind.FallGraceMetres);
			if (num <= 0f)
			{
				return false;
			}
			float num2 = num * num;
			if (hit.GetTotalDamage() > num2)
			{
				return false;
			}
			((DamageTypes)(ref hit.m_damage)).Modify(0f);
			return true;
		}
	}
	internal enum OffhandKind
	{
		Empty,
		Shield,
		Torch,
		Weapon
	}
	internal static class Offhand
	{
		private const float CacheSeconds = 0.2f;

		private static ItemData _item;

		private static OffhandKind _kind;

		private static float _takenAt = -1f;

		internal static void Invalidate()
		{
			_takenAt = -1f;
		}

		internal static OffhandKind KindOf(Player player)
		{
			Refresh(player);
			return _kind;
		}

		internal static ItemData ItemOf(Player player)
		{
			Refresh(player);
			return _item;
		}

		internal static bool IsDualWielding(Player player)
		{
			return KindOf(player) == OffhandKind.Weapon;
		}

		private static void Refresh(Player player)
		{
			//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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Invalid comparison between Unknown and I4
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Invalid comparison between Unknown and I4
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			float time = Time.time;
			if (_takenAt >= 0f && time - _takenAt < 0.2f)
			{
				return;
			}
			_takenAt = time;
			_item = null;
			_kind = OffhandKind.Empty;
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			List<ItemData> list = ((inventory != null) ? inventory.GetAllItems() : null);
			if (list == null)
			{
				return;
			}
			ItemData currentWeapon = ((Humanoid)player).GetCurrentWeapon();
			foreach (ItemData item in list)
			{
				if (item != null && item.m_equipped && item.m_shared != null && item != currentWeapon)
				{
					ItemType itemType = item.m_shared.m_itemType;
					if ((int)itemType == 3)
					{
						_item = item;
						_kind = OffhandKind.Weapon;
						break;
					}
					if ((int)itemType == 5)
					{
						_item = item;
						_kind = OffhandKind.Shield;
						break;
					}
					if ((int)itemType == 15)
					{
						_item = item;
						_kind = OffhandKind.Torch;
						break;
					}
				}
			}
		}

		internal static float ContributionFrom(ItemData item, OffhandKind kind, int quality)
		{
			//IL_0054: 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_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)
			if (item?.m_shared == null)
			{
				return 0f;
			}
			DamageTypes damage;
			switch (kind)
			{
			case OffhandKind.Weapon:
				damage = item.GetDamage(quality, 1f);
				return ((DamageTypes)(ref damage)).GetTotalDamage();
			case OffhandKind.Shield:
				return item.GetBaseBlockPower(quality) * 0.25f;
			case OffhandKind.Torch:
				damage = item.GetDamage(quality, 1f);
				return ((DamageTypes)(ref damage)).GetTotalDamage();
			default:
				return 0f;
			}
		}
	}
	internal static class OffhandPicker
	{
		internal static ConfigEntry<KeyboardShortcut> PickKey;

		private static bool _unavailable;

		internal static bool Available => !_unavailable;

		internal static void Bind(ConfigFile config)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			PickKey = config.Bind<KeyboardShortcut>("Combat", "OffhandPickKey", new KeyboardShortcut((KeyCode)108, Array.Empty<KeyCode>()), "With the inventory open, point at an item and press this to put it in your offhand. Press again on the same item to take it off. A weapon there needs the Dual Wield perk; a shield or torch does not.");
		}

		internal static void Tick(Player player)
		{
			//IL_002b: 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)
			if (_unavailable || PickKey == null || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			KeyboardShortcut value = PickKey.Value;
			if (((KeyboardShortcut)(ref value)).IsDown() && !Console.IsVisible() && !TextInput.IsVisible() && (!((Object)(object)Chat.instance != (Object)null) || !Chat.instance.HasFocus()))
			{
				ItemData val = BrawlerHover.Item();
				if (val?.m_shared == null)
				{
					((Character)player).Message((MessageType)2, "Point at something in your inventory first", 0, (Sprite)null, false);
				}
				else
				{
					Toggle(player, val);
				}
			}
		}

		private static void Toggle(Player player, ItemData item)
		{
			Traverse val = Traverse.Create((object)player);
			Traverse val2 = val.Field("m_leftItem");
			if (!val2.FieldExists())
			{
				Disable("Humanoid.m_leftItem is not where it used to be");
				return;
			}
			ItemData value = val2.GetValue<ItemData>();
			if (value == item)
			{
				val2.SetValue((object)null);
				item.m_equipped = false;
				Refresh(player, val, item, null);
				((Character)player).Message((MessageType)2, item.m_shared.m_name + " off hand", 0, (Sprite)null, false);
				return;
			}
			if (!Allowed(player, item, out var why))
			{
				((Character)player).Message((MessageType)2, why, 0, (Sprite)null, false);
				return;
			}
			if (value != null)
			{
				value.m_equipped = false;
			}
			item.m_equipped = true;
			val2.SetValue((object)item);
			if (Refresh(player, val, item, value))
			{
				((Character)player).Message((MessageType)2, item.m_shared.m_name + " in hand", 0, (Sprite)null, false);
			}
		}

		private static bool Allowed(Player player, ItemData item, out string why)
		{
			//IL_000d: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			why = string.Empty;
			ItemType itemType = item.m_shared.m_itemType;
			if ((int)itemType == 5 || (int)itemType == 15)
			{
				return true;
			}
			if ((int)itemType != 3)
			{
				why = "That does not go in an off hand";
				return false;
			}
			if (!ModConfig.DualWieldEnabled.Value)
			{
				why = "Dual wielding is switched off in the config";
				return false;
			}
			if (PerkState.Current.GetRank("dw1") <= 0)
			{
				why = "A second weapon needs the Dual Wield perk 'Off Hand' first";
				return false;
			}
			if (Equipment.IsTwoHanded(player))
			{
				why = "Both hands are already on that";
				return false;
			}
			return true;
		}

		private static bool Refresh(Player player, Traverse traverse, ItemData item, ItemData putBack)
		{
			Traverse val = traverse.Method("SetupEquipment", Array.Empty<object>());
			if (!val.MethodExists())
			{
				traverse.Field("m_leftItem").SetValue((object)putBack);
				item.m_equipped = putBack != null && item == putBack;
				if (putBack != null)
				{
					putBack.m_equipped = true;
				}
				Disable("Humanoid.SetupEquipment is not where it used to be");
				return false;
			}
			val.GetValue();
			Equipment.Invalidate();
			Offhand.Invalidate();
			return true;
		}

		private static void Disable(string reason)
		{
			_unavailable = true;
			Log.Warn("Offhand picking turned itself off: " + reason + ". Everything else keeps working; nsg.check reports this.");
		}
	}
	internal static class OffhandStrike
	{
		private static int _swings;

		internal static void Reset()
		{
			_swings = 0;
		}

		internal static bool OnMainHandHit(Player player, Character target, HitData hit)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (Object)(object)target == (Object)null || hit == null)
			{
				return false;
			}
			if (!ModConfig.DualWieldEnabled.Value)
			{
				return false;
			}
			OffhandKind offhandKind = Offhand.KindOf(player);
			if (offhandKind == OffhandKind.Empty)
			{
				return false;
			}
			ItemData val = Offhand.ItemOf(player);
			if (val == null)
			{
				return false;
			}
			PerkState current = PerkState.Current;
			float num = ShareFor(current, offhandKind);
			if (num <= 0f)
			{
				return false;
			}
			float num2 = Offhand.ContributionFrom(val, offhandKind, val.m_quality);
			if (num2 <= 0f)
			{
				return false;
			}
			_swings++;
			float num3 = num2 * num;
			AddDamage(hit, val, offhandKind, num3);
			int num4 = Mathf.Max(1, ModConfig.DualWieldCadence.Value);
			if (_swings % num4 == 0)
			{
				AddDamage(hit, val, offhandKind, num2 * ExtraShareFor(current, offhandKind));
				TriggerBus.Fire(TriggerKind.Hit, new TriggerContext
				{
					Target = target,
					Hit = hit,
					Skill = hit.m_skill
				});
			}
			TrainOffhand(player, offhandKind, num3);
			return true;
		}

		private static void AddDamage(HitData hit, ItemData item, OffhandKind kind, float amount)
		{
			//IL_002a: 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_0062: 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_0090: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			if (amount <= 0f)
			{
				return;
			}
			if (kind == OffhandKind.Shield)
			{
				hit.m_damage.m_blunt += amount;
				return;
			}
			DamageTypes damage = item.GetDamage(item.m_quality, 1f);
			float totalDamage = ((DamageTypes)(ref damage)).GetTotalDamage();
			if (totalDamage <= 0f)
			{
				hit.m_damage.m_blunt += amount;
				return;
			}
			float num = amount / totalDamage;
			hit.m_damage.m_blunt += damage.m_blunt * num;
			hit.m_damage.m_slash += damage.m_slash * num;
			hit.m_damage.m_pierce += damage.m_pierce * num;
			hit.m_damage.m_fire += damage.m_fire * num;
			hit.m_damage.m_frost += damage.m_frost * num;
			hit.m_damage.m_lightning += damage.m_lightning * num;
			hit.m_damage.m_poison += damage.m_poison * num;
			hit.m_damage.m_spirit += damage.m_spirit * num;
		}

		private static float ShareFor(PerkState state, OffhandKind kind)
		{
			float num = 0f;
			switch (kind)
			{
			case OffhandKind.Weapon:
				num += 0.05f * (float)state.GetRank("dw1");
				num += 0.05f * (float)state.GetRank("dw2");
				break;
			case OffhandKind.Shield:
				num += 0.08f * (float)state.GetRank("sh5");
				num += 0.06f * (float)state.GetRank("sh2");
				break;
			case OffhandKind.Torch:
				num += 0.08f * (float)state.GetRank("tr1");
				break;
			}
			return num;
		}

		private static float ExtraShareFor(PerkState state, OffhandKind kind)
		{
			return Mathf.Max(0.15f, ShareFor(state, kind) * 2.5f);
		}

		private static void TrainOffhand(Player player, OffhandKind kind, float damage)
		{
			//IL_0011: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			if (CustomSkills.Registered && !(damage <= 0f))
			{
				((Character)player).RaiseSkill(CustomSkills.DualWield, Mathf.Clamp(damage * 0.05f, 0.05f, 1.2f));
				switch (kind)
				{
				case OffhandKind.Torch:
					((Character)player).RaiseSkill(CustomSkills.Torch, Mathf.Clamp(damage * 0.04f, 0.05f, 1.2f));
					break;
				case OffhandKind.Shield:
					((Character)player).RaiseSkill(CustomSkills.Shield, Mathf.Clamp(damage * 0.05f, 0.05f, 1.2f));
					break;
				}
			}
		}
	}
	internal static class PlayerTuning
	{
		private sealed class Baseline
		{
			internal float StaminaRegenDelay;

			internal float JumpForce;

			internal float JumpForceForward;

			internal float JumpStamina;

			internal float JumpTiredFactor;
		}

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

		private const float Interval = 0.25f;

		private static float _next;

		internal static int TrackedForTests => Baselines.Count;

		internal static void Reset()
		{
			Baselines.Clear();
		}

		private static Baseline For(Player player)
		{
			int instanceID = ((Object)player).GetInstanceID();
			if (Baselines.TryGetValue(instanceID, out var value))
			{
				return value;
			}
			value = new Baseline
			{
				StaminaRegenDelay = player.m_staminaRegenDelay,
				JumpForce = ((Character)player).m_jumpForce,
				JumpForceForward = ((Character)player).m_jumpForceForward,
				JumpStamina = ((Character)player).m_jumpStaminaUsage,
				JumpTiredFactor = ((Character)player).m_jumpForceTiredFactor
			};
			Baselines[instanceID] = value;
			Log.Debug("Captured movement baselines: jump " + value.JumpForce + ", forward " + value.JumpForceForward + ", regen delay " + value.StaminaRegenDelay + ".");
			return value;
		}

		internal static void Tick(Player player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer || Time.time < _next)
			{
				return;
			}
			_next = Time.time + 0.25f;
			Baseline baseline = For(player);
			float num = EffectAggregator.Pct(EffectKind.StaminaDelayFlat);
			float num2 = baseline.StaminaRegenDelay - num;
			player.m_staminaRegenDelay = ((num2 < 0f) ? 0f : num2);
			((Character)player).m_jumpForceForward = Scale(baseline.JumpForceForward, EffectAggregator.Pct(EffectKind.JumpForwardPct));
			((Character)player).m_jumpStaminaUsage = Scale(baseline.JumpStamina, EffectAggregator.Pct(EffectKind.StaminaJumpPct));
			float num3 = EffectAggregator.Pct(EffectKind.JumpWeightReliefPct);
			if (num3 != 0f)
			{
				float num4 = 1f - num3 / 100f;
				if (num4 < 0f)
				{
					num4 = 0f;
				}
				((Character)player).m_jumpForceTiredFactor = baseline.JumpTiredFactor * num4;
			}
			else
			{
				((Character)player).m_jumpForceTiredFactor = baseline.JumpTiredFactor;
			}
		}

		private static float Scale(float baseValue, float percent)
		{
			if (percent == 0f)
			{
				return baseValue;
			}
			float num = baseValue * (1f + percent / 100f);
			if (!(num < 0f))
			{
				return num;
			}
			return 0f;
		}
	}
	[HarmonyPatch(typeof(Projectile), "Setup")]
	internal static class Projectiles
	{
		internal static int ShotsShapedThisSession { get; private set; }

		private static bool IsOurs(Character owner)
		{
			if ((Object)(object)owner != (Object)null)
			{
				return (Object)(object)owner == (Object)(object)Player.m_localPlayer;
			}
			return false;
		}

		[HarmonyPrefix]
		private static void Prefix(Character owner, ref Vector3 velocity, HitData hitData)
		{
			//IL_000d: 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_0015: 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_0034: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			if (IsOurs(owner) && hitData != null)
			{
				SkillType skill = hitData.m_skill;
				float num = EffectAggregator.Pct(EffectKind.ProjectileSpeedPct, skill);
				if (num != 0f)
				{
					float num2 = 1f + num / 100f;
					velocity *= ((num2 < 0f) ? 0f : num2);
				}
				float num3 = EffectAggregator.Pct(EffectKind.ProjectileDamagePct, skill);
				if (num3 != 0f)
				{
					float num4 = 1f + num3 / 100f;
					((DamageTypes)(ref hitData.m_damage)).Modify((num4 < 0f) ? 0f : num4);
				}
			}
		}

		[HarmonyPostfix]
		private static void Postfix(Projectile __instance, Character owner, HitData hitData)
		{
			//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)
			//IL_0020: 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)
			if (!((Object)(object)__instance == (Object)null) && IsOurs(owner) && hitData != null)
			{
				SkillType skill = hitData.m_skill;
				bool flag = false;
				float num = EffectAggregator.Pct(EffectKind.ProjectileDropPct, skill);
				if (num != 0f && __instance.m_gravity != 0f)
				{
					float num2 = 1f + num / 100f;
					__instance.m_gravity *= ((num2 < 0f) ? 0f : num2);
					flag = true;
				}
				float num3 = EffectAggregator.Pct(EffectKind.ProjectilePiercePct, skill);
				if (num3 > 0f && (num3 >= 100f || Random.Range(0f, 100f) < num3))
				{
					__instance.m_onlyStopOnTerrain = true;
					flag = true;
				}
				if (flag)
				{
					ShotsShapedThisSession++;
				}
			}
		}
	}
	internal static class Splash
	{
		private static readonly Dictionary<string, List<SplashSpec>> ByNode = new Dictionary<string, List<SplashSpec>>();

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

		private const int MaxTargetsPerSplash = 12;

		internal static int HitsThisSession { get; private set; }

		internal static int ClauseCount { get; private set; }

		internal static int LiveCount
		{
			get
			{
				PerkState current = PerkState.Current;
				if (current == null)
				{
					return 0;
				}
				int num = 0;
				foreach (KeyValuePair<string, List<SplashSpec>> item in ByNode)
				{
					if (current.GetRank(item.Key) > 0)
					{
						num += item.Value.Count;
					}
				}
				return num;
			}
		}

		internal static void Rebuild()
		{
			ByNode.Clear();
			Counts.Clear();
			ClauseCount = 0;
			foreach (PerkTree value in PerkDatabase.Trees.Values)
			{
				foreach (PerkNode node in value.Nodes)
				{
					if (node.Splashes != null && node.Splashes.Count != 0)
					{
						ByNode[node.Id] = node.Splashes;
						ClauseCount += node.Splashes.Count;
					}
				}
			}
		}

		internal static bool Implements(string nodeId)
		{
			return ByNode.ContainsKey(nodeId);
		}

		internal static void FromHit(Player attacker, Character primary, HitData hit, PerkState state)
		{
			//IL_0081: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			if (ByNode.Count == 0 || (Object)(object)attacker == (Object)null || (Object)(object)primary == (Object)null || hit == null || state == null)
			{
				return;
			}
			float totalDamage = hit.GetTotalDamage();
			if (totalDamage <= 0f)
			{
				return;
			}
			foreach (KeyValuePair<string, List<SplashSpec>> item in ByNode)
			{
				int rank = state.GetRank(item.Key);
				if (rank <= 0)
				{
					continue;
				}
				foreach (SplashSpec item2 in item.Value)
				{
					if (((int)item2.Skill == 0 || item2.Skill == hit.m_skill) && !(HitConditions.Factor(new HitModifier
					{
						When = item2.When,
						ConditionValue = item2.ConditionValue,
						ConditionText = item2.ConditionText
					}, primary) <= 0f) && Due(item2))
					{
						float num = item2.RadiusAt(rank);
						float num2 = item2.ValueAt(rank);
						if (!(num <= 0f) && !(num2 <= 0f))
						{
							Throw(attacker, primary, hit, totalDamage * num2 / 100f, num, item2.StaggerPct);
						}
					}
				}
			}
		}

		private static bool Due(SplashSpec spec)
		{
			if (spec.Every <= 1)
			{
				return true;
			}
			Counts.TryGetValue(spec, out var value);
			value++;
			if (value < spec.Every)
			{
				Counts[spec] = value;
				return false;
			}
			Counts[spec] = 0;
			return true;
		}

		private static void Throw(Player attacker, Character primary, HitData source, float amount, float radius, float staggerPct)
		{
			//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_007e: 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_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: 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)
			Vector3 centerPoint = primary.GetCenterPoint();
			List<Character> allCharacters = Character.GetAllCharacters();
			if (allCharacters == null)
			{
				return;
			}
			int num = 0;
			foreach (Character item in allCharacters)
			{
				if (num >= 12)
				{
					break;
				}
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item == (Object)(object)primary) && !((Object)(object)item == (Object)(object)attacker) && !item.IsDead() && !item.IsPlayer() && BaseAI.IsEnemy((Character)(object)attacker, item) && !(Vector3.Distance(centerPoint, item.GetCenterPoint()) > radius))
				{
					HitData val = source.Clone();
					val.m_damage.m_blunt = amount;
					val.m_damage.m_slash = 0f;
					val.m_damage.m_pierce = 0f;
					val.m_damage.m_chop = 0f;
					val.m_damage.m_pickaxe = 0f;
					val.m_damage.m_fire = 0f;
					val.m_damage.m_frost = 0f;
					val.m_damage.m_lightning = 0f;
					val.m_damage.m_poison = 0f;
					val.m_damage.m_spirit = 0f;
					val.m_skill = (SkillType)0;
					Vector3 val2 = item.GetCenterPoint() - centerPoint;
					val.m_dir = ((Vector3)(ref val2)).normalized;
					val.m_point = item.GetCenterPoint();
					if (staggerPct != 0f)
					{
						float num2 = val.m_staggerMultiplier * (1f + staggerPct / 100f);
						val.m_staggerMultiplier = ((num2 < 0f) ? 0f : num2);
					}
					item.Damage(val);
					num++;
					HitsThisSession++;
				}
			}
		}
	}
	internal static class StationReach
	{
		[HarmonyPatch(typeof(CraftingStation), "FindClosestStationInRange")]
		internal static class Closest
		{
			[HarmonyPrefix]
			private static void Prefix(ref float __2)
			{
				if (!Available)
				{
					return;
				}
				try
				{
					float num = Bonus();
					if (num > 0f)
					{
						__2 += num;
					}
				}
				catch (Exception ex)
				{
					Disable("FindClosestStationInRange changed shape: " + ex.Message);
				}
			}
		}

		[HarmonyPatch(typeof(CraftingStation), "HaveBuildStationInRange")]
		internal static class Build
		{
			[HarmonyPostfix]
			private static void Postfix(string name, Vector3 point, ref CraftingStation __result)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				if (!Available || (Object)(object)__result != (Object)null)
				{
					return;
				}
				try
				{
					float num = Bonus();
					if (!(num <= 0f))
					{
						__result = CraftingStation.FindClosestStationInRange(name, point, 20f + num);
					}
				}
				catch (Exception ex)
				{
					Disable("HaveBuildStationInRange changed shape: " + ex.Message);
				}
			}
		}

		private const float VanillaBuildRange = 20f;

		private const float Anywhere = 100000f;

		internal static bool Available { get; private set; } = true;

		private static void Disable(string reason)
		{
			if (Available)
			{
				Available = false;
				Log.Warn("Station reach perks turned themselves off: " + reason + ".");
			}
		}

		private static float Bonus()
		{
			float num = EffectAggregator.Pct(EffectKind.StationReachMetres);
			if (num <= 0f)
			{
				return 0f;
			}
			if (!(num >= 100000f))
			{
				return num;
			}
			return 100000f;
		}
	}
	internal static class StrikeRiders
	{
		internal static void Outgoing(HitData hit, float extraUnblockableChance)
		{
			//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_000e: 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_0040: 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_0098: 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)
			if (hit == null)
			{
				return;
			}
			SkillType skill = hit.m_skill;
			Guard.ApplyUnblockable(hit, EffectAggregator.Pct(EffectKind.UnblockableChancePct, skill) + extraUnblockableChance);
			float num = EffectAggregator.Pct(EffectKind.StaggerPowerPct, skill);
			if (num != 0f)
			{
				hit.m_staggerMultiplier = Scale(hit.m_staggerMultiplier, num);
			}
			float num2 = EffectAggregator.Pct(EffectKind.KnockbackPowerPct, skill);
			if (num2 != 0f)
			{
				hit.m_pushForce = Scale(hit.m_pushForce, num2);
			}
			float num3 = EffectAggregator.Pct(EffectKind.BackstabPct, skill);
			if (num3 != 0f)
			{
				hit.m_backstabBonus = Scale(hit.m_backstabBonus, num3);
			}
			float totalDamage = hit.GetTotalDamage();
			if (!(totalDamage <= 0f))
			{
				float num4 = EffectAggregator.Pct(EffectKind.LifestealPct, skill);
				if (num4 > 0f)
				{
					hit.m_healthReturn += totalDamage * num4 / 100f;
				}
				float num5 = EffectAggregator.Pct(EffectKind.EitrStealPct, skill);
				if (num5 > 0f)
				{
					hit.m_eitrAdd += totalDamage * num5 / 100f;
				}
			}
		}

		internal static void Incoming(HitData hit)
		{
			if (hit != null)
			{
				float num = EffectAggregator.Pct(EffectKind.KnockbackTakenPct);
				if (num != 0f)
				{
					hit.m_pushForce = Scale(hit.m_pushForce, num);
				}
			}
		}

		private static float Scale(float value, float percent)
		{
			float num = value * (1f + percent / 100f);
			if (!(num < 0f))
			{
				return num;
			}
			return 0f;
		}
	}
}
namespace Norntastic.Brawler
{
	internal static class BrawlerAttack
	{
		private const float SwingRange = 2.6f;

		private const float SwingRadius = 1.4f;

		private const float StaminaPerUse = 12f;

		internal static bool Swing(Player player, ItemData item)
		{
			return Execute(player, item, thrown: false);
		}

		internal static bool Throw(Player player, ItemData item)
		{
			return Execute(player, item, thrown: true);
		}

		private static bool Execute(Player player, ItemData item, bool thrown)
		{
			//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_0113: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || item?.m_shared == null)
			{
				return false;
			}
			if (!BrawlerModifiers.Unlocked)
			{
				((Character)player).Message((MessageType)2, "Improvised weapons need the Tavern Brawler perk 'Anything Goes' (free at level 0 - open the perk panel with P)", 0, (Sprite)null, false);
				return false;
			}
			if (((Character)player).InAttack())
			{
				return false;
			}
			if (!((Character)player).HaveStamina(12f))
			{
				((Character)player).Message((MessageType)2, "$msg_encumbered", 0, (Sprite)null, false);
				return false;
			}
			((Character)player).UseStamina(12f);
			ImprovisedWeapon profile = ImprovisedWeapon.From(item);
			SkillType val = CookingCombat.Governs(item);
			profile.Scale(CookingCombat.SkillMultiplier(player, item));
			profile.Scale(CookingCombat.QualityMultiplier(item));
			profile.Scale(BrawlerModifiers.CrowdMultiplier(player));
			if (thrown)
			{
				profile.Scale(BrawlerModifiers.ThrownDamageMultiplier());
			}
			if (profile.IsMetal)
			{
				profile.Scale(BrawlerModifiers.MetalMultiplier());
			}
			float range = (thrown ? BrawlerModifiers.ThrowRange() : 2.6f);
			Vector3 point;
			Character val2 = FindTarget(player, range, thrown ? 0.6f : 1.4f, out point);
			bool killed = false;
			if ((Object)(object)val2 != (Object)null)
			{
				killed = ApplyHit(player, val2, profile, item, point, val);
				RaiseSkill(player, profile.Total, val);
			}
			Consume(player, item, thrown, killed, point, (Object)(object)val2 == (Object)null);
			return true;
		}

		private static Character FindTarget(Player player, float range, float radius, out Vector3 point)
		{
			//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_0008: 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_000f: 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_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			Vector3 eyePoint = ((Character)player).GetEyePoint();
			Vector3 lookDir = ((Character)player).GetLookDir();
			point = eyePoint + lookDir * range;
			RaycastHit[] array = Physics.SphereCastAll(eyePoint, radius, lookDir, range);
			if (array == null)
			{
				return null;
			}
			Character result = null;
			float num = float.MaxValue;
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val = array2[i];
				Character val2 = (((Object)(object)((RaycastHit)(ref val)).collider != (Object)null) ? ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<Character>() : null);
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2 == (Object)(object)player) && !val2.IsDead() && !(((RaycastHit)(ref val)).distance >= num))
				{
					result = val2;
					num = ((RaycastHit)(ref val)).distance;
					point = ((RaycastHit)(ref val)).point;
				}
			}
			return result;
		}

		private static bool ApplyHit(Player player, Character target, ImprovisedWeapon profile, ItemData item, Vector3 point, SkillType governing)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_000f: 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_001d: 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_002d: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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)
			HitData val = new HitData();
			profile.WriteInto(val);
			val.m_point = point;
			Vector3 val2 = ((Component)target).transform.position - ((Component)player).transform.position;
			val.m_dir = ((Vector3)(ref val2)).normalized;
			val.m_pushForce = profile.Weight * 12f;
			val.m_blockable = true;
			val.m_dodgeable = true;
			val.m_ranged = false;
			val.m_skill = governing;
			val.SetAttacker((Character)(object)player);
			if (profile.IsMetal && BrawlerModifiers.MetalStaggers)
			{
				val.m_staggerMultiplier = 3f;
			}
			target.Damage(val);
			string name = item.m_shared.m_name;
			Log.Debug($"Improvised hit with {name} for {profile.Total:0.0}.");
			return target.IsDead();
		}

		private static void RaiseSkill(Player player, float damage, SkillType skill)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!(damage <= 0f))
			{
				((Character)player).RaiseSkill(skill, Mathf.Clamp(damage * 0.03f, 0.05f, 1.2f));
			}
		}

		private static void Consume(Player player, ItemData item, bool thrown, bool killed, Vector3 point, bool missed)
		{
			//IL_0027: 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_007c: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			if (killed && BrawlerModifiers.KillSparesItem)
			{
				float num = BrawlerModifiers.KillStaminaReward();
				if (num > 0f)
				{
					((Character)player).AddStamina(num);
				}
				return;
			}
			float num2 = ItemWear.BaseBreakChance(item, ((Character)player).GetSkills().GetSkillLevel(CustomSkills.Brawler)) * BrawlerModifiers.BreakChanceMultiplier();
			ItemWear.Use(player, item, thrown ? 1f : num2);
			if (thrown && ItemWear.CanBreak(item) && Random.value > Mathf.Clamp01(num2))
			{
				ItemData obj = item.Clone();
				obj.m_stack = 1;
				ItemDrop.DropItem(obj, 1, point + Vector3.up * 0.3f, Quaternion.identity);
			}
		}
	}
	internal static class BrawlerFavourites
	{
		private const int HotbarRow = 0;

		internal const string DefaultFavouriteKeys = "favorit,favourit,lock,pin,quickslot";

		internal static bool IsProtected(ItemData item)
		{
			if (item == null)
			{
				return true;
			}
			if (item.m_equipped)
			{
				return true;
			}
			if (InHotbar(item))
			{
				ConfigEntry<bool> brawlerSpareHotbar = ModConfig.BrawlerSpareHotbar;
				if (brawlerSpareHotbar == null || brawlerSpareHotbar.Value)
				{
					return true;
				}
			}
			return HasFavouriteFlag(item);
		}

		private static bool InHotbar(ItemData item)
		{
			return item.m_gridPos.y == 0;
		}

		private static bool HasFavouriteFlag(ItemData item)
		{
			Dictionary<string, string> customData = item.m_customData;
			if (customData == null || customData.Count == 0)
			{
				return false;
			}
			string text = ModConfig.BrawlerFavouriteKeys?.Value;
			if (string.IsNullOrEmpty(text))
			{
				text = "favorit,favourit,lock,pin,quickslot";
			}
			foreach (string key in customData.Keys)
			{
				if (string.IsNullOrEmpty(key))
				{
					continue;
				}
				string[] array = text.Split(',');
				for (int i = 0; i < array.Length; i++)
				{
					string text2 = array[i].Trim();
					if (text2.Length != 0 && key.IndexOf(text2, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
			}
			return false;
		}

		internal static string Reason(ItemData item)
		{
			if (item == null)
			{
				return "nothing there";
			}
			if (item.m_equipped)
			{
				return "equipped";
			}
			if (InHotbar(item))
			{
				return "on the hotbar";
			}
			if (HasFavouriteFlag(item))
			{
				return "favourited";
			}
			return "available";
		}
	}
	internal static class BrawlerHand
	{
		private static int _slot;

		internal static ItemData Readied(Player player)
		{
			ItemData val = BrawlerHover.Item();
			if (val?.m_shared != null && !val.m_equipped)
			{
				return val;
			}
			List<ItemData> list = Candidates(player);
			if (list.Count == 0)
			{
				return null;
			}
			if (_slot >= list.Count)
			{
				_slot = 0;
			}
			return list[_slot];
		}

		internal static void Cycle(Player player)
		{
			List<ItemData> list = Candidates(player);
			if (list.Count == 0)
			{
				((Character)player).Message((MessageType)2, AnythingAtAll(player) ? "Nothing free to hand - everything is equipped, on the hotbar or favourited" : "Nothing to hand", 0, (Sprite)null, false);
				return;
			}
			_slot = (_slot + 1) % list.Count;
			ItemData val = list[_slot];
			string text = (ItemWear.CanBreak(val) ? "breakable" : "wears, never breaks");
			((Character)player).Message((MessageType)2, "To hand: " + val.m_shared.m_name + " (" + text + ")", 0, (Sprite)null, false);
		}

		private static bool AnythingAtAll(Player player)
		{
			object obj;
			if (player == null)
			{
				obj = null;
			}
			else
			{
				Inventory inventory = ((Humanoid)player).GetInventory();
				obj = ((inventory != null) ? inventory.GetAllItems() : null);
			}
			List<ItemData> list = (List<ItemData>)obj;
			if (list != null)
			{
				return list.Count > 0;
			}
			return false;
		}

		private static List<ItemData> Candidates(Player player)
		{
			List<ItemData> list = new List<ItemData>();
			Inventory val = ((player != null) ? ((Humanoid)player).GetInventory() : null);
			if (val == null)
			{
				return list;
			}
			List<ItemData> allItems = val.GetAllItems();
			if (allItems == null)
			{
				return list;
			}
			foreach (ItemData item in allItems)
			{
				if (item?.m_shared != null && !BrawlerFavourites.IsProtected(item))
				{
					list.Add(item);
				}
			}
			return list;
		}
	}
	internal static class BrawlerHover
	{
		[HarmonyPatch(typeof(InventoryGrid), "GetHoveredElement")]
		internal static class Watch
		{
			[HarmonyPostfix]
			private static void Postfix(InventoryGrid __instance, InventoryElement __result)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: 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)
				if (!((Object)(object)__result == (Object)null))
				{
					Inventory val = (((Object)(object)__instance == (Object)null) ? null : __instance.GetInventory());
					if (val != null)
					{
						Vector2i position = __result.Position;
						Remember(val, position.x, position.y);
					}
				}
			}
		}

		private static Inventory _inventory;

		private static int _x;

		private static int _y;

		private static int _frame = -1;

		private const int Grace = 30;

		internal static ItemData Item()
		{
			if (_inventory == null)
			{
				return null;
			}
			if (!InventoryGui.IsVisible())
			{
				return null;
			}
			if (Time.frameCount - _frame > 30)
			{
				return null;
			}
			return _inventory.GetItemAt(_x, _y);
		}

		internal static void Remember(Inventory inventory, int x, int y)
		{
			_inventory = inventory;
			_x = x;
			_y = y;
			_frame = Time.frameCount;
		}

		internal static void Forget()
		{
			_inventory = null;
			_frame = -1;
		}
	}
	internal static class BrawlerInput
	{
		internal static ConfigEntry<KeyboardShortcut> SwingKey;

		internal static ConfigEntry<KeyboardShortcut> ThrowKey;

		internal static ConfigEntry<KeyboardShortcut> CycleKey;

		internal static void Bind(ConfigFile config)
		{
			//IL_0012: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			SwingKey = config.Bind<KeyboardShortcut>("Tavern Brawler", "SwingKey", new KeyboardShortcut((KeyCode)104, Array.Empty<KeyCode>()), "Swing the readied item as an improvised weapon. Was G, which Valheim uses for the radial menu.");
			ThrowKey = config.Bind<KeyboardShortcut>("Tavern Brawler", "ThrowKey", new KeyboardShortcut((KeyCode)107, Array.Empty<KeyCode>()), "Throw the readied item.");
			CycleKey = config.Bind<KeyboardShortcut>("Tavern Brawler", "CycleKey", new KeyboardShortcut((KeyCode)106, Array.Empty<KeyCode>()), "Ready the next item. Only needed with the inventory closed - with it open, whatever the mouse is over is the readied item.");
		}

		internal static void Tick(Player __instance)
		{
			//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)
			//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)
			//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_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_009f: 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)
			if (SwingKey == null || PerkPanel.IsOpen || Console.IsVisible() || TextInput.IsVisible() || ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus()))
			{
				return;
			}
			KeyboardShortcut value = CycleKey.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				BrawlerHand.Cycle(__instance);
				return;
			}
			value = SwingKey.Value;
			bool flag = ((KeyboardShortcut)(ref value)).IsDown();
			value = ThrowKey.Value;
			bool flag2 = ((KeyboardShortcut)(ref value)).IsDown();
			if (flag || flag2)
			{
				ItemData val = BrawlerHand.Readied(__instance);
				if (val == null)
				{
					value = CycleKey.Value;
					((Character)__instance).Message((MessageType)2, "Nothing to hand - point at something in your inventory, or press " + ((object)((KeyboardShortcut)(ref value)).MainKey/*cast due to .constrained prefix*/).ToString() + " to cycle", 0, (Sprite)null, false);
				}
				else if (flag)
				{
					BrawlerAttack.Swing(__instance, val);
				}
				else
				{
					BrawlerAttack.Throw(__instance, val);
				}
			}
		}
	}
	internal static class BrawlerModifiers
	{
		internal static readonly string[] ImplementedPerks = new string[6] { "tb1", "tb2", "tb3", "tb5", "tb6", "tb11" };

		internal static bool Unlocked => Rank("tb1") > 0;

		internal static bool MetalStaggers => Rank("tb6") > 0;

		internal static bool KillSparesItem => Rank("tb11") > 0;

		internal static void DeclareImplemented()
		{
			string[] implementedPerks = ImplementedPerks;
			for (int i = 0; i < implementedPerks.Length; i++)
			{
				PerkHandlerRegistry.MarkImplemented(implementedPerks[i], "Tavern Brawler attack system");
			}
		}

		private static int Rank(string nodeId)
		{
			return PerkState.Current.GetRank(nodeId);
		}

		internal static float BreakChanceMultiplier()
		{
			return Rank("tb2") switch
			{
				1 => 0.8f, 
				2 => 0.65f, 
				3 => 0.5f, 
				_ => 1f, 
			};
		}

		internal static float ThrownDamageMultiplier()
		{
			return Rank("tb3") switch
			{
				1 => 1.25f, 
				2 => 1.5f, 
				_ => 1f, 
			};
		}

		internal static float ThrowRange()
		{
			float num = 18f;
			if (Rank("tb3") <= 0)
			{
				return num;
			}
			return num * 1.3f;
		}

		internal static float CrowdMultiplier(Player player)
		{
			int num = Rank("tb5");
			if (num <= 0 || (Object)(object)player == (Object)null)
			{
				return 1f;
			}
			float num2 = ((num >= 3) ? 0.15f : ((num == 2) ? 0.1f : 0.05f));
			int num3 = Mathf.Min(3, CountEnemiesNear(player, 6f));
			return 1f + num2 * (float)num3;
		}

		internal static float MetalMultiplier()
		{
			return Rank("tb6") switch
			{
				1 => 1.5f, 
				2 => 2f, 
				_ => 1f, 
			};
		}

		internal static float KillStaminaReward()
		{
			return Rank("tb11") switch
			{
				1 => 15f, 
				2 => 30f, 
				_ => 0f, 
			};
		}

		private static int CountEnemiesNear(Player player, float radius)
		{
			//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_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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			List<Character> allCharacters = Character.GetAllCharacters();
			if (allCharacters == null)
			{
				return 0;
			}
			Vector3 position = ((Component)player).transform.position;
			foreach (Character item in allCharacters)
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item == (Object)(object)player) && !item.IsPlayer() && !item.IsDead())
				{
					Vector3 val = ((Component)item).transform.position - position;
					if (((Vector3)(ref val)).sqrMagnitude <= radius * radius)
					{
						num++;
					}
				}
			}
			return num;
		}
	}
	internal struct ImprovisedWeapon
	{
		internal float Blunt;

		internal float Pierce;

		internal float Slash;

		internal bool IsMetal;

		internal bool IsFood;

		internal float Weight;

		internal float Total => Blunt + Pierce + Slash;

		internal static ImprovisedWeapon From(ItemData item)
		{
			//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_005f: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			ImprovisedWeapon result = default(ImprovisedWeapon);
			if (item?.m_shared == null)
			{
				return result;
			}
			SharedData shared = item.m_shared;
			result.Weight = Mathf.Max(0.1f, shared.m_weight);
			result.Blunt = 4f + result.Weight * 3f;
			DamageTypes damages = shared.m_damages;
			result.Slash += damages.m_slash * 0.5f;
			result.Pierce += damages.m_pierce * 0.5f;
			result.Blunt += damages.m_blunt * 0.5f;
			if (shared.m_toolTier > 0 && result.Pierce <= 0f)
			{
				result.Pierce += (float)shared.m_toolTier * 2f;
			}
			result.IsFood = shared.m_food > 0f;
			result.IsMetal = IsMetallic(shared);
			return result;
		}

		private static bool IsMetallic(SharedData shared)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)shared.m_itemType != 1)
			{
				return false;
			}
			return shared.m_weight >= 8f;
		}

		internal void Scale(float multiplier)
		{
			Blunt *= multiplier;
			Pierce *= multiplier;
			Slash *= multiplier;
		}

		internal void WriteInto(HitData hit)
		{
			hit.m_damage.m_blunt += Blunt;
			hit.m_damage.m_pierce += Pierce;
			hit.m_damage.m_slash += Slash;
		}
	}
	internal static class ItemWear
	{
		internal enum Outcome
		{
			Wore,
			Survived,
			Broke
		}

		private const float WearPerUse = 0.04f;

		internal static bool CanBreak(ItemData item)
		{
			if (item?.m_shared != null)
			{
				return !item.m_shared.m_useDurability;
			}
			return false;
		}

		internal static Outcome Use(Player player, ItemData item, float breakChance)
		{
			if ((Object)(object)player == (Object)null || item?.m_shared == null)
			{
				return Outcome.Survived;
			}
			if (item.m_shared.m_useDurability)
			{
				Wear(item);
				return Outcome.Wore;
			}
			if (Random.value > Mathf.Clamp01(breakChance))
			{
				return Outcome.Survived;
			}
			Break(player, item);
			return Outcome.Broke;
		}

		private static void Wear(ItemData item)
		{
			float maxDurability = item.GetMaxDurability();
			if (!(maxDurability <= 0f))
			{
				float num = (item.m_shared.m_destroyBroken ? 1f : 0f);
				item.m_durability = Mathf.Max(num, item.m_durability - maxDurability * 0.04f);
			}
		}

		private static void Break(Player player, ItemData item)
		{
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory != null)
			{
				inventory.RemoveOneItem(item);
				Log.Debug("Improvised break: one " + item.m_shared.m_name + " destroyed.");
			}
		}

		internal static float BaseBreakChance(ItemData item, float skillLevel)
		{
			if (item?.m_shared == null)
			{
				return 0f;
			}
			float num = Mathf.Max(0.1f, item.m_shared.m_weight);
			return Mathf.Clamp(0.42f / Mathf.Sqrt(num + 0.5f) * (1f - Mathf.Clamp01(skillLevel / 100f) * 0.4f), 0.02f, 0.9f);
		}
	}
}
namespace Norntastic.Auras
{
	internal static class AuraBroadcast
	{
		internal const string ZdoKey = "nsg.aura";

		private static string _lastPublished = string.Empty;

		private static float _timer;

		private const float Interval = 0.5f;

		internal static void Tick(Player player, float dt)
		{
			_timer += dt;
			if (_timer < 0.5f)
			{
				return;
			}
			_timer = 0f;
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				string text = Build(PerkState.Current, player);
				if (!(text == _lastPublished) && Publish(player, text))
				{
					_lastPublished = text;
					Log.Debug("Published auras: '" + text + "'");
				}
			}
		}

		internal static void Reset()
		{
			_lastPublished = string.Empty;
			_timer = 0f;
		}

		internal static string Build(PerkState state)
		{
			return Build(state, null);
		}

		internal static string Build(PerkState state, Player wearer)
		{
			if (state == null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(24);
			AuraKind[] all = Auras.All;
			foreach (AuraKind auraKind in all)
			{
				float num = AuraSources.MagnitudeOf(state, auraKind);
				if (auraKind == AuraKind.Comfort && (Object)(object)wearer != (Object)null)
				{
					num += ClownBoots.ComfortFrom(wearer);
				}
				if (!(num <= 0f))
				{
					stringBuilder.Append(Auras.CodeFor(auraKind));
					stringBuilder.Append(num.ToString("0.#", CultureInfo.InvariantCulture));
				}
			}
			return stringBuilder.ToString();
		}

		internal static Dictionary<AuraKind, float> Parse(string payload)
		{
			Dictionary<AuraKind, float> dictionary = new Dictionary<AuraKind, float>();
			if (string.IsNullOrEmpty(payload))
			{
				return dictionary;
			}
			int i = 0;
			while (i < payload.Length)
			{
				AuraKind auraKind = Auras.FromCode(payload[i]);
				i++;
				if (auraKind != AuraKind.None)
				{
					int num = i;
					for (; i < payload.Length && (char.IsDigit(payload[i]) || payload[i] == '.'); i++)
					{
					}
					if (i != num && float.TryParse(payload.Substring(num, i - num), NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && result > 0f)
					{
						dictionary[auraKind] = result;
					}
				}
			}
			return dictionary;
		}

		private static bool Publish(Player player, string payload)
		{
			ZNetView value = Traverse.Create((object)player).Field<ZNetView>("m_nview").Value;
			if ((Object)(object)value == (Object)null || !value.IsValid() || !value.IsOwner())
			{
				return false;
			}
			ZDO zDO = value.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			zDO.Set("nsg.aura", payload);
			return true;
		}

		internal static string ReadFrom(Player other)
		{
			if ((Object)(object)other == (Object)null)
			{
				return string.Empty;
			}
			ZNetView value = Traverse.Create((object)other).Field<ZNetView>("m_nview").Value;
			if ((Object)(object)value == (Object)null || !value.IsValid())
			{
				return string.Empty;
			}
			ZDO zDO = value.GetZDO();
			if (zDO != null)
			{
				return zDO.GetString("nsg.aura", string.Empty);
			}
			return string.Empty;
		}
	}
	internal static class AuraSources
	{
		private static readonly Dictionary<AuraKind, KeyValuePair<string, float>[]> Feeds = new Dictionary<AuraKind, KeyValuePair<string, float>[]>
		{
			{
				AuraKind.Crafting,
				new KeyValuePair<string, float>[2]
				{
					new KeyValuePair<string, float>("lt2", 1.5f),
					new KeyValuePair<string, float>("lt3", 2f)
				}
			},
			{
				AuraKind.Gathering,
				new KeyValuePair<string, float>[2]
				{
					new KeyValuePair<string, float>("lt4", 2f),
					new KeyValuePair<string, float>("lt5", 2.5f)
				}
			},
			{
				AuraKind.Building,
				new KeyValuePair<string, float>[2]
				{
					new KeyValuePair<string, float>("lt6", 1f),
					new KeyValuePair<string, float>("lt7", 1.5f)
				}
			},
			{
				AuraKind.Comfort,
				new KeyValuePair<string, float>[2]
				{
					new KeyValuePair<string, float>("lt8", 2f),
					new KeyValuePair<string, float>("lt9", 2.5f)
				}
			},
			{
				AuraKind.Guard,
				new KeyValuePair<string, float>[2]
				{
					new KeyValuePair<string, float>("bl7", 5f),
					new KeyValuePair<string, float>("sh12", 12f)
				}
			},
			{
				AuraKind.Vigour,
				new KeyValuePair<string, float>[1]
				{
					new KeyValuePair<string, float>("tr9", 10f)
				}
			}
		};

		private static readonly AuraKind[] Ungated = new AuraKind[2]
		{
			AuraKind.Guard,
			AuraKind.Vigour
		};

		private const string CapstoneId = "lt12";

		private const float CapstoneMultiplier = 1.5f;

		private const string RootId = "lt1";

		private static bool NeedsRoot(AuraKind kind)
		{
			AuraKind[] ungated = Ungated;
			for (int i = 0; i < ungated.Length; i++)
			{
				if (ungated[i] == kind)
				{
					return false;
				}
			}
			return true;
		}

		internal static float MagnitudeOf(PerkState state, AuraKind kind)
		{
			if (state == null)
			{
				return 0f;
			}
			if (NeedsRoot(kind) && state.GetRank("lt1") <= 0)
			{
				return 0f;
			}
			if (!Feeds.TryGetValue(kind, out var value))
			{
				return 0f;
			}
			float num = 0f;
			KeyValuePair<string, float>[] array = value;
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<string, float> keyValuePair = array[i];
				num += (float)state.GetRank(keyValuePair.Key) * keyValuePair.Value;
			}
			if (num <= 0f)
			{
				return 0f;
			}
			if (NeedsRoot(kind) && state.GetRank("lt12") > 0)
			{
				num *= 1.5f;
			}
			return Mathf.Round(num * 10f) / 10f;
		}

		internal static IEnumerable<string> NodeIds()
		{
			yield return "lt1";
			foreach (KeyValuePair<AuraKind, KeyValuePair<string, float>[]> feed in Feeds)
			{
				KeyValuePair<string, float>[] value = feed.Value;
				foreach (KeyValuePair<string, float> keyValuePair in value)
				{
					yield return keyValuePair.Key;
				}
			}
			yield return "lt12";
		}
	}
	internal enum AuraKind
	{
		None,
		Crafting,
		Gathering,
		Building,
		Comfort,
		Guard,
		Vigour
	}
	internal static class Auras
	{
		internal const float Radius = 14f;

		internal static readonly AuraKind[] All = new AuraKind[6]
		{
			AuraKind.Crafting,
			AuraKind.Gathering,
			AuraKind.Building,
			AuraKind.Comfort,
			AuraKind.Guard,
			AuraKind.Vigour
		};

		internal static EffectKind EffectFor(AuraKind kind)
		{
			return kind switch
			{
				AuraKind.Crafting => EffectKind.ArmorPct, 
				AuraKind.Gathering => EffectKind.StaminaRegenPct, 
				AuraKind.Building => EffectKind.DamageTakenPct, 
				AuraKind.Comfort => EffectKind.HealthRegenPct, 
				AuraKind.Guard => EffectKind.DamageTakenPct, 
				AuraKind.Vigour => EffectKind.StaminaRegenPct, 
				_ => EffectKind.Pending, 
			};
		}

		internal static float SignFor(AuraKind kind)
		{
			if (kind != AuraKind.Building && kind != AuraKind.Guard)
			{
				return 1f;
			}
			return -1f;
		}

		internal static char CodeFor(AuraKind kind)
		{
			return kind switch
			{
				AuraKind.Crafting => 'c', 
				AuraKind.Gathering => 'g', 
				AuraKind.Building => 'b', 
				AuraKind.Comfort => 'h', 
				AuraKind.Guard => 'd', 
				AuraKind.Vigour => 'v', 
				_ => '?', 
			};
		}

		internal static AuraKind FromCode(char code)
		{
			return code switch
			{
				'c' => AuraKind.Crafting, 
				'g' => AuraKind.Gathering, 
				'b' => AuraKind.Building, 
				'h' => AuraKind.Comfort, 
				'd' => AuraKind.Guard, 
				'v' => AuraKind.Vigour, 
				_ => AuraKind.None, 
			};
		}

		internal static string NameOf(AuraKind kind)
		{
			return kind switch
			{
				AuraKind.Crafting => "Smith's Work", 
				AuraKind.Gathering => "Provision", 
				AuraKind.Building => "Raised Roof", 
				AuraKind.Comfort => "Hearth", 
				AuraKind.Guard => "Shield Wall", 
				AuraKind.Vigour => "Beacon", 
				_ => "none", 
			};
		}
	}
	internal static class AuraReceiver
	{
		private static readonly Dictionary<AuraKind, float> Received = new Dictionary<AuraKind, float>();

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

		private const float Interval = 0.5f;

		private static float _timer;

		internal static int ContributorCount => Contributors.Count;

		internal static IEnumerable<string> Describe()
		{
			foreach (KeyValuePair<AuraKind, float> item in Received)
			{
				yield return $"{Auras.NameOf(item.Key)}: {item.Value:0.#}%";
			}
		}

		internal static void Reset()
		{
			Received.Clear();
			Contributors.Clear();
			_timer = 0f;
		}

		internal static void Tick(Player player, float dt)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			_timer += dt;
			if (_timer < 0.5f)
			{
				return;
			}
			_timer = 0f;
			Received.Clear();
			Contributors.Clear();
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null)
			{
				return;
			}
			Vector3 position = ((Component)player).transform.position;
			float num = 196f;
			foreach (Player item in allPlayers)
			{
				if ((Object)(object)item == (Object)null || ((Character)item).IsDead())
				{
					continue;
				}
				if ((Object)(object)item != (Object)(object)player)
				{
					Vector3 val = ((Component)item).transform.position - position;
					if (((Vector3)(ref val)).sqrMagnitude > num)
					{
						continue;
					}
				}
				string text = (((Object)(object)item == (Object)(object)player) ? AuraBroadcast.Build(PerkState.Current) : AuraBroadcast.ReadFrom(item));
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				Dictionary<AuraKind, float> dictionary = AuraBroadcast.Parse(text);
				if (dictionary.Count == 0)
				{
					continue;
				}
				foreach (KeyValuePair<AuraKind, float> item2 in dictionary)
				{
					Received.TryGetValue(item2.Key, out var value);
					Received[item2.Key] = value + item2.Value;
				}
				Contributors.Add(((Object)(object)item == (Object)(object)player) ? "you" : item.GetPlayerName());
			}
		}

		internal static void Contribute(EffectAggregator.Sink sink)
		{
			foreach (KeyValuePair<AuraKind, float> item in Received)
			{
				EffectKind effectKind = Auras.EffectFor(item.Key);
				if (effectKind != EffectKind.Pending)
				{
					sink(effectKind, (SkillType)0, allSkills: true, item.Value * Auras.SignFor(item.Key));
				}
			}
		}

		internal static float Of(AuraKind kind)
		{
			if (!Received.TryGetValue(kind, out var value))
			{
				return 0f;
			}
			return value;
		}
	}
}