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

[assembly: ComVisible(false)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Guid("E0E2F92E-557C-4A05-9D89-AA92A0BD75C4")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyFileVersion("2.2.2")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Taeguk")]
[assembly: AssemblyProduct("TGServerAssets")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyTitle("TGServerAssets")]
[assembly: AssemblyDescription("")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.2.2.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<94b8a150-ee07-4a3e-bbc4-821a1a2a1c80>Embedded]
	internal sealed class <94b8a150-ee07-4a3e-bbc4-821a1a2a1c80>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<94b8a150-ee07-4a3e-bbc4-821a1a2a1c80>Embedded]
	internal sealed class <9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<94b8a150-ee07-4a3e-bbc4-821a1a2a1c80>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace TGServerAssets
{
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[BepInPlugin("Taeguk.TGServerAssets", "TGServerAssets", "2.2.2")]
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	public class TGServerAssetsPlugin : BaseUnityPlugin
	{
		[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)]
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order = null;

			[UsedImplicitly]
			public bool? Browsable = null;

			[UsedImplicitly]
			[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
			public string Category = null;

			[UsedImplicitly]
			[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(new byte[] { 2, 1 })]
			public Action<ConfigEntryBase> CustomDrawer = null;
		}

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
		private class AcceptableShortcuts : AcceptableValueBase
		{
			public AcceptableShortcuts()
				: base(typeof(KeyboardShortcut))
			{
			}

			public override object Clamp(object value)
			{
				return value;
			}

			public override bool IsValid(object value)
			{
				return true;
			}

			public override string ToDescriptionString()
			{
				return "# Acceptable values: " + string.Join(", ", UnityInput.Current.SupportedKeyCodes);
			}
		}

		internal const string ModName = "TGServerAssets";

		internal const string ModVersion = "2.2.2";

		internal const string Author = "Taeguk";

		private const string ModGUID = "Taeguk.TGServerAssets";

		private static string ConfigFileName = "Taeguk.TGServerAssets.cfg";

		private static string ConfigFileFullPath;

		internal static string ConnectionError;

		private readonly Harmony _harmony = new Harmony("Taeguk.TGServerAssets");

		public static readonly ManualLogSource TGServerAssetsLogger;

		private static readonly ConfigSync ConfigSync;

		public Texture2D tex = null;

		private static ConfigEntry<Toggle> _serverConfigLocked;

		public void Awake()
		{
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			_serverConfigLocked = config("1 - General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.");
			ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
			Item item = new Item("tgserverassets", "ArmorCarapaceChestTG");
			item.Name.English("Reinforced Carapace Cuirass");
			item.Description.English("Reinforced carapace breastplate that enchances blocking and mace skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item.RequiredItems.Add("ArmorCarapaceChest", 1);
			item.RequiredItems.Add("ReinforcedCarapace", 20);
			item.RequiredItems.Add("ScaleHide", 3);
			item.RequiredItems.Add("YagluthDrop", 1);
			item.RequiredUpgradeItems.Add("ReinforcedCarapace", 10);
			item.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item2 = new Item("tgserverassets", "ArmorCarapaceLegsTG");
			item2.Name.English("Reinforced Carapace Greaves");
			item2.Description.English("Reinforced carapace greaves that enchances blocking and mace skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item2.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item2.RequiredItems.Add("ArmorCarapaceLegs", 1);
			item2.RequiredItems.Add("ReinforcedCarapace", 20);
			item2.RequiredItems.Add("ScaleHide", 3);
			item2.RequiredItems.Add("YagluthDrop", 1);
			item2.RequiredUpgradeItems.Add("ReinforcedCarapace", 10);
			item2.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item3 = new Item("tgserverassets", "HelmetCarapaceTG");
			item3.Name.English("Reinforced Carapace Helmet");
			item3.Description.English("Reinforced carapace helmet that enchances blocking and mace skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item3.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item3.RequiredItems.Add("HelmetCarapace", 1);
			item3.RequiredItems.Add("ReinforcedCarapace", 16);
			item3.RequiredItems.Add("ScaleHide", 3);
			item3.RequiredItems.Add("YagluthDrop", 1);
			item3.RequiredUpgradeItems.Add("ReinforcedCarapace", 8);
			item3.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item4 = new Item("tgserverassets", "ArmorFenringChestTG");
			item4.Name.English("Reinforced Fenris Coat");
			item4.Description.English("Reinforced fenris coat that maintains the set effect when worn with the rest of the set.  Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item4.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item4.RequiredItems.Add("ArmorFenringChest", 1);
			item4.RequiredItems.Add("ReinforcedWolfHairBundle", 20);
			item4.RequiredItems.Add("WolfPelt", 5);
			item4.RequiredItems.Add("YagluthDrop", 1);
			item4.RequiredUpgradeItems.Add("ReinforcedWolfHairBundle", 5);
			item4.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item5 = new Item("tgserverassets", "ArmorFenringLegsTG");
			item5.Name.English("Reinforced Fenris Leggings");
			item5.Description.English("Reinforced fenris leggings that maintains the set effect when worn with the rest of the set.  Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item5.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item5.RequiredItems.Add("ArmorFenringLegs", 1);
			item5.RequiredItems.Add("ReinforcedWolfHairBundle", 20);
			item5.RequiredItems.Add("WolfPelt", 5);
			item5.RequiredItems.Add("YagluthDrop", 1);
			item5.RequiredUpgradeItems.Add("ReinforcedWolfHairBundle", 5);
			item5.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item6 = new Item("tgserverassets", "HelmetFenringTG");
			item6.Name.English("Reinforced Fenris Hood");
			item6.Description.English("Reinforced fenris hood that maintains the set effect when worn with the rest of the set.  Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item6.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item6.RequiredItems.Add("HelmetFenring", 1);
			item6.RequiredItems.Add("ReinforcedWolfHairBundle", 20);
			item6.RequiredItems.Add("WolfPelt", 5);
			item6.RequiredItems.Add("YagluthDrop", 1);
			item6.RequiredUpgradeItems.Add("ReinforcedWolfHairBundle", 5);
			item6.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item7 = new Item("tgserverassets", "FistFenrirClawTG");
			item7.Name.English("Reinforced Flesh Rippers");
			item7.Description.English("Reinforced flesh rippers that has additional frost damage. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item7.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item7.RequiredItems.Add("FistFenrirClaw", 1);
			item7.RequiredItems.Add("ReinforcedWolfHairBundle", 10);
			item7.RequiredItems.Add("WolfClaw", 6);
			item7.RequiredItems.Add("YagluthDrop", 1);
			item7.RequiredUpgradeItems.Add("ReinforcedWolfHairBundle", 1);
			item7.RequiredUpgradeItems.Add("WolfClaw", 1);
			item7.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item8 = new Item("tgserverassets", "ArmorMageChestTG");
			item8.Name.English("Reinforced Eitr-weave Robe");
			item8.Description.English("Reinforced Eitr-weave robe that adds elemental and blood magic skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item8.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item8.RequiredItems.Add("ArmorMageChest", 1);
			item8.RequiredItems.Add("ReinforcedFeathers", 20);
			item8.RequiredItems.Add("LinenThread", 20);
			item8.RequiredItems.Add("YagluthDrop", 1);
			item8.RequiredUpgradeItems.Add("ReinforcedFeathers", 5);
			item8.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item9 = new Item("tgserverassets", "ArmorMageLegsTG");
			item9.Name.English("Reinforced Eitr-weaved Trousers");
			item9.Description.English("Reinforced Eitr-weave trousers that adds elemental and blood magic skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item9.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item9.RequiredItems.Add("ArmorMageLegs", 1);
			item9.RequiredItems.Add("ReinforcedFeathers", 20);
			item9.RequiredItems.Add("LinenThread", 20);
			item9.RequiredItems.Add("YagluthDrop", 1);
			item9.RequiredUpgradeItems.Add("ReinforcedFeathers", 5);
			item9.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item10 = new Item("tgserverassets", "HelmetMageTG");
			item10.Name.English("Reinforced Eitr-weaved Hood");
			item10.Description.English("Reinforced Eitr-weave hood that adds elemental and blood magic skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item10.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item10.RequiredItems.Add("HelmetMage", 1);
			item10.RequiredItems.Add("ReinforcedFeathers", 15);
			item10.RequiredItems.Add("LinenThread", 15);
			item10.RequiredItems.Add("YagluthDrop", 1);
			item10.RequiredUpgradeItems.Add("ReinforcedFeathers", 5);
			item10.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item11 = new Item("tgserverassets", "ArmorPaddedCuirassTG");
			item11.Name.English("Reinforced Padded Cuirass");
			item11.Description.English("Reinforced padded cuirass that adds sword and axe skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item11.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item11.RequiredItems.Add("ArmorPaddedCuirass", 1);
			item11.RequiredItems.Add("ReinforcedBlackMetal", 10);
			item11.RequiredItems.Add("LinenThread", 20);
			item11.RequiredItems.Add("YagluthDrop", 1);
			item11.RequiredUpgradeItems.Add("ReinforcedBlackMetal", 3);
			item11.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item12 = new Item("tgserverassets", "ArmorPaddedGreavesTG");
			item12.Name.English("Reinforced Padded Greaves");
			item12.Description.English("Reinforced padded greaves that adds sword and axe skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item12.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item12.RequiredItems.Add("ArmorPaddedGreaves", 1);
			item12.RequiredItems.Add("ReinforcedBlackMetal", 10);
			item12.RequiredItems.Add("LinenThread", 20);
			item12.RequiredItems.Add("YagluthDrop", 1);
			item12.RequiredUpgradeItems.Add("ReinforcedBlackMetal", 3);
			item12.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item13 = new Item("tgserverassets", "HelmetPaddedTG");
			item13.Name.English("Reinforced Padded Helmet");
			item13.Description.English("Reinforced padded helmet that adds sword and axe skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item13.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item13.RequiredItems.Add("HelmetPadded", 1);
			item13.RequiredItems.Add("ReinforcedBlackMetal", 10);
			item13.RequiredItems.Add("LinenThread", 15);
			item13.RequiredItems.Add("YagluthDrop", 1);
			item13.RequiredUpgradeItems.Add("ReinforcedBlackMetal", 2);
			item13.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item14 = new Item("tgserverassets", "ArmorRootChestTG");
			item14.Name.English("Reinforced Root Harnesk");
			item14.Description.English("Reinforced root harness that adds bow and crossbow skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item14.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item14.RequiredItems.Add("ArmorRootChest", 1);
			item14.RequiredItems.Add("ReinforcedElderBark", 10);
			item14.RequiredItems.Add("Root", 10);
			item14.RequiredItems.Add("YagluthDrop", 1);
			item14.RequiredUpgradeItems.Add("ReinforcedElderBark", 5);
			item14.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item15 = new Item("tgserverassets", "ArmorRootLegsTG");
			item15.Name.English("Reinforced Root Leggings");
			item15.Description.English("Reinforced root leggings that adds bow and crossbow skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item15.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item15.RequiredItems.Add("ArmorRootLegs", 1);
			item15.RequiredItems.Add("ReinforcedElderBark", 10);
			item15.RequiredItems.Add("Root", 10);
			item15.RequiredItems.Add("YagluthDrop", 1);
			item15.RequiredUpgradeItems.Add("ReinforcedElderBark", 5);
			item15.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item16 = new Item("tgserverassets", "HelmetRootTG");
			item16.Name.English("Reinforced Root Mask");
			item16.Description.English("Reinforced root mask that adds bow and crossbow skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item16.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item16.RequiredItems.Add("HelmetRoot", 1);
			item16.RequiredItems.Add("ReinforcedElderBark", 10);
			item16.RequiredItems.Add("Root", 10);
			item16.RequiredItems.Add("YagluthDrop", 1);
			item16.RequiredUpgradeItems.Add("ReinforcedElderBark", 5);
			item16.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item17 = new Item("tgserverassets", "ArmorTrollLeatherChestTG");
			item17.Name.English("Reinforced Troll Leather Tunic");
			item17.Description.English("Reinforced troll leather tunic that adds knife and more sneak skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item17.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item17.RequiredItems.Add("ArmorTrollLeatherChest", 1);
			item17.RequiredItems.Add("ReinforcedTrollHide", 5);
			item17.RequiredItems.Add("BoneFragments", 10);
			item17.RequiredItems.Add("YagluthDrop", 1);
			item17.RequiredUpgradeItems.Add("ReinforcedTrollHide", 2);
			item17.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item18 = new Item("tgserverassets", "ArmorTrollLeatherLegsTG");
			item18.Name.English("Reinforced Troll Leather Pants");
			item18.Description.English("Reinforced troll leather pants that adds knife and more sneak skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item18.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item18.RequiredItems.Add("ArmorTrollLeatherLegs", 1);
			item18.RequiredItems.Add("ReinforcedTrollHide", 5);
			item18.RequiredItems.Add("BoneFragments", 10);
			item18.RequiredItems.Add("YagluthDrop", 1);
			item18.RequiredUpgradeItems.Add("ReinforcedTrollHide", 2);
			item18.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item19 = new Item("tgserverassets", "HelmetTrollLeatherTG");
			item19.Name.English("Reinforced Troll Leather Hood");
			item19.Description.English("Reinforced troll leather hood that adds knife and more sneak skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item19.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item19.RequiredItems.Add("HelmetTrollLeather", 1);
			item19.RequiredItems.Add("ReinforcedTrollHide", 5);
			item19.RequiredItems.Add("BoneFragments", 3);
			item19.RequiredItems.Add("YagluthDrop", 1);
			item19.RequiredUpgradeItems.Add("ReinforcedTrollHide", 2);
			item19.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item20 = new Item("tgserverassets", "CapeTrollHideTG");
			item20.Name.English("Reinforced Troll Leather Cape");
			item20.Description.English("Reinforced troll leather cape that adds knife and more sneak skills when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item20.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item20.RequiredItems.Add("CapeTrollHide", 1);
			item20.RequiredItems.Add("ReinforcedTrollHide", 10);
			item20.RequiredItems.Add("BoneFragments", 10);
			item20.RequiredItems.Add("YagluthDrop", 1);
			item20.RequiredUpgradeItems.Add("ReinforcedTrollHide", 5);
			item20.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item21 = new Item("tgserverassets", "ArmorWolfChestTG");
			item21.Name.English("Reinforced Wolf Armor Chest");
			item21.Description.English("Reinforced wolf armor chest that adds spear and polearm skills and less jump stamina usage when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item21.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item21.RequiredItems.Add("ArmorWolfChest", 1);
			item21.RequiredItems.Add("ReinforcedWolfPelt", 20);
			item21.RequiredItems.Add("Chain", 1);
			item21.RequiredItems.Add("YagluthDrop", 1);
			item21.RequiredUpgradeItems.Add("ReinforcedWolfPelt", 5);
			item21.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item22 = new Item("tgserverassets", "ArmorWolfLegsTG");
			item22.Name.English("Reinforced Wolf Armor Legs");
			item22.Description.English("Reinforced wolf armor legs that adds spear and polearm skills and less jump stamina usage when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item22.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item22.RequiredItems.Add("ArmorWolfLegs", 1);
			item22.RequiredItems.Add("ReinforcedWolfPelt", 20);
			item22.RequiredItems.Add("WolfFang", 4);
			item22.RequiredItems.Add("YagluthDrop", 1);
			item22.RequiredUpgradeItems.Add("ReinforcedWolfPelt", 5);
			item22.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item23 = new Item("tgserverassets", "HelmetDrakeTG");
			item23.Name.English("Reinforced Drake Helmet");
			item23.Description.English("Reinforced drake helmet that adds spear and polearm skills and less jump stamina usage when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item23.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item23.RequiredItems.Add("HelmetDrake", 1);
			item23.RequiredItems.Add("ReinforcedWolfPelt", 20);
			item23.RequiredItems.Add("TrophyHatchling", 1);
			item23.RequiredItems.Add("YagluthDrop", 1);
			item23.RequiredUpgradeItems.Add("ReinforcedWolfPelt", 5);
			item23.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Item item24 = new Item("tgserverassets", "CapeWolfTG");
			item24.Name.English("Reinforced Wolf Cape");
			item24.Description.English("Reinforced wolf cape that adds spear and polearm skills and less jump stamina usage when worn with the rest of the set. Upgrade to restore its durability. It can be upgraded upto 4 times only.");
			item24.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item24.RequiredItems.Add("CapeWolf", 1);
			item24.RequiredItems.Add("ReinforcedWolfPelt", 6);
			item24.RequiredItems.Add("TrophyWolf", 1);
			item24.RequiredItems.Add("YagluthDrop", 1);
			item24.RequiredUpgradeItems.Add("ReinforcedWolfPelt", 2);
			item24.RequiredUpgradeItems.Add("YagluthDrop", 1);
			Location location = new Location("tgserverassets", "TreeCaveTG")
			{
				CanSpawn = false
			};
			BuildPiece.ConfigurationEnabled = false;
			BuildPiece buildPiece = new BuildPiece("tgserverassets", "piece_blackforge_ext3_tg");
			buildPiece.Name.English("Blackforge Cooler");
			buildPiece.Description.English("Upgrade for Blackforge");
			buildPiece.RequiredItems.Add("BlackCore", 4, recover: true);
			buildPiece.RequiredItems.Add("YggdrasilWood", 25, recover: true);
			buildPiece.RequiredItems.Add("Copper", 10, recover: true);
			buildPiece.Category.Set(BuildPieceCategory.Crafting);
			buildPiece.Crafting.Set(PieceManager.CraftingTable.BlackForge);
			BuildPiece buildPiece2 = new BuildPiece("tgserverassets", "piece_magetable_ext3_tg");
			buildPiece2.Name.English("Spirit Caller");
			buildPiece2.Description.English("Upgrade for Galdr table");
			buildPiece2.RequiredItems.Add("TrophySkeleton", 5, recover: true);
			buildPiece2.RequiredItems.Add("WitheredBone", 5, recover: true);
			buildPiece2.RequiredItems.Add("BoneFragments", 50, recover: true);
			buildPiece2.Category.Set(BuildPieceCategory.Crafting);
			buildPiece2.Crafting.Set(PieceManager.CraftingTable.MageTable);
			BuildPiece buildPiece3 = new BuildPiece("tgserverassets", "guard_stone_tg");
			buildPiece3.Name.English("Admin Ward");
			buildPiece3.Description.English("...");
			buildPiece3.RequiredItems.Add("SwordCheat", 999, recover: false);
			buildPiece3.Category.Set(BuildPieceCategory.Misc);
			buildPiece3.Crafting.Set(PieceManager.CraftingTable.None);
			buildPiece3.SpecialProperties = new SpecialProperties
			{
				AdminOnly = true,
				NoConfig = true
			};
			BuildPiece buildPiece4 = new BuildPiece("tgserverassets", "metal_recycler_tg");
			buildPiece4.Name.English("Recycler Furnace");
			buildPiece4.Description.English("A furnace to recycle metals from armors and weapons.");
			buildPiece4.RequiredItems.Add("Stone", 20, recover: true);
			buildPiece4.RequiredItems.Add("SurtlingCore", 5, recover: true);
			buildPiece4.RequiredItems.Add("Iron", 8, recover: true);
			buildPiece4.RequiredItems.Add("Thunderstone", 1, recover: true);
			buildPiece4.Category.Set(BuildPieceCategory.Crafting);
			buildPiece4.Crafting.Set(PieceManager.CraftingTable.Forge);
			Item item25 = new Item("tgserverassets", "ReinforcedCarapace");
			item25.Name.English("Reinforced Carapace");
			item25.Description.English("Carapace reinforced with iron.");
			item25.Crafting.Add(ItemManager.CraftingTable.BlackForge, 1);
			item25.RequiredItems.Add("Carapace", 1);
			item25.RequiredItems.Add("Iron", 1);
			Item item26 = new Item("tgserverassets", "ReinforcedFeathers");
			item26.Name.English("Reinforced Feathers");
			item26.Description.English("Feathers reinforced with eitr.");
			item26.Crafting.Add(ItemManager.CraftingTable.MageTable, 1);
			item26.RequiredItems.Add("Feathers", 1);
			item26.RequiredItems.Add("Eitr", 1);
			Item item27 = new Item("tgserverassets", "ReinforcedTrollHide");
			item27.Name.English("Reinforced Troll Leather");
			item27.Description.English("Troll Leather reinforced with bronze.");
			item27.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item27.RequiredItems.Add("TrollHide", 1);
			item27.RequiredItems.Add("Bronze", 1);
			Item item28 = new Item("tgserverassets", "ReinforcedWolfPelt");
			item28.Name.English("Reinforced Wolf Pelt");
			item28.Description.English("Wolf Pelt reinforced with silver.");
			item28.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item28.RequiredItems.Add("WolfPelt", 1);
			item28.RequiredItems.Add("Silver", 1);
			Item item29 = new Item("tgserverassets", "ReinforcedElderBark");
			item29.Name.English("Reinforced Ancient Bark");
			item29.Description.English("Ancient bark reinforced with iron.");
			item29.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item29.RequiredItems.Add("ElderBark", 1);
			item29.RequiredItems.Add("Iron", 1);
			Item item30 = new Item("tgserverassets", "ReinforcedWolfHairBundle");
			item30.Name.English("Reinforced Fenris Hair");
			item30.Description.English("Wolf hair reinforced with silver.");
			item30.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item30.RequiredItems.Add("WolfHairBundle", 1);
			item30.RequiredItems.Add("Silver", 1);
			Item item31 = new Item("tgserverassets", "ReinforcedBlackMetal");
			item31.Name.English("Reinforced Blackmetal");
			item31.Description.English("Blackmetal reinforced with iron.");
			item31.Crafting.Add(ItemManager.CraftingTable.Forge, 1);
			item31.RequiredItems.Add("BlackMetal", 1);
			item31.RequiredItems.Add("Iron", 1);
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			SetupWatcher();
			if (saveOnConfigSet)
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
				((BaseUnityPlugin)this).Config.Save();
			}
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				TGServerAssetsLogger.LogDebug((object)"ReadConfigValues called");
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch
			{
				TGServerAssetsLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
				TGServerAssetsLogger.LogError((object)"Please check your config entries for spelling and format!");
			}
		}

		private ConfigEntry<T> config<[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)] T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			SyncedConfigEntry<T> syncedConfigEntry = ConfigSync.AddConfigEntry<T>(val2);
			syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		private ConfigEntry<T> config<[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)] T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		static TGServerAssetsPlugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			TGServerAssetsLogger = Logger.CreateLogSource("TGServerAssets");
			ConfigSync = new ConfigSync("Taeguk.TGServerAssets")
			{
				DisplayName = "TGServerAssets",
				CurrentVersion = "2.2.2",
				MinimumRequiredVersion = "2.2.2"
			};
			_serverConfigLocked = null;
		}
	}
	public static class KeyboardExtensions
	{
		public static bool IsKeyDown(this KeyboardShortcut shortcut)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return (int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
		}

		public static bool IsKeyHeld(this KeyboardShortcut shortcut)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return (int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class RegisterAndCheckVersion
	{
		[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			TGServerAssetsPlugin.TGServerAssetsLogger.LogDebug((object)"Registering version RPC handler");
			peer.m_rpc.Register<ZPackage>("TGServerAssets_VersionCheck", (Action<ZRpc, ZPackage>)RpcHandlers.RPC_TGServerAssets_Version);
			TGServerAssetsPlugin.TGServerAssetsLogger.LogDebug((object)"Invoking version check");
			ZPackage val = new ZPackage();
			val.Write("2.2.2");
			peer.m_rpc.Invoke("TGServerAssets_VersionCheck", new object[1] { val });
		}
	}
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	public static class VerifyClient
	{
		private static bool Prefix(ZRpc rpc, ZPackage pkg, ref ZNet __instance)
		{
			if (!__instance.IsServer() || RpcHandlers.ValidatedPeers.Contains(rpc))
			{
				return true;
			}
			TGServerAssetsPlugin.TGServerAssetsLogger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") never sent version or couldn't due to previous disconnect, disconnecting"));
			rpc.Invoke("Error", new object[1] { 3 });
			return false;
		}

		private static void Postfix(ZNet __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "TGServerAssetsRequestAdminSync", new object[1] { (object)new ZPackage() });
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	public class ShowConnectionError
	{
		[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
		private static void Postfix(FejdStartup __instance)
		{
			if (__instance.m_connectionFailedPanel.activeSelf)
			{
				__instance.m_connectionFailedError.fontSizeMax = 25f;
				__instance.m_connectionFailedError.fontSizeMin = 15f;
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + TGServerAssetsPlugin.ConnectionError;
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class RemoveDisconnectedPeerFromVerified
	{
		[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			if (__instance.IsServer())
			{
				TGServerAssetsPlugin.TGServerAssetsLogger.LogInfo((object)("Peer (" + peer.m_rpc.m_socket.GetHostName() + ") disconnected, removing from validated list"));
				RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
			}
		}
	}
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	public static class RpcHandlers
	{
		public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

		public static void RPC_TGServerAssets_Version(ZRpc rpc, ZPackage pkg)
		{
			string text = pkg.ReadString();
			TGServerAssetsPlugin.TGServerAssetsLogger.LogInfo((object)("Version check, local: 2.2.2,  remote: " + text));
			if (text != "2.2.2")
			{
				TGServerAssetsPlugin.ConnectionError = "TGServerAssets Installed: 2.2.2\n Needed: " + text;
				if (ZNet.instance.IsServer())
				{
					TGServerAssetsPlugin.TGServerAssetsLogger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") has incompatible version, disconnecting..."));
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (!ZNet.instance.IsServer())
			{
				TGServerAssetsPlugin.TGServerAssetsLogger.LogInfo((object)"Received same version from server!");
			}
			else
			{
				TGServerAssetsPlugin.TGServerAssetsLogger.LogInfo((object)("Adding peer (" + rpc.m_socket.GetHostName() + ") to validated list"));
				ValidatedPeers.Add(rpc);
			}
		}
	}
}
namespace StatusEffectManager
{
	[PublicAPI]
	[Description("The ItemDrop effect to apply the status effect")]
	public enum EffectType
	{
		Equip,
		Attack,
		Consume,
		Set
	}
	public struct SE_Item
	{
		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(1)]
		public StatusEffect Effect;

		public EffectType Type;
	}
	[PublicAPI]
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	public class CustomSE
	{
		private static readonly List<CustomSE> RegisteredEffects = new List<CustomSE>();

		private static readonly Dictionary<StatusEffect, CustomSE> CustomEffectMap = new Dictionary<StatusEffect, CustomSE>();

		internal static readonly List<StatusEffect> CustomSEs = new List<StatusEffect>();

		internal static readonly Dictionary<SE_Item, string> AddToPrefabs = new Dictionary<SE_Item, string>();

		[Description("Instance of the StatusEffect.")]
		public readonly StatusEffect Effect;

		public EffectType Type;

		private string _folderName = "icons";

		private AssetBundle _assetBundle = null;

		[Description("Sets the icon for the StatusEffect. Must be 64x64")]
		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		public Sprite IconSprite = null;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private string IconName = null;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private LocalizeKey _name;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static Localization _english;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static BaseUnityPlugin _plugin;

		private static bool hasConfigSync = true;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static object _configSync;

		[Description("Sets the icon for the StatusEffect. Must be 64x64")]
		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		public string Icon
		{
			[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(2)]
			get
			{
				return IconName;
			}
			[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(2)]
			set
			{
				IconName = value;
				IconSprite = ((IconName == null) ? null : loadSprite(IconName));
				Effect.m_icon = IconSprite;
			}
		}

		[Description("Sets the in-game name for the StatusEffect")]
		public LocalizeKey Name
		{
			get
			{
				LocalizeKey name = _name;
				if (name != null)
				{
					return name;
				}
				StatusEffect effect = Effect;
				if (effect.m_name.StartsWith("$"))
				{
					_name = new LocalizeKey(effect.m_name);
				}
				else
				{
					string text = "$statuseffect_" + ((Object)Effect).name.Replace(" ", "_");
					_name = new LocalizeKey(text).English(effect.m_name);
					effect.m_name = text;
				}
				return _name;
			}
		}

		private static Localization english
		{
			get
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Expected O, but got Unknown
				if (_english == null)
				{
					_english = new Localization();
					_english.SetupLanguage("English");
				}
				return _english;
			}
		}

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static object configSync
		{
			[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(2)]
			get
			{
				if (_configSync == null && hasConfigSync)
				{
					Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
					if ((object)type != null)
					{
						_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " ItemManager");
						type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
						type.GetProperty("IsLocked").SetValue(_configSync, true);
					}
					else
					{
						hasConfigSync = false;
					}
				}
				return _configSync;
			}
		}

		public CustomSE(string assetBundleFileName, string customEffectName, string folderName = "assets")
			: this(EffectManager.RegisterAssetBundle(assetBundleFileName, folderName), customEffectName)
		{
		}

		public CustomSE(AssetBundle bundle, string customEffectName)
		{
			Effect = EffectManager.RegisterCustomSE(bundle, customEffectName);
			RegisteredEffects.Add(this);
			CustomEffectMap[Effect] = this;
		}

		public CustomSE(string customEffectName)
		{
			Effect = ScriptableObject.CreateInstance<StatusEffect>();
			EffectManager.RegisterCustomSE(Effect, customEffectName);
			RegisteredEffects.Add(this);
			CustomEffectMap[Effect] = this;
		}

		[return: <9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private byte[] ReadEmbeddedFileBytes(string name)
		{
			using MemoryStream memoryStream = new MemoryStream();
			Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + ((_folderName == "") ? "" : ".") + _folderName + "." + name);
			if (manifestResourceStream == null)
			{
				return null;
			}
			manifestResourceStream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		[return: <9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private Texture2D loadTexture(string name)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			byte[] array = ReadEmbeddedFileBytes(name);
			if (array != null)
			{
				Texture2D val = new Texture2D(0, 0);
				ImageConversion.LoadImage(val, array);
				return val;
			}
			return null;
		}

		private Sprite loadSprite(string name)
		{
			//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)
			Texture2D val = loadTexture(name);
			if (val != null)
			{
				return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), Vector2.zero);
			}
			AssetBundle assetBundle = _assetBundle;
			Sprite val2 = ((assetBundle != null) ? assetBundle.LoadAsset<Sprite>(name) : null);
			if (val2 != null)
			{
				return val2;
			}
			throw new FileNotFoundException("Could not find a file named " + name + " for the effect icon");
		}

		public void AddSEToPrefab(CustomSE customSE, string prefabName)
		{
			SE_Item sE_Item = default(SE_Item);
			sE_Item.Effect = customSE.Effect;
			sE_Item.Type = customSE.Type;
			SE_Item key = sE_Item;
			AddToPrefabs.Add(key, prefabName);
		}

		private static ConfigEntry<T> config<[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)] T>(string group, string name, T value, ConfigDescription description)
		{
			ConfigEntry<T> val = plugin.Config.Bind<T>(group, name, value, description);
			configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
				.Invoke(configSync, new object[1] { val });
			return val;
		}

		private static ConfigEntry<T> config<[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)] T>(string group, string name, T value, string description)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[PublicAPI]
	public class LocalizeKey
	{
		public readonly string Key;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private LocalizeKey addForLang(string lang, string value)
		{
			if (Localization.instance.GetSelectedLanguage() == lang)
			{
				Localization.instance.AddWord(Key, value);
			}
			else if (lang == "English" && !Localization.instance.m_translations.ContainsKey(Key))
			{
				Localization.instance.AddWord(Key, value);
			}
			return this;
		}
	}
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	public static class EffectManager
	{
		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		static EffectManager()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			Harmony val = new Harmony("org.bepinex.helpers.StatusEffectManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(EffectManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(EffectManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId bundleId = default(BundleId);
			bundleId.assetBundleFileName = assetBundleFileName;
			bundleId.folderName = folderName;
			BundleId key = bundleId;
			if (!bundleCache.TryGetValue(key, out var value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + ((folderName == "") ? "" : ".") + folderName + "." + assetBundleFileName));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static StatusEffect RegisterCustomSE(string assetBundleFileName, string customEffectName, string folderName = "assets")
		{
			return RegisterCustomSE(RegisterAssetBundle(assetBundleFileName, folderName), customEffectName);
		}

		public static StatusEffect RegisterCustomSE(AssetBundle assets, string customEffectName)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			StatusEffect val = (StatusEffect)assets.LoadAsset<ScriptableObject>(customEffectName);
			CustomSE.CustomSEs.Add(val);
			return val;
		}

		public static StatusEffect RegisterCustomSE(StatusEffect customSE, string customEffectName)
		{
			((Object)customSE).name = customEffectName;
			CustomSE.CustomSEs.Add(customSE);
			return customSE;
		}

		[HarmonyPriority(700)]
		private static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			foreach (StatusEffect customSE in CustomSE.CustomSEs)
			{
				if (!__instance.m_StatusEffects.Contains(customSE))
				{
					__instance.m_StatusEffects.Add(customSE);
				}
			}
			__instance.UpdateItemHashes();
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (KeyValuePair<SE_Item, string> addToPrefab in CustomSE.AddToPrefabs)
			{
				try
				{
					GameObject prefab = __instance.GetPrefab(addToPrefab.Value);
					ItemDrop val = (Object.op_Implicit((Object)(object)prefab) ? prefab.GetComponent<ItemDrop>() : prefab.GetComponentInChildren<ItemDrop>());
					Aoe val2 = (Object.op_Implicit((Object)(object)prefab) ? prefab.GetComponent<Aoe>() : prefab.GetComponentInChildren<Aoe>());
					EffectArea val3 = (Object.op_Implicit((Object)(object)prefab) ? prefab.GetComponent<EffectArea>() : prefab.GetComponentInChildren<EffectArea>());
					if (Object.op_Implicit((Object)(object)val))
					{
						switch (addToPrefab.Key.Type)
						{
						case EffectType.Equip:
							val.m_itemData.m_shared.m_equipStatusEffect = addToPrefab.Key.Effect;
							break;
						case EffectType.Attack:
							val.m_itemData.m_shared.m_attackStatusEffect = addToPrefab.Key.Effect;
							break;
						case EffectType.Consume:
							val.m_itemData.m_shared.m_consumeStatusEffect = addToPrefab.Key.Effect;
							break;
						case EffectType.Set:
							val.m_itemData.m_shared.m_setSize = 1;
							val.m_itemData.m_shared.m_setName = ((Object)addToPrefab.Key.Effect).name;
							val.m_itemData.m_shared.m_setStatusEffect = addToPrefab.Key.Effect;
							break;
						default:
							throw new ArgumentOutOfRangeException();
						}
					}
					else if (Object.op_Implicit((Object)(object)val2))
					{
						val2.m_statusEffect = ((Object)addToPrefab.Key.Effect).name;
					}
					else if (Object.op_Implicit((Object)(object)val3))
					{
						val3.m_statusEffect = ((Object)addToPrefab.Key.Effect).name;
					}
					else
					{
						Debug.LogWarning((object)("The prefab '" + ((Object)prefab).name + "' does not have an ItemDrop, AOE, or EffectArea component. Cannot add the StatusEffect to the prefab."));
					}
				}
				catch (Exception arg)
				{
					Debug.LogWarning((object)$"BROKE : {arg}");
				}
			}
		}
	}
}
namespace SkillManager
{
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	[PublicAPI]
	public class Skill
	{
		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
		public static class LocalizationCache
		{
			private static readonly Dictionary<string, Localization> localizations = new Dictionary<string, Localization>();

			internal static void LocalizationPostfix(Localization __instance, string language)
			{
				string key = localizations.FirstOrDefault([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (KeyValuePair<string, Localization> l) => l.Value == __instance).Key;
				if (key != null)
				{
					localizations.Remove(key);
				}
				if (!localizations.ContainsKey(language))
				{
					localizations.Add(language, __instance);
				}
			}

			public static Localization ForLanguage([<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)] string language = null)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				if (localizations.TryGetValue(language ?? PlayerPrefs.GetString("language", "English"), out var value))
				{
					return value;
				}
				value = new Localization();
				if (language != null)
				{
					value.SetupLanguage(language);
				}
				return value;
			}
		}

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
		[PublicAPI]
		public class LocalizeKey
		{
			private static readonly List<LocalizeKey> keys = new List<LocalizeKey>();

			public readonly string Key;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[HarmonyPriority(300)]
			internal static void AddLocalizedKeys(Localization __instance, string language)
			{
				foreach (LocalizeKey key in keys)
				{
					string value2;
					if (key.Localizations.TryGetValue(language, out var value) || key.Localizations.TryGetValue("English", out value))
					{
						__instance.AddWord(key.Key, value);
					}
					else if (key.Localizations.TryGetValue("alias", out value2))
					{
						__instance.AddWord(key.Key, Localization.instance.Localize(value2));
					}
				}
			}
		}

		[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
			[UsedImplicitly]
			public string Category;
		}

		[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)]
		[HarmonyPatch(typeof(Skills), "IsSkillValid")]
		private static class Patch_Skills_IsSkillValid
		{
			private static void Postfix(SkillType type, ref bool __result)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				if (!__result && skills.ContainsKey(type))
				{
					__result = true;
				}
			}
		}

		private static readonly Dictionary<SkillType, Skill> skills;

		internal static readonly Dictionary<string, Skill> skillByName;

		private readonly string skillName;

		private readonly string internalSkillName;

		private readonly SkillDef skillDef;

		public readonly LocalizeKey Name;

		public readonly LocalizeKey Description;

		private float skillEffectFactor = 1f;

		private int skillLoss = 5;

		public bool Configurable = false;

		private static bool InitializedTerminal;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static Localization _english;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static BaseUnityPlugin _plugin;

		private static bool hasConfigSync;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static object _configSync;

		public float SkillGainFactor
		{
			get
			{
				return skillDef.m_increseStep;
			}
			set
			{
				skillDef.m_increseStep = value;
				this.SkillGainFactorChanged?.Invoke(value);
			}
		}

		public float SkillEffectFactor
		{
			get
			{
				return skillEffectFactor;
			}
			set
			{
				skillEffectFactor = value;
				this.SkillEffectFactorChanged?.Invoke(value);
			}
		}

		public int SkillLoss
		{
			get
			{
				return skillLoss;
			}
			set
			{
				skillLoss = value;
				this.SkillLossChanged?.Invoke(value);
			}
		}

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

		private static BaseUnityPlugin plugin
		{
			get
			{
				//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_004c: Expected O, but got Unknown
				object obj = _plugin;
				if (obj == null)
				{
					BaseUnityPlugin val = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)Assembly.GetExecutingAssembly().DefinedTypes.First([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
					_plugin = val;
					obj = (object)val;
				}
				return (BaseUnityPlugin)obj;
			}
		}

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static object configSync
		{
			[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(2)]
			get
			{
				if (_configSync == null && hasConfigSync)
				{
					Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
					if ((object)type != null)
					{
						_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " SkillManager");
						type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
						type.GetProperty("IsLocked").SetValue(_configSync, true);
					}
					else
					{
						hasConfigSync = false;
					}
				}
				return _configSync;
			}
		}

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		[method: <9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(2)]
		[field: <9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		public event Action<float> SkillGainFactorChanged;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		[method: <9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(2)]
		[field: <9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		public event Action<float> SkillEffectFactorChanged;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		[method: <9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(2)]
		[field: <9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		public event Action<float> SkillLossChanged;

		public Skill(string englishName, string icon)
			: this(englishName, loadSprite(icon, 64, 64))
		{
		}

		public Skill(string englishName, Sprite icon)
		{
			//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_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_006f: 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_0082: 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_008d: Expected O, but got Unknown
			SkillType val = fromName(englishName);
			string text = new Regex("[^a-zA-Z]").Replace(englishName, "_");
			skills[val] = this;
			skillByName[englishName] = this;
			skillDef = new SkillDef
			{
				m_description = "$skilldesc_" + text,
				m_icon = icon,
				m_increseStep = 1f,
				m_skill = val
			};
			internalSkillName = text;
			skillName = englishName;
			Name = new LocalizeKey("skill_" + ((object)(SkillType)(ref val)).ToString()).English(englishName);
			Description = new LocalizeKey("skilldesc_" + text);
		}

		public static SkillType fromName(string englishName)
		{
			return (SkillType)Math.Abs(StringExtensionMethods.GetStableHashCode(englishName));
		}

		static Skill()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_0185: 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_01ad: Expected O, but got Unknown
			//IL_01ad: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_023f: Expected O, but got Unknown
			skills = new Dictionary<SkillType, Skill>();
			skillByName = new Dictionary<string, Skill>();
			InitializedTerminal = false;
			hasConfigSync = true;
			Harmony val = new Harmony("org.bepinex.helpers.skillmanager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "GetSkillDef", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_GetSkillDef", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "CheatRaiseSkill", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_CheatRaiseskill", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "CheatResetSkill", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_CheatResetSkill", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizeKey), "AddLocalizedKeys", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Terminal), "InitTerminal", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Terminal_InitTerminal_Prefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Terminal_InitTerminal", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizationCache), "LocalizationPostfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "OnDeath", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_OnDeath_Prefix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_OnDeath_Finalizer", (Type[])null, (Type[])null)), (HarmonyMethod)null);
		}

		private static void Patch_FejdStartup()
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			foreach (Skill skill in skills.Values)
			{
				if (skill.Configurable)
				{
					string key = skill.Name.Key;
					string group = new Regex("['[\"\\]]").Replace(english.Localize(key), "").Trim();
					string category = Localization.instance.Localize(key).Trim();
					ConfigEntry<float> skillGain = config(group, "Skill gain factor", skill.SkillGainFactor, new ConfigDescription("The rate at which you gain experience for the skill.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 5f), new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = category
						}
					}));
					skill.SkillGainFactor = skillGain.Value;
					skillGain.SettingChanged += [<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (object _, EventArgs _) =>
					{
						skill.SkillGainFactor = skillGain.Value;
					};
					ConfigEntry<float> skillEffect = config(group, "Skill effect factor", skill.SkillEffectFactor, new ConfigDescription("The power of the skill, based on the default power.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 5f), new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = category
						}
					}));
					skill.SkillEffectFactor = skillEffect.Value;
					skillEffect.SettingChanged += [<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (object _, EventArgs _) =>
					{
						skill.SkillEffectFactor = skillEffect.Value;
					};
					ConfigEntry<int> skillLoss = config(group, "Skill loss", skill.skillLoss, new ConfigDescription("How much experience to lose on death.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = category
						}
					}));
					skill.skillLoss = skillLoss.Value;
					skillLoss.SettingChanged += [<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (object _, EventArgs _) =>
					{
						skill.skillLoss = skillLoss.Value;
					};
				}
			}
		}

		private static void Patch_Skills_GetSkillDef([<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)] ref SkillDef __result, List<SkillDef> ___m_skills, SkillType type)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (__result == null)
			{
				SkillDef val = GetSkillDef(type);
				if (val != null)
				{
					___m_skills.Add(val);
					__result = val;
				}
			}
		}

		private static bool Patch_Skills_CheatRaiseskill(Skills __instance, string name, float value, Player ___m_player)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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)
			foreach (SkillType key in skills.Keys)
			{
				SkillType current = key;
				Skill skill = skills[current];
				if (string.Equals(skill.internalSkillName, name, StringComparison.CurrentCultureIgnoreCase))
				{
					Skill skill2 = __instance.GetSkill(current);
					skill2.m_level += value;
					skill2.m_level = Mathf.Clamp(skill2.m_level, 0f, 100f);
					((Character)___m_player).Message((MessageType)1, "Skill increased " + Localization.instance.Localize("$skill_" + ((object)(SkillType)(ref current)).ToString()) + ": " + (int)skill2.m_level, 0, skill2.m_info.m_icon);
					Console.instance.Print("Skill " + skill.internalSkillName + " = " + skill2.m_level);
					return false;
				}
			}
			return true;
		}

		private static bool Patch_Skills_CheatResetSkill(Skills __instance, string name)
		{
			//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_0022: 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)
			foreach (SkillType key in skills.Keys)
			{
				Skill skill = skills[key];
				if (string.Equals(skill.internalSkillName, name, StringComparison.CurrentCultureIgnoreCase))
				{
					__instance.ResetSkill(key);
					Console.instance.Print("Skill " + skill.internalSkillName + " reset");
					return false;
				}
			}
			return true;
		}

		private static void Patch_Skills_OnDeath_Prefix(Skills __instance, [<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(new byte[] { 2, 1 })] ref Dictionary<SkillType, Skill> __state)
		{
			//IL_002e: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			if (__state == null)
			{
				__state = new Dictionary<SkillType, Skill>();
			}
			foreach (KeyValuePair<SkillType, Skill> skill in skills)
			{
				if (__instance.m_skillData.TryGetValue(skill.Key, out var value))
				{
					__state[skill.Key] = value;
					if (skill.Value.skillLoss > 0)
					{
						Skill obj = value;
						obj.m_level -= value.m_level * (float)skill.Value.SkillLoss / 100f;
						value.m_accumulator = 0f;
					}
					__instance.m_skillData.Remove(skill.Key);
				}
			}
		}

		private static void Patch_Skills_OnDeath_Finalizer(Skills __instance, [<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(new byte[] { 2, 1 })] ref Dictionary<SkillType, Skill> __state)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (__state == null)
			{
				return;
			}
			foreach (KeyValuePair<SkillType, Skill> item in __state)
			{
				__instance.m_skillData[item.Key] = item.Value;
			}
			__state = null;
		}

		private static void Patch_Terminal_InitTerminal_Prefix()
		{
			InitializedTerminal = Terminal.m_terminalInitialized;
		}

		private static void Patch_Terminal_InitTerminal()
		{
			if (!InitializedTerminal)
			{
				AddSkill(Terminal.commands["raiseskill"]);
				AddSkill(Terminal.commands["resetskill"]);
			}
			static void AddSkill(ConsoleCommand command)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected O, but got Unknown
				ConsoleOptionsFetcher fetcher = command.m_tabOptionsFetcher;
				command.m_tabOptionsFetcher = (ConsoleOptionsFetcher)([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] () =>
				{
					List<string> list = fetcher.Invoke();
					list.AddRange(skills.Values.Select([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (Skill skill) => skill.internalSkillName));
					return list;
				});
			}
		}

		[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(2)]
		private static SkillDef GetSkillDef(SkillType skillType)
		{
			//IL_0006: 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)
			if (!skills.ContainsKey(skillType))
			{
				return null;
			}
			Skill skill = skills[skillType];
			return skill.skillDef;
		}

		private static byte[] ReadEmbeddedFileBytes(string name)
		{
			using MemoryStream memoryStream = new MemoryStream();
			Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + name).CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		private static Texture2D loadTexture(string name)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			Texture2D val = new Texture2D(0, 0);
			ImageConversion.LoadImage(val, ReadEmbeddedFileBytes("icons." + name));
			return val;
		}

		private static Sprite loadSprite(string name, int width, int height)
		{
			//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)
			return Sprite.Create(loadTexture(name), new Rect(0f, 0f, (float)width, (float)height), Vector2.zero);
		}

		private static ConfigEntry<T> config<[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)] T>(string group, string name, T value, ConfigDescription description)
		{
			ConfigEntry<T> val = plugin.Config.Bind<T>(group, name, value, description);
			configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
				.Invoke(configSync, new object[1] { val });
			return val;
		}

		private static ConfigEntry<T> config<[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)] T>(string group, string name, T value, string description)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[PublicAPI]
	public static class SkillExtensions
	{
		public static float GetSkillFactor(this Character character, string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return character.GetSkillFactor(Skill.fromName(name)) * Skill.skillByName[name].SkillEffectFactor;
		}

		public static float GetSkillFactor(this Skills skills, string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return skills.GetSkillFactor(Skill.fromName(name)) * Skill.skillByName[name].SkillEffectFactor;
		}

		public static void RaiseSkill(this Character character, string name, float value = 1f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			character.RaiseSkill(Skill.fromName(name), value);
		}

		public static void RaiseSkill(this Skills skill, string name, float value = 1f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			skill.RaiseSkill(Skill.fromName(name), value);
		}

		public static void LowerSkill(this Character character, string name, float factor = 1f)
		{
			character.GetSkills().LowerSkill(name, factor);
		}

		public static void LowerSkill(this Skills skills, string name, float factor)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (factor > 0f && skills.m_skillData.TryGetValue(Skill.fromName(name), out var value))
			{
				Skill obj = value;
				obj.m_level -= value.m_level * factor;
				value.m_accumulator = 0f;
			}
		}
	}
}
namespace PieceManager
{
	[PublicAPI]
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	public static class MaterialReplacer
	{
		[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)]
		public enum ShaderType
		{
			PieceShader,
			VegetationShader,
			RockShader,
			RugShader,
			GrassShader,
			CustomCreature,
			UseUnityShader
		}

		private static readonly Dictionary<GameObject, bool> ObjectToSwap;

		private static readonly Dictionary<string, Material> OriginalMaterials;

		private static readonly Dictionary<GameObject, ShaderType> ObjectsForShaderReplace;

		private static readonly HashSet<Shader> CachedShaders;

		private static bool hasRun;

		static MaterialReplacer()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			CachedShaders = new HashSet<Shader>();
			hasRun = false;
			OriginalMaterials = new Dictionary<string, Material>();
			ObjectToSwap = new Dictionary<GameObject, bool>();
			ObjectsForShaderReplace = new Dictionary<GameObject, ShaderType>();
			Harmony val = new Harmony("org.bepinex.helpers.PieceManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZoneSystem), "Start", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(MaterialReplacer), "ReplaceAllMaterialsWithOriginal", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static void RegisterGameObjectForShaderSwap(GameObject go, ShaderType type)
		{
			if (!ObjectsForShaderReplace.ContainsKey(go))
			{
				ObjectsForShaderReplace.Add(go, type);
			}
		}

		public static void RegisterGameObjectForMatSwap(GameObject go, bool isJotunnMock = false)
		{
			if (!ObjectToSwap.ContainsKey(go))
			{
				ObjectToSwap.Add(go, isJotunnMock);
			}
		}

		private static void GetAllMaterials()
		{
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				OriginalMaterials[((Object)val).name] = val;
			}
		}

		[HarmonyPriority(700)]
		private static void ReplaceAllMaterialsWithOriginal()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)SystemInfo.graphicsDeviceType == 4 || hasRun)
			{
				return;
			}
			if (OriginalMaterials.Count == 0)
			{
				GetAllMaterials();
			}
			foreach (KeyValuePair<GameObject, bool> item in ObjectToSwap)
			{
				GameObject key = item.Key;
				bool value = item.Value;
				ProcessGameObjectMaterials(key, value);
			}
			AssetBundle[] array = Resources.FindObjectsOfTypeAll<AssetBundle>();
			AssetBundle[] array2 = array;
			foreach (AssetBundle val in array2)
			{
				IEnumerable<Shader> enumerable3;
				try
				{
					IEnumerable<Shader> enumerable2;
					if (!val.isStreamedSceneAssetBundle || !Object.op_Implicit((Object)(object)val))
					{
						IEnumerable<Shader> enumerable = val.LoadAllAssets<Shader>();
						enumerable2 = enumerable;
					}
					else
					{
						enumerable2 = from shader in ((IEnumerable<string>)val.GetAllAssetNames()).Select((Func<string, Shader>)val.LoadAsset<Shader>)
							where (Object)(object)shader != (Object)null
							select shader;
					}
					enumerable3 = enumerable2;
				}
				catch (Exception)
				{
					continue;
				}
				if (enumerable3 == null)
				{
					continue;
				}
				foreach (Shader item2 in enumerable3)
				{
					CachedShaders.Add(item2);
				}
			}
			foreach (KeyValuePair<GameObject, ShaderType> item3 in ObjectsForShaderReplace)
			{
				GameObject key2 = item3.Key;
				ShaderType value2 = item3.Value;
				ProcessGameObjectShaders(key2, value2);
			}
			hasRun = true;
		}

		private static void ProcessGameObjectMaterials(GameObject go, bool isJotunnMock)
		{
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] sharedMaterials = val.sharedMaterials.Select([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (Material material) => ReplaceMaterial(material, isJotunnMock)).ToArray();
				val.sharedMaterials = sharedMaterials;
			}
		}

		private static Material ReplaceMaterial(Material originalMaterial, bool isJotunnMock)
		{
			string text = (isJotunnMock ? "JVLmock_" : "_REPLACE_");
			if (!((Object)originalMaterial).name.StartsWith(text, StringComparison.Ordinal))
			{
				return originalMaterial;
			}
			string text2 = ((Object)originalMaterial).name.Replace(" (Instance)", "").Replace(text, "");
			if (OriginalMaterials.TryGetValue(text2, out var value))
			{
				return value;
			}
			Debug.LogWarning((object)("No suitable material found to replace: " + text2));
			return originalMaterial;
		}

		private static void ProcessGameObjectShaders(GameObject go, ShaderType shaderType)
		{
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						val2.shader = GetShaderForType(val2.shader, shaderType, ((Object)val2.shader).name);
					}
				}
			}
		}

		private static Shader GetShaderForType(Shader orig, ShaderType shaderType, string originalShaderName)
		{
			return (Shader)(shaderType switch
			{
				ShaderType.PieceShader => FindShaderWithName(orig, "Custom/Piece"), 
				ShaderType.VegetationShader => FindShaderWithName(orig, "Custom/Vegetation"), 
				ShaderType.RockShader => FindShaderWithName(orig, "Custom/StaticRock"), 
				ShaderType.RugShader => FindShaderWithName(orig, "Custom/Rug"), 
				ShaderType.GrassShader => FindShaderWithName(orig, "Custom/Grass"), 
				ShaderType.CustomCreature => FindShaderWithName(orig, "Custom/Creature"), 
				ShaderType.UseUnityShader => FindShaderWithName(orig, ((Object)(object)FindShaderWithName(orig, originalShaderName) != (Object)null) ? originalShaderName : "ToonDeferredShading2017"), 
				_ => FindShaderWithName(orig, "Standard"), 
			});
		}

		public static Shader FindShaderWithName(Shader origShader, string name)
		{
			foreach (Shader cachedShader in CachedShaders)
			{
				if (((Object)cachedShader).name == name)
				{
					return cachedShader;
				}
			}
			return origShader;
		}
	}
	[PublicAPI]
	public enum CraftingTable
	{
		None,
		[InternalName("piece_workbench")]
		Workbench,
		[InternalName("piece_cauldron")]
		Cauldron,
		[InternalName("forge")]
		Forge,
		[InternalName("piece_artisanstation")]
		ArtisanTable,
		[InternalName("piece_stonecutter")]
		StoneCutter,
		[InternalName("piece_magetable")]
		MageTable,
		[InternalName("blackforge")]
		BlackForge,
		Custom
	}
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	public class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[PublicAPI]
	public class ExtensionList
	{
		public readonly List<ExtensionConfig> ExtensionStations = new List<ExtensionConfig>();

		public void Set(CraftingTable table, int maxStationDistance = 5)
		{
			ExtensionStations.Add(new ExtensionConfig
			{
				Table = table,
				maxStationDistance = maxStationDistance
			});
		}

		public void Set(string customTable, int maxStationDistance = 5)
		{
			ExtensionStations.Add(new ExtensionConfig
			{
				Table = CraftingTable.Custom,
				custom = customTable,
				maxStationDistance = maxStationDistance
			});
		}
	}
	public struct ExtensionConfig
	{
		public CraftingTable Table;

		public float maxStationDistance;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		public string custom;
	}
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	[PublicAPI]
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	public class CraftingStationList
	{
		public readonly List<CraftingStationConfig> Stations = new List<CraftingStationConfig>();

		public void Set(CraftingTable table)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = table
			});
		}

		public void Set(string customTable)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = CraftingTable.Custom,
				custom = customTable
			});
		}
	}
	public struct CraftingStationConfig
	{
		public CraftingTable Table;

		public int level;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		public string custom;
	}
	[PublicAPI]
	public enum BuildPieceCategory
	{
		Misc = 0,
		Crafting = 1,
		Building = 2,
		Furniture = 3,
		All = 100,
		Custom = 99
	}
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[PublicAPI]
	public class RequiredResourcesList
	{
		public readonly List<Requirement> Requirements = new List<Requirement>();

		public void Add(string item, int amount, bool recover)
		{
			Requirements.Add(new Requirement
			{
				itemName = item,
				amount = amount,
				recover = recover
			});
		}
	}
	public struct Requirement
	{
		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(1)]
		public string itemName;

		public int amount;

		public bool recover;
	}
	public struct SpecialProperties
	{
		[Description("Admins should be the only ones that can build this piece.")]
		public bool AdminOnly;

		[Description("Turns off generating a config for this build piece.")]
		public bool NoConfig;
	}
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[PublicAPI]
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	public class BuildingPieceCategory
	{
		public BuildPieceCategory Category;

		public string custom = "";

		public void Set(BuildPieceCategory category)
		{
			Category = category;
		}

		public void Set(string customCategory)
		{
			Category = BuildPieceCategory.Custom;
			custom = customCategory;
		}
	}
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[PublicAPI]
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	public class PieceTool
	{
		public readonly HashSet<string> Tools = new HashSet<string>();

		public void Add(string tool)
		{
			Tools.Add(tool);
		}
	}
	[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(1)]
	[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
	[PublicAPI]
	public class BuildPiece
	{
		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
		internal class PieceConfig
		{
			public ConfigEntry<string> craft = null;

			public ConfigEntry<BuildPieceCategory> category = null;

			public ConfigEntry<string> customCategory = null;

			public ConfigEntry<string> tools = null;

			public ConfigEntry<CraftingTable> extensionTable = null;

			public ConfigEntry<string> customExtentionTable = null;

			public ConfigEntry<float> maxStationDistance = null;

			public ConfigEntry<CraftingTable> table = null;

			public ConfigEntry<string> customTable = null;
		}

		[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
			public string Category;

			[UsedImplicitly]
			[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(new byte[] { 2, 1 })]
			public Action<ConfigEntryBase> CustomDrawer;
		}

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(0)]
		private class SerializedRequirements
		{
			public readonly List<Requirement> Reqs;

			public SerializedRequirements(List<Requirement> reqs)
			{
				Reqs = reqs;
			}

			public SerializedRequirements(string reqs)
			{
				Reqs = reqs.Split(new char[1] { ',' }).Select([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (string r) =>
				{
					string[] array = r.Split(new char[1] { ':' });
					Requirement result = default(Requirement);
					result.itemName = array[0];
					result.amount = ((array.Length <= 1 || !int.TryParse(array[1], out var result2)) ? 1 : result2);
					bool result3 = default(bool);
					result.recover = array.Length <= 2 || !bool.TryParse(array[2], out result3) || result3;
					return result;
				}).ToList();
			}

			public override string ToString()
			{
				return string.Join(",", Reqs.Select([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (Requirement r) => $"{r.itemName}:{r.amount}:{r.recover}"));
			}

			[return: <9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
			public static ItemDrop fetchByName(ObjectDB objectDB, string name)
			{
				GameObject itemPrefab = objectDB.GetItemPrefab(name);
				ItemDrop val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)(((!string.IsNullOrWhiteSpace(((Object)plugin).name)) ? ("[" + ((Object)plugin).name + "]") : "") + " The required item '" + name + "' does not exist."));
				}
				return val;
			}

			public static Requirement[] toPieceReqs(SerializedRequirements craft)
			{
				Dictionary<string, Requirement> dictionary = craft.Reqs.Where((Requirement r) => r.itemName != "").ToDictionary((Func<Requirement, string>)([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (Requirement r) => r.itemName), (Func<Requirement, Requirement>)([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (Requirement r) =>
				{
					//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_001e: 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)
					ItemDrop val = ResItem(r);
					return (val == null) ? ((Requirement)null) : new Requirement
					{
						m_amount = r.amount,
						m_resItem = val,
						m_recover = r.recover
					};
				}));
				return dictionary.Values.Where([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (Requirement v) => v != null).ToArray();
				[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(2)]
				static ItemDrop ResItem(Requirement r)
				{
					return fetchByName(ObjectDB.instance, r.itemName);
				}
			}
		}

		internal static readonly List<BuildPiece> registeredPieces = new List<BuildPiece>();

		internal static Dictionary<BuildPiece, PieceConfig> pieceConfigs = new Dictionary<BuildPiece, PieceConfig>();

		internal List<Conversion> Conversions = new List<Conversion>();

		internal List<ItemConversion> conversions = new List<ItemConversion>();

		[Description("Disables generation of the configs for your pieces. This is global, this turns it off for all pieces in your mod.")]
		public static bool ConfigurationEnabled = true;

		public readonly GameObject Prefab;

		[Description("Specifies the resources needed to craft the piece.\nUse .Add to add resources with their internal ID and an amount.\nUse one .Add for each resource type the building piece should need.")]
		public readonly RequiredResourcesList RequiredItems = new RequiredResourcesList();

		[Description("Sets the category for the building piece.")]
		public readonly BuildingPieceCategory Category = new BuildingPieceCategory();

		[Description("Specifies the tool needed to build your piece.\nUse .Add to add a tool.")]
		public readonly PieceTool Tool = new PieceTool();

		[Description("Specifies the crafting station needed to build your piece.\nUse .Add to add a crafting station, using the CraftingTable enum and a minimum level for the crafting station.")]
		public CraftingStationList Crafting = new CraftingStationList();

		[Description("Makes this piece a station extension")]
		public ExtensionList Extension = new ExtensionList();

		[Description("Change the extended/special properties of your build piece.")]
		public SpecialProperties SpecialProperties;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		[Description("Specifies a config entry which toggles whether a recipe is active.")]
		public ConfigEntryBase RecipeIsActive = null;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private LocalizeKey _name;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private LocalizeKey _description;

		internal string[] activeTools = null;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static object configManager;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static Localization _english;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		internal static BaseUnityPlugin _plugin = null;

		private static bool hasConfigSync = true;

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static object _configSync;

		public LocalizeKey Name
		{
			get
			{
				LocalizeKey name = _name;
				if (name != null)
				{
					return name;
				}
				Piece component = Prefab.GetComponent<Piece>();
				if (component.m_name.StartsWith("$"))
				{
					_name = new LocalizeKey(component.m_name);
				}
				else
				{
					string text = "$piece_" + ((Object)Prefab).name.Replace(" ", "_");
					_name = new LocalizeKey(text).English(component.m_name);
					component.m_name = text;
				}
				return _name;
			}
		}

		public LocalizeKey Description
		{
			get
			{
				LocalizeKey description = _description;
				if (description != null)
				{
					return description;
				}
				Piece component = Prefab.GetComponent<Piece>();
				if (component.m_description.StartsWith("$"))
				{
					_description = new LocalizeKey(component.m_description);
				}
				else
				{
					string text = "$piece_" + ((Object)Prefab).name.Replace(" ", "_") + "_description";
					_description = new LocalizeKey(text).English(component.m_description);
					component.m_description = text;
				}
				return _description;
			}
		}

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

		internal static BaseUnityPlugin plugin
		{
			get
			{
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Expected O, but got Unknown
				if (_plugin != null)
				{
					return _plugin;
				}
				IEnumerable<TypeInfo> source;
				try
				{
					source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
				}
				catch (ReflectionTypeLoadException ex)
				{
					source = from t in ex.Types
						where t != null
						select t.GetTypeInfo();
				}
				_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First([<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				return _plugin;
			}
		}

		[<9a54d694-f2d8-4ee4-83ae-d4a830a0cf04>Nullable(2)]
		private static object configSync
		{
			[<9ea156b0-36db-44db-81f2-ee5ef495c74c>NullableContext(2)]
			get
			{
				if (_configSync != null || !hasConfigSync)
				{
					return _configSync;
				}
				Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
				if ((object)type != null)
				{
					_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " PieceManager");
					type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
					type.GetProperty("IsLocked").SetValue(_configSync, true);
				}
				else
				{
					hasConfigSync = false;
				}
				return _configSync;
			}
		}

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

		public BuildPiece(AssetBundle bundle, string prefabName)
		{
			Prefab = PiecePrefabManager.RegisterPrefab(bundle, prefabName);
			registeredPieces.Add(this);
		}

		internal static void Patch_FejdStartup(FejdStartup __instance)
		{
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Expected O, but got Unknown
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Expected O, but got Unknown
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Expected O, but got Unknown
			//IL_05a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b1: Expected O, but got Unknown
			//IL_088b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0895: Expected O, but got Unknown
			//IL_061c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Expected O, but got Unknown
			//IL_06c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cc: Expected O, but got Unknown
			//IL_0900: Unknown result type (might be due to invalid IL or missing references)
			//IL_090a: Ex