using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using HiddenDoors.PieceManager;
using JFUtils;
using JFUtils.Valheim.WithPatch;
using JFUtils.WithPatch;
using JFUtils.zdos;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: Guid("46BDCABE-BEB1-491F-8631-310F5186A3DB")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyProduct("HiddenDoors")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("HiddenDoors")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("JustAFrogger")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: <5aac4faa-f9e2-40ad-94c7-a07c12fb8ecb>RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<c2cd5c0e-62aa-46ed-848c-98962345d015>Embedded]
	internal sealed class <c2cd5c0e-62aa-46ed-848c-98962345d015>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<c2cd5c0e-62aa-46ed-848c-98962345d015>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <491f810f-c1a6-41bf-97fd-013e785d0824>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <491f810f-c1a6-41bf-97fd-013e785d0824>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <491f810f-c1a6-41bf-97fd-013e785d0824>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<c2cd5c0e-62aa-46ed-848c-98962345d015>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <aef20687-8678-4387-b184-c7fda4f8966b>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <aef20687-8678-4387-b184-c7fda4f8966b>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[<c2cd5c0e-62aa-46ed-848c-98962345d015>Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class <5aac4faa-f9e2-40ad-94c7-a07c12fb8ecb>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <5aac4faa-f9e2-40ad-94c7-a07c12fb8ecb>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace HiddenDoors
{
	[BepInPlugin("com.Frogger.HiddenDoors", "HiddenDoors", "1.1.2")]
	internal class Plugin : BaseUnityPlugin
	{
		private const string ModName = "HiddenDoors";

		private const string ModAuthor = "Frogger";

		private const string ModVersion = "1.1.2";

		private const string ModGUID = "com.Frogger.HiddenDoors";

		private void Awake()
		{
			ModBase.CreateMod((BaseUnityPlugin)(object)this, "HiddenDoors", "Frogger", "1.1.2", "com.Frogger.HiddenDoors");
			ModBase.LoadAssetBundle("door");
			BuildPiece buildPiece = new BuildPiece(ModBase.bundle, "Hideen_Door_Stone_2x2");
			buildPiece.Name.English("Hidden stone door 2x2").Swedish("Dold stendörr 2x2").French("Porte en pierre cachée 2x2")
				.Italian("Porta in pietra nascosta 2x2")
				.German("Versteckte Steintür 2x2")
				.Spanish("Puerta de piedra oculta 2x2")
				.Russian("Скрытая каменная дверь 2x2")
				.Romanian("Ușă de piatră ascunsă 2x2")
				.Bulgarian("Скрита каменна врата 2x2")
				.Macedonian("Скриена камена врата 2х2")
				.Finnish("Piilotettu kiviovi 2x2")
				.Danish("Skjult stendør 2x2")
				.Norwegian("Skjult steindør 2x2")
				.Icelandic("Falin steinhurð 2x2")
				.Turkish("Gizli taş kapı 2x2")
				.Lithuanian("Paslėptos akmeninės durys 2x2")
				.Czech("Skryté kamenné dveře 2x2")
				.Hungarian("Rejtett kőajtó 2x2")
				.Slovak("Skryté kamenné dvere 2x2")
				.Polish("Ukryte kamienne drzwi 2x2")
				.Dutch("Verborgen stenen deur 2x2")
				.Chinese("隐藏石门 2x2")
				.Japanese("隠し石扉 2x2")
				.Korean("숨겨진 돌문 2x2")
				.Hindi("छ\u093fप\u093e ह\u0941आ पत\u094dथर क\u093e दरव\u093eज\u093e 2x2")
				.Thai("ประต\u0e39ห\u0e34นซ\u0e48อน 2x2")
				.Croatian("Skrivena kamena vrata 2x2")
				.Georgian("დამალული ქვის კარი 2x2")
				.Greek("Κρυφή πέτρινη πόρτα 2x2")
				.Serbian("Скривена камена врата 2к2")
				.Ukrainian("Приховані кам'яні двері 2x2");
			buildPiece.Category.Set(BuildPieceCategory.BuildingStonecutter);
			buildPiece.RequiredItems.Add("Stone", 8, recover: true);
			buildPiece.SpecialProperties.NoConfig = false;
			BuildPiece buildPiece2 = new BuildPiece(ModBase.bundle, "Hideen_Door_Stone_2x3");
			buildPiece2.Name.English("Hidden stone door 2x3").Swedish("Dold stendörr 2x3").French("Porte en pierre cachée 2x3")
				.Italian("Porta in pietra nascosta 2x3")
				.German("Versteckte Steintür 2x3")
				.Spanish("Puerta de piedra oculta 2x3")
				.Russian("Скрытая каменная дверь 2x3")
				.Romanian("Ușă de piatră ascunsă 2x3")
				.Bulgarian("Скрита каменна врата 2x3")
				.Macedonian("Скриена камена врата 2x3")
				.Finnish("Piilotettu kiviovi 2x3")
				.Danish("Skjult stendør 2x3")
				.Norwegian("Skjult steindør 2x3")
				.Icelandic("Falin steinhurð 2x3")
				.Turkish("Gizli taş kapı 2x3")
				.Lithuanian("Paslėptos akmeninės durys 2x3")
				.Czech("Skryté kamenné dveře 2x3")
				.Hungarian("Rejtett kőajtó 2x3")
				.Slovak("Skryté kamenné dvere 2x3")
				.Polish("Ukryte kamienne drzwi 2x3")
				.Dutch("Verborgen stenen deur 2x3")
				.Chinese("隐藏石门 2x3")
				.Japanese("隠し石扉 2x3")
				.Korean("숨겨진 돌문 2x3")
				.Hindi("छ\u093fप\u093e ह\u0941आ पत\u094dथर क\u093e दरव\u093eज\u093e 2x3")
				.Thai("ประต\u0e39ห\u0e34นซ\u0e48อน 2x3")
				.Croatian("Skrivena kamena vrata 2x3")
				.Georgian("დამალული ქვის კარი 2x3")
				.Greek("Κρυφή πέτρινη πόρτα 2x3")
				.Serbian("Скривена камена врата 2к3")
				.Ukrainian("Приховані кам'яні двері 2x3");
			buildPiece2.Category.Set(BuildPieceCategory.BuildingStonecutter);
			buildPiece2.RequiredItems.Add("Stone", 8, recover: true);
			buildPiece2.SpecialProperties.NoConfig = false;
			BuildPiece buildPiece3 = new BuildPiece(ModBase.bundle, "Hideen_Door_Stone_4x2");
			buildPiece3.Name.English("Hidden stone door 4x2").Swedish("Dold stendörr 4x2").French("Porte en pierre cachée 4x2")
				.Italian("Porta in pietra nascosta 4x2")
				.German("Versteckte Steintür 4x2")
				.Spanish("Puerta de piedra oculta 4x2")
				.Russian("Скрытая каменная дверь 4x2")
				.Romanian("Ușă de piatră ascunsă 4x2")
				.Bulgarian("Скрита каменна врата 4x2")
				.Macedonian("Скриена камена врата 4х2")
				.Finnish("Piilotettu kiviovi 4x2")
				.Danish("Skjult stendør 4x2")
				.Norwegian("Skjult steindør 4x2")
				.Icelandic("Falin steinhurð 4x2")
				.Turkish("Gizli taş kapı 4x2")
				.Lithuanian("Paslėptos akmeninės durys 4x2")
				.Czech("Skryté kamenné dveře 4x2")
				.Hungarian("Rejtett kőajtó 4x2")
				.Slovak("Skryté kamenné dvere 4x2")
				.Polish("Ukryte kamienne drzwi 4x2")
				.Dutch("Verborgen stenen deur 4x2")
				.Chinese("隐藏石门 4x2")
				.Japanese("隠し石扉 4x2")
				.Korean("숨겨진 돌문 4x2")
				.Hindi("छ\u093fप\u093e ह\u0941आ पत\u094dथर क\u093e दरव\u093eज\u093e 4x2")
				.Thai("ประต\u0e39ห\u0e34นซ\u0e48อน 4x2")
				.Croatian("Skrivena kamena vrata 4x2")
				.Georgian("დამალული ქვის კარი 4x2")
				.Greek("Κρυφή πέτρινη πόρτα 4x2")
				.Serbian("Скривена камена врата 4к2")
				.Ukrainian("Приховані кам'яні двері 4x2");
			buildPiece3.Category.Set(BuildPieceCategory.BuildingStonecutter);
			buildPiece3.RequiredItems.Add("Stone", 8, recover: true);
			buildPiece3.SpecialProperties.NoConfig = false;
			BuildPiece buildPiece4 = new BuildPiece(ModBase.bundle, "Hideen_Door_Wood");
			buildPiece4.Name.English("Hidden wooden door").Swedish("Dold trädörr").French("Porte en bois cachée")
				.Italian("Porta di legno nascosta")
				.German("Versteckte Holztür")
				.Spanish("Puerta de madera oculta")
				.Russian("Скрытая деревянная дверь")
				.Romanian("Ușă de lemn ascunsă")
				.Bulgarian("Скрита дървена врата")
				.Macedonian("Скриена дрвена врата")
				.Finnish("Piilotettu puinen ovi")
				.Danish("Skjult trædør")
				.Norwegian("Skjult tredør")
				.Icelandic("Falin viðarhurð")
				.Turkish("Gizli ahşap kapı")
				.Lithuanian("Paslėptos medinės durys")
				.Czech("Skryté dřevěné dveře")
				.Hungarian("Rejtett fa ajtó")
				.Slovak("Skryté drevené dvere")
				.Polish("Ukryte drewniane drzwi")
				.Dutch("Verborgen houten deur")
				.Chinese("隐藏式木门")
				.Japanese("隠し木製ドア")
				.Korean("숨겨진 나무 문")
				.Hindi("छ\u093fप\u093e ह\u0941आ लकड\u093c\u0940 क\u093e दरव\u093eज\u093c\u093e")
				.Thai("ประต\u0e39ไม\u0e49ท\u0e35\u0e48ซ\u0e48อนอย\u0e39\u0e48")
				.Croatian("Skrivena drvena vrata")
				.Georgian("დამალული ხის კარი")
				.Greek("Κρυφή ξύλινη πόρτα")
				.Serbian("Скривена дрвена врата")
				.Ukrainian("Приховані дерев'яні двері");
			buildPiece4.Category.Set(BuildPieceCategory.BuildingWorkbench);
			buildPiece4.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece4.SpecialProperties.NoConfig = false;
			ModBase.bundle.Unload(false);
		}
	}
}
namespace HiddenDoors.Patch
{
	[HarmonyPatch]
	public class HideDoorHover
	{
		[HarmonyPatch(typeof(Door), "GetHoverName")]
		[HarmonyPostfix]
		private static void DoorHoverNamePatch(Door __instance, ref string __result)
		{
			if (Object.op_Implicit((Object)(object)__instance) && ((Object)__instance).name.StartsWith("Hideen_Door"))
			{
				__result = "";
			}
		}

		[HarmonyPatch(typeof(Door), "GetHoverText")]
		[HarmonyPostfix]
		private static void DoorHoverTextPatch(Door __instance, ref string __result)
		{
			if (Object.op_Implicit((Object)(object)__instance) && ((Object)__instance).name.StartsWith("Hideen_Door"))
			{
				__result = "";
			}
		}
	}
	[UsedImplicitly]
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	[HarmonyWrapSafe]
	internal class <ReplaceWithVanila>F1C095A84405225A0B1B9C44CE8BF5BE11DDC2B4E756FA3213AC4F1B31B94BD8C__ReplaceWithVanila
	{
		[HarmonyPostfix]
		[UsedImplicitly]
		private static void Postfix(ZNetScene __instance)
		{
			TryFixDoor("Hideen_Door_Stone_2x2", "stone_wall_2x1");
			TryFixDoor("Hideen_Door_Stone_2x3", "stone_wall_2x1");
			TryFixDoor("Hideen_Door_Stone_4x2", "stone_wall_4x2");
			TryFixDoor("Hideen_Door_Wood", "woodwall");
		}

		private static void TryFixDoor(string name, string origName)
		{
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(name);
				Piece val = ((prefab != null) ? prefab.GetComponent<Piece>() : null);
				GameObject prefab2 = ZNetScene.instance.GetPrefab(origName);
				Piece val2 = ((prefab2 != null) ? prefab2.GetComponent<Piece>() : null);
				GameObject prefab3 = ZNetScene.instance.GetPrefab("wood_door");
				Piece val3 = ((prefab3 != null) ? prefab3.GetComponent<Piece>() : null);
				if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val3) || !Object.op_Implicit((Object)(object)val2))
				{
					return;
				}
				WearNTear component = ((Component)val).GetComponent<WearNTear>();
				WearNTear component2 = ((Component)val2).GetComponent<WearNTear>();
				WearNTear component3 = ((Component)val3).GetComponent<WearNTear>();
				Door component4 = ((Component)val).GetComponent<Door>();
				Door component5 = ((Component)val3).GetComponent<Door>();
				Door val4 = null;
				if (((Object)val).name.Contains("Wood"))
				{
					val4 = component5;
				}
				else
				{
					if (!((Object)val).name.Contains("Stone"))
					{
						if (((Object)val).name.Contains("Marble"))
						{
							throw new Exception("Marble door not supported");
						}
						throw new Exception("Unknown door type");
					}
					val4 = component5;
				}
				GameObject val5 = default(GameObject);
				foreach (string item in new List<string> { "New", "Worn", "Broken" })
				{
					if (1 == 0)
					{
					}
					switch (item)
					{
					case "New":
						val5 = component.m_new;
						break;
					case "Worn":
						val5 = component.m_worn;
						break;
					case "Broken":
						val5 = component.m_broken;
						break;
					default:
						if (1 == 0)
						{
						}
						global::<PrivateImplementationDetails>.ThrowInvalidOperationException();
						break;
					}
					if (1 == 0)
					{
					}
					GameObject val6 = val5;
					if (1 == 0)
					{
					}
					switch (item)
					{
					case "New":
						val5 = component2.m_new;
						break;
					case "Worn":
						val5 = component2.m_worn;
						break;
					case "Broken":
						val5 = component2.m_broken;
						break;
					default:
						if (1 == 0)
						{
						}
						global::<PrivateImplementationDetails>.ThrowInvalidOperationException();
						break;
					}
					if (1 == 0)
					{
					}
					GameObject val7 = val5;
					Renderer[] componentsInChildren = val6.GetComponentsInChildren<Renderer>();
					foreach (Renderer val8 in componentsInChildren)
					{
						Transform obj = val7.transform.FindChildByName(((Object)val8).name);
						Renderer val9 = ((obj != null) ? ((Component)obj).GetComponent<Renderer>() : null);
						if (Object.op_Implicit((Object)(object)val9))
						{
							val8.sharedMaterials = val9.sharedMaterials;
							continue;
						}
						ModBase.DebugWarning("Skipping '" + ((Object)val8).name + "' not found in " + ((Object)val2).name + ". Prefab: " + ((Object)val).name);
					}
				}
				if (!((Object)val).name.Contains("Stone"))
				{
					component4.m_openEffects = val4.m_openEffects;
					component4.m_closeEffects = val4.m_closeEffects;
					component4.m_lockedEffects = val4.m_lockedEffects;
				}
				AudioSource component6 = component4.m_openEffects.m_effectPrefabs[0].m_prefab.GetComponent<AudioSource>();
				AudioSource component7 = val4.m_openEffects.m_effectPrefabs[0].m_prefab.GetComponent<AudioSource>();
				component6.outputAudioMixerGroup = component7.outputAudioMixerGroup;
				component6.priority = component7.priority;
				component6.volume = component7.volume;
				component6.pitch = component7.pitch;
				component6.panStereo = component7.panStereo;
				component6.spread = component7.spread;
				component6.dopplerLevel = component7.dopplerLevel;
				component6.rolloffMode = component7.rolloffMode;
				component6.minDistance = component7.minDistance;
				component6.maxDistance = component7.maxDistance;
				val.m_placeEffect = val2.m_placeEffect;
				component.m_destroyedEffect = component2.m_destroyedEffect;
				component.m_hitEffect = component2.m_hitEffect;
				component.m_switchEffect = component2.m_switchEffect;
			}
			catch (Exception ex)
			{
				ModBase.DebugError("Failed to fix door '" + name + "': " + ex.Message);
			}
		}
	}
}
namespace HiddenDoors.PieceManager
{
	[PublicAPI]
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	public static class MaterialReplacer
	{
		[<aef20687-8678-4387-b184-c7fda4f8966b>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([<aef20687-8678-4387-b184-c7fda4f8966b>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;
			}
			ModBase.DebugWarning("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
	}
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	public class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	[<491f810f-c1a6-41bf-97fd-013e785d0824>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;

		[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(2)]
		public string custom;
	}
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	[PublicAPI]
	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;

		[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(2)]
		public string custom;
	}
	[PublicAPI]
	public enum BuildPieceCategory
	{
		Misc = 0,
		Crafting = 1,
		BuildingWorkbench = 2,
		BuildingStonecutter = 3,
		Furniture = 4,
		All = 100,
		Custom = 99
	}
	[PublicAPI]
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	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
	{
		[<491f810f-c1a6-41bf-97fd-013e785d0824>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;
	}
	[PublicAPI]
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	[<aef20687-8678-4387-b184-c7fda4f8966b>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;
		}
	}
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	[PublicAPI]
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	public class PieceTool
	{
		public readonly HashSet<string> Tools = new HashSet<string>();

		public void Add(string tool)
		{
			Tools.Add(tool);
		}
	}
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	[PublicAPI]
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	public class BuildPiece
	{
		[<491f810f-c1a6-41bf-97fd-013e785d0824>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;
		}

		[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(2)]
			public string Category;

			[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(new byte[] { 2, 1 })]
			[UsedImplicitly]
			public Action<ConfigEntryBase> CustomDrawer;
		}

		[<491f810f-c1a6-41bf-97fd-013e785d0824>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([<aef20687-8678-4387-b184-c7fda4f8966b>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([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (Requirement r) => $"{r.itemName}:{r.amount}:{r.recover}"));
			}

			[return: <491f810f-c1a6-41bf-97fd-013e785d0824>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)
				{
					ModBase.DebugWarning(((!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>)([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (Requirement r) => r.itemName), (Func<Requirement, Requirement>)([<aef20687-8678-4387-b184-c7fda4f8966b>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([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (Requirement v) => v != null).ToArray();
				[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(2)]
				static ItemDrop ResItem(Requirement r)
				{
					return fetchByName(ObjectDB.instance, r.itemName);
				}
			}
		}

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

		private static readonly Dictionary<Piece, BuildPiece> pieceMap = new Dictionary<Piece, 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;

		[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(2)]
		[Description("Specifies a config entry which toggles whether a recipe is active.")]
		public ConfigEntryBase RecipeIsActive = null;

		[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(2)]
		private LocalizeKey _name;

		[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(2)]
		private LocalizeKey _description;

		internal string[] activeTools = null;

		[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(2)]
		private static object configManager;

		[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(2)]
		private static Localization _english;

		[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(2)]
		internal static BaseUnityPlugin _plugin = null;

		private static bool hasConfigSync = true;

		[<491f810f-c1a6-41bf-97fd-013e785d0824>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([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				return _plugin;
			}
		}

		[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(2)]
		private static object configSync
		{
			[<aef20687-8678-4387-b184-c7fda4f8966b>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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Expected O, but got Unknown
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Expected O, but got Unknown
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Expected O, but got Unknown
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Expected O, but got Unknown
			//IL_08ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f4: Expected O, but got Unknown
			//IL_067b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0685: Expected O, but got Unknown
			//IL_0721: Unknown result type (might be due to invalid IL or missing references)
			//IL_072b: Expected O, but got Unknown
			//IL_095f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0969: Expected O, but got Unknown
			//IL_0b7e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b88: Expected O, but got Unknown
			//IL_0c18: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c22: Expected O, but got Unknown
			Type configManagerType = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
			configManager = ((configManagerType == null) ? null : Chainloader.ManagerObject.GetComponent(configManagerType));
			foreach (BuildPiece registeredPiece in registeredPieces)
			{
				registeredPiece.activeTools = registeredPiece.Tool.Tools.DefaultIfEmpty("Hammer").ToArray();
				if (registeredPiece.Category.Category != BuildPieceCategory.Custom)
				{
					registeredPiece.Prefab.GetComponent<Piece>().m_category = (PieceCategory)registeredPiece.Category.Category;
				}
				else
				{
					registeredPiece.Prefab.GetComponent<Piece>().m_category = PiecePrefabManager.GetCategory(registeredPiece.Category.custom);
				}
			}
			if (!ConfigurationEnabled)
			{
				return;
			}
			bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
			plugin.Config.SaveOnConfigSet = false;
			foreach (BuildPiece registeredPiece2 in registeredPieces)
			{
				BuildPiece piece = registeredPiece2;
				if (piece.SpecialProperties.NoConfig)
				{
					continue;
				}
				PieceConfig pieceConfig2 = (pieceConfigs[piece] = new PieceConfig());
				PieceConfig cfg = pieceConfig2;
				Piece piecePrefab2 = piece.Prefab.GetComponent<Piece>();
				string pieceName = piecePrefab2.m_name;
				string englishName = new Regex("[=\\n\\t\\\\\"\\'\\[\\]]*").Replace(english.Localize(pieceName), "").Trim();
				string localizedName = Localization.instance.Localize(pieceName).Trim();
				int order = 0;
				cfg.category = config(englishName, "Build Table Category", piece.Category.Category, new ConfigDescription("Build Category where " + localizedName + " is available.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Order = (order -= 1),
						Category = localizedName
					}
				}));
				ConfigurationManagerAttributes customTableAttributes = new ConfigurationManagerAttributes
				{
					Order = (order -= 1),
					Browsable = (cfg.category.Value == BuildPieceCategory.Custom),
					Category = localizedName
				};
				cfg.customCategory = config(englishName, "Custom Build Category", piece.Category.custom, new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
				cfg.category.SettingChanged += BuildTableConfigChanged;
				cfg.customCategory.SettingChanged += BuildTableConfigChanged;
				if (cfg.category.Value == BuildPieceCategory.Custom)
				{
					piecePrefab2.m_category = PiecePrefabManager.GetCategory(cfg.customCategory.Value);
				}
				else
				{
					piecePrefab2.m_category = (PieceCategory)cfg.category.Value;
				}
				cfg.tools = config(englishName, "Tools", string.Join(", ", piece.activeTools), new ConfigDescription("Comma separated list of tools where " + localizedName + " is available.", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
				piece.activeTools = (from s in cfg.tools.Value.Split(new char[1] { ',' })
					select s.Trim()).ToArray();
				cfg.tools.SettingChanged += [<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (object _, EventArgs _) =>
				{
					Inventory[] source = (from c in Player.s_players.Select([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (Player p) => ((Humanoid)p).GetInventory()).Concat(from c in Object.FindObjectsOfType<Container>()
							select c.GetInventory())
						where c != null
						select c).ToArray();
					Dictionary<string, List<PieceTable>> dictionary = (from kv in (from i in (from p in ObjectDB.instance.m_items
								select p.GetComponent<ItemDrop>() into c
								where Object.op_Implicit((Object)(object)c) && Object.op_Implicit((Object)(object)((Component)c).GetComponent<ZNetView>())
								select c).Concat(ItemDrop.s_instances)
							select new KeyValuePair<string, ItemData>(Utils.GetPrefabName(((Component)i).gameObject), i.m_itemData)).Concat(from i in source.SelectMany([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (Inventory i) => i.GetAllItems())
							select new KeyValuePair<string, ItemData>(((Object)i.m_dropPrefab).name, i))
						where Object.op_Implicit((Object)(object)kv.Value.m_shared.m_buildPieces)
						group kv by kv.Key).ToDictionary([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (IGrouping<string, KeyValuePair<string, ItemData>> g) => g.Key, [<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (IGrouping<string, KeyValuePair<string, ItemData>> g) => g.Select([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (KeyValuePair<string, ItemData> kv) => kv.Value.m_shared.m_buildPieces).Distinct().ToList());
					string[] array5 = piece.activeTools;
					foreach (string key in array5)
					{
						if (dictionary.TryGetValue(key, out var value3))
						{
							foreach (PieceTable item3 in value3)
							{
								item3.m_pieces.Remove(piece.Prefab);
							}
						}
					}
					piece.activeTools = (from s in cfg.tools.Value.Split(new char[1] { ',' })
						select s.Trim()).ToArray();
					if (Object.op_Implicit((Object)(object)ObjectDB.instance))
					{
						string[] array6 = piece.activeTools;
						foreach (string key2 in array6)
						{
							if (dictionary.TryGetValue(key2, out var value4))
							{
								foreach (PieceTable item4 in value4)
								{
									if (!item4.m_pieces.Contains(piece.Prefab))
									{
										item4.m_pieces.Add(piece.Prefab);
									}
								}
							}
						}
						if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces))
						{
							((Humanoid)Player.m_localPlayer).SetPlaceMode(Player.m_localPlayer.m_buildPieces);
						}
					}
				};
				StationExtension pieceExtensionComp;
				List<ConfigurationManagerAttributes> hideWhenNoneAttributes2;
				if (piece.Extension.ExtensionStations.Count > 0)
				{
					pieceExtensionComp = piece.Prefab.GetOrAddComponent<StationExtension>();
					PieceConfig pieceConfig3 = cfg;
					string group = englishName;
					CraftingTable table = piece.Extension.ExtensionStations.First().Table;
					string text = "Crafting station that " + localizedName + " extends.";
					object[] array = new object[1];
					ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes();
					int num = order - 1;
					order = num;
					configurationManagerAttributes.Order = num;
					array[0] = configurationManagerAttributes;
					pieceConfig3.extensionTable = config(group, "Extends Station", table, new ConfigDescription(text, (AcceptableValueBase)null, array));
					cfg.customExtentionTable = config(englishName, "Custom Extend Station", piece.Extension.ExtensionStations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
					PieceConfig pieceConfig4 = cfg;
					string group2 = englishName;
					float maxStationDistance = piece.Extension.ExtensionStations.First().maxStationDistance;
					string text2 = "Distance from the station that " + localizedName + " can be placed.";
					object[] array2 = new object[1];
					ConfigurationManagerAttributes configurationManagerAttributes2 = new ConfigurationManagerAttributes();
					num = order - 1;
					order = num;
					configurationManagerAttributes2.Order = num;
					array2[0] = configurationManagerAttributes2;
					pieceConfig4.maxStationDistance = config(group2, "Max Station Distance", maxStationDistance, new ConfigDescription(text2, (AcceptableValueBase)null, array2));
					hideWhenNoneAttributes2 = new List<ConfigurationManagerAttributes>();
					cfg.extensionTable.SettingChanged += ExtensionTableConfigChanged;
					cfg.customExtentionTable.SettingChanged += ExtensionTableConfigChanged;
					cfg.maxStationDistance.SettingChanged += ExtensionTableConfigChanged;
					ConfigurationManagerAttributes configurationManagerAttributes3 = new ConfigurationManagerAttributes();
					num = order - 1;
					order = num;
					configurationManagerAttributes3.Order = num;
					configurationManagerAttributes3.Browsable = cfg.extensionTable.Value != CraftingTable.None;
					ConfigurationManagerAttributes item = configurationManagerAttributes3;
					hideWhenNoneAttributes2.Add(item);
				}
				List<ConfigurationManagerAttributes> hideWhenNoneAttributes;
				if (piece.Crafting.Stations.Count > 0)
				{
					hideWhenNoneAttributes = new List<ConfigurationManagerAttributes>();
					PieceConfig pieceConfig5 = cfg;
					string group3 = englishName;
					CraftingTable table2 = piece.Crafting.Stations.First().Table;
					string text3 = "Crafting station where " + localizedName + " is available.";
					object[] array3 = new object[1];
					ConfigurationManagerAttributes configurationManagerAttributes4 = new ConfigurationManagerAttributes();
					int num = order - 1;
					order = num;
					configurationManagerAttributes4.Order = num;
					array3[0] = configurationManagerAttributes4;
					pieceConfig5.table = config(group3, "Crafting Station", table2, new ConfigDescription(text3, (AcceptableValueBase)null, array3));
					cfg.customTable = config(englishName, "Custom Crafting Station", piece.Crafting.Stations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
					cfg.table.SettingChanged += TableConfigChanged;
					cfg.customTable.SettingChanged += TableConfigChanged;
					ConfigurationManagerAttributes configurationManagerAttributes5 = new ConfigurationManagerAttributes();
					num = order - 1;
					order = num;
					configurationManagerAttributes5.Order = num;
					configurationManagerAttributes5.Browsable = cfg.table.Value != CraftingTable.None;
					ConfigurationManagerAttributes item2 = configurationManagerAttributes5;
					hideWhenNoneAttributes.Add(item2);
				}
				cfg.craft = itemConfig("Crafting Costs", new SerializedRequirements(piece.RequiredItems.Requirements).ToString(), "Item costs to craft " + localizedName);
				cfg.craft.SettingChanged += [<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (object _, EventArgs _) =>
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance) && (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") != (Object)null)
					{
						Requirement[] resources = SerializedRequirements.toPieceReqs(new SerializedRequirements(cfg.craft.Value));
						piecePrefab2.m_resources = resources;
						Piece[] array4 = Object.FindObjectsOfType<Piece>();
						foreach (Piece val in array4)
						{
							if (val.m_name == pieceName)
							{
								val.m_resources = resources;
							}
						}
					}
				};
				for (int j = 0; j < piece.Conversions.Count; j++)
				{
					string text4 = ((piece.Conversions.Count > 1) ? $"{j + 1}. " : "");
					Conversion conversion = piece.Conversions[j];
					conversion.config = new Conversion.ConversionConfig();
					int index = j;
					conversion.config.input = config(englishName, text4 + "Conversion Input Item", conversion.Input, new ConfigDescription("Conversion input item within " + englishName, (AcceptableValueBase)null, new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = localizedName
						}
					}));
					conversion.config.input.SettingChanged += [<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (object _, EventArgs _) =>
					{
						if (index < piece.conversions.Count)
						{
							ObjectDB instance2 = ObjectDB.instance;
							if (instance2 != null)
							{
								ItemDrop from = SerializedRequirements.fetchByName(instance2, conversion.config.input.Value);
								piece.conversions[index].m_from = from;
							}
						}
					};
					conversion.config.output = config(englishName, text4 + "Conversion Output Item", conversion.Output, new ConfigDescription("Conversion output item within " + englishName, (AcceptableValueBase)null, new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = localizedName
						}
					}));
					conversion.config.output.SettingChanged += [<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (object _, EventArgs _) =>
					{
						if (index < piece.conversions.Count)
						{
							ObjectDB instance = ObjectDB.instance;
							if (instance != null)
							{
								ItemDrop to = SerializedRequirements.fetchByName(instance, conversion.config.output.Value);
								piece.conversions[index].m_to = to;
							}
						}
					};
				}
				if (saveOnConfigSet)
				{
					plugin.Config.SaveOnConfigSet = true;
					plugin.Config.Save();
				}
				void BuildTableConfigChanged(object o, EventArgs e)
				{
					//IL_0066: Unknown result type (might be due to invalid IL or missing references)
					//IL_0042: Unknown result type (might be due to invalid IL or missing references)
					//IL_0047: Unknown result type (might be due to invalid IL or missing references)
					if (registeredPieces.Count > 0)
					{
						if (cfg.category.Value == BuildPieceCategory.Custom)
						{
							piecePrefab2.m_category = PiecePrefabManager.GetCategory(cfg.customCategory.Value);
						}
						else
						{
							piecePrefab2.m_category = (PieceCategory)cfg.category.Value;
						}
						if (Object.op_Implicit((Object)(object)Hud.instance))
						{
							PiecePrefabManager.CreateCategoryTabs();
						}
					}
					customTableAttributes.Browsable = cfg.category.Value == BuildPieceCategory.Custom;
					ReloadConfigDisplay();
				}
				void ExtensionTableConfigChanged(object o, EventArgs e)
				{
					if (piece.RequiredItems.Requirements.Count > 0)
					{
						CraftingTable value2 = cfg.extensionTable.Value;
						CraftingTable craftingTable = value2;
						if (craftingTable == CraftingTable.Custom)
						{
							StationExtension obj2 = pieceExtensionComp;
							GameObject prefab2 = ZNetScene.instance.GetPrefab(cfg.customExtentionTable.Value);
							obj2.m_craftingStation = ((prefab2 != null) ? prefab2.GetComponent<CraftingStation>() : null);
						}
						else
						{
							pieceExtensionComp.m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(cfg.extensionTable.Value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
						}
						pieceExtensionComp.m_maxStationDistance = cfg.maxStationDistance.Value;
					}
					customTableAttributes.Browsable = cfg.extensionTable.Value == CraftingTable.Custom;
					foreach (ConfigurationManagerAttributes item5 in hideWhenNoneAttributes2)
					{
						item5.Browsable = cfg.extensionTable.Value != CraftingTable.None;
					}
					ReloadConfigDisplay();
					plugin.Config.Save();
				}
				void TableConfigChanged(object o, EventArgs e)
				{
					if (piece.RequiredItems.Requirements.Count > 0)
					{
						switch (cfg.table.Value)
						{
						case CraftingTable.None:
							piecePrefab2.m_craftingStation = null;
							break;
						case CraftingTable.Custom:
						{
							Piece obj = piecePrefab2;
							GameObject prefab = ZNetScene.instance.GetPrefab(cfg.customTable.Value);
							obj.m_craftingStation = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
							break;
						}
						default:
							piecePrefab2.m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(cfg.table.Value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
							break;
						}
					}
					customTableAttributes.Browsable = cfg.table.Value == CraftingTable.Custom;
					foreach (ConfigurationManagerAttributes item6 in hideWhenNoneAttributes)
					{
						item6.Browsable = cfg.table.Value != CraftingTable.None;
					}
					ReloadConfigDisplay();
					plugin.Config.Save();
				}
				ConfigEntry<string> itemConfig(string name, string value, string desc)
				{
					//IL_0066: Unknown result type (might be due to invalid IL or missing references)
					//IL_0070: Expected O, but got Unknown
					ConfigurationManagerAttributes configurationManagerAttributes6 = new ConfigurationManagerAttributes
					{
						CustomDrawer = DrawConfigTable,
						Order = (order -= 1),
						Category = localizedName
					};
					return config(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes6 }));
				}
			}
			foreach (BuildPiece registeredPiece3 in registeredPieces)
			{
				ConfigEntryBase enabledCfg = registeredPiece3.RecipeIsActive;
				Piece piecePrefab;
				if (enabledCfg != null)
				{
					piecePrefab = registeredPiece3.Prefab.GetComponent<Piece>();
					ConfigChanged(null, null);
					((object)enabledCfg).GetType().GetEvent("SettingChanged").AddEventHandler(enabledCfg, new EventHandler(ConfigChanged));
				}
				registeredPiece3.InitializeNewRegisteredPiece(registeredPiece3);
				[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(2)]
				void ConfigChanged(object o, EventArgs e)
				{
					piecePrefab.m_enabled = (int)enabledCfg.BoxedValue != 0;
				}
			}
			void ReloadConfigDisplay()
			{
				object obj3 = configManagerType?.GetProperty("DisplayingWindow").GetValue(configManager);
				if (obj3 is bool && (bool)obj3)
				{
					configManagerType.GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
				}
			}
		}

		private void InitializeNewRegisteredPiece(BuildPiece piece)
		{
			ConfigEntryBase recipeIsActive = piece.RecipeIsActive;
			PieceConfig cfg;
			Piece piecePrefab;
			string pieceName;
			if (recipeIsActive != null)
			{
				pieceConfigs.TryGetValue(piece, out cfg);
				piecePrefab = piece.Prefab.GetComponent<Piece>();
				pieceName = piecePrefab.m_name;
				((object)recipeIsActive).GetType().GetEvent("SettingChanged").AddEventHandler(recipeIsActive, new EventHandler(ConfigChanged));
			}
			void ConfigChanged(object o, EventArgs e)
			{
				if (Object.op_Implicit((Object)(object)ObjectDB.instance) && (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") != (Object)null && cfg != null)
				{
					Requirement[] resources = SerializedRequirements.toPieceReqs(new SerializedRequirements(cfg.craft.Value));
					piecePrefab.m_resources = resources;
					Piece[] array = Object.FindObjectsOfType<Piece>();
					foreach (Piece val in array)
					{
						if (val.m_name == pieceName)
						{
							val.m_resources = resources;
						}
					}
				}
			}
		}

		[HarmonyPriority(700)]
		internal static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Expected O, but got Unknown
			if ((Object)(object)__instance.GetItemPrefab("YmirRemains") == (Object)null)
			{
				return;
			}
			foreach (BuildPiece registeredPiece in registeredPieces)
			{
				pieceConfigs.TryGetValue(registeredPiece, out var value);
				registeredPiece.Prefab.GetComponent<Piece>().m_resources = SerializedRequirements.toPieceReqs((value == null) ? new SerializedRequirements(registeredPiece.RequiredItems.Requirements) : new SerializedRequirements(value.craft.Value));
				foreach (ExtensionConfig extensionStation in registeredPiece.Extension.ExtensionStations)
				{
					switch ((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.Table : value.extensionTable.Value)
					{
					case CraftingTable.None:
						registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = null;
						break;
					case CraftingTable.Custom:
					{
						GameObject prefab = ZNetScene.instance.GetPrefab((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.custom : value.customExtentionTable.Value);
						if (prefab != null)
						{
							registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = prefab.GetComponent<CraftingStation>();
						}
						else
						{
							ModBase.DebugWarning("Custom crafting station '" + ((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.custom : value.customExtentionTable.Value) + "' does not exist");
						}
						break;
					}
					default:
						if (value != null && value.table.Value == CraftingTable.None)
						{
							registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = null;
						}
						else
						{
							registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.Table : value.extensionTable.Value).ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
						}
						break;
					}
				}
				foreach (CraftingStationConfig station in registeredPiece.Crafting.Stations)
				{
					switch ((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.Table : value.table.Value)
					{
					case CraftingTable.None:
						registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = null;
						break;
					case CraftingTable.Custom:
					{
						GameObject prefab2 = ZNetScene.instance.GetPrefab((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.custom : value.customTable.Value);
						if (prefab2 != null)
						{
							registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = prefab2.GetComponent<CraftingStation>();
						}
						else
						{
							ModBase.DebugWarning("Custom crafting station '" + ((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.custom : value.customTable.Value) + "' does not exist");
						}
						break;
					}
					default:
						if (value != null && value.table.Value == CraftingTable.None)
						{
							registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = null;
						}
						else
						{
							registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.Table : value.table.Value).ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
						}
						break;
					}
				}
				registeredPiece.conversions = new List<ItemConversion>();
				for (int i = 0; i < registeredPiece.Conversions.Count; i++)
				{
					Conversion conversion = registeredPiece.Conversions[i];
					registeredPiece.conversions.Add(new ItemConversion
					{
						m_from = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.input.Value ?? conversion.Input),
						m_to = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.output.Value ?? conversion.Output)
					});
					if (registeredPiece.conversions[i].m_from != null && registeredPiece.conversions[i].m_to != null)
					{
						registeredPiece.Prefab.GetComponent<Smelter>().m_conversion.Add(registeredPiece.conversions[i]);
					}
				}
			}
		}

		public void Snapshot(float lightIntensity = 1.3f, Quaternion? cameraRotation = null)
		{
			SnapshotPiece(Prefab, lightIntensity, cameraRotation);
		}

		internal void SnapshotPiece(GameObject prefab, float lightIntensity = 1.3f, Quaternion? cameraRotation = null)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: 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_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Expected O, but got Unknown
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)prefab == (Object)null) && (prefab.GetComponentsInChildren<Renderer>().Any() || prefab.GetComponentsInChildren<MeshFilter>().Any()))
			{
				Camera component = new GameObject("CameraIcon", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
				component.backgroundColor = Color.clear;
				component.clearFlags = (CameraClearFlags)2;
				((Component)component).transform.position = new Vector3(10000f, 10000f, 10000f);
				((Component)component).transform.rotation = (Quaternion)(((??)cameraRotation) ?? Quaternion.Euler(0f, 180f, 0f));
				component.fieldOfView = 0.5f;
				component.farClipPlane = 100000f;
				component.cullingMask = 8;
				Light component2 = new GameObject("LightIcon", new Type[1] { typeof(Light) }).GetComponent<Light>();
				((Component)component2).transform.position = new Vector3(10000f, 10000f, 10000f);
				((Component)component2).transform.rotation = Quaternion.Euler(5f, 180f, 5f);
				component2.type = (LightType)1;
				component2.cullingMask = 8;
				component2.intensity = lightIntensity;
				GameObject val = Object.Instantiate<GameObject>(prefab);
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				foreach (Transform val2 in componentsInChildren)
				{
					((Component)val2).gameObject.layer = 3;
				}
				val.transform.position = Vector3.zero;
				val.transform.rotation = Quaternion.Euler(23f, 51f, 25.8f);
				((Object)val).name = ((Object)prefab).name;
				MeshRenderer[] componentsInChildren2 = val.GetComponentsInChildren<MeshRenderer>();
				Vector3 val3 = componentsInChildren2.Aggregate(Vector3.positiveInfinity, [<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (Vector3 cur, MeshRenderer renderer) =>
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					Bounds bounds2 = ((Renderer)renderer).bounds;
					return Vector3.Min(cur, ((Bounds)(ref bounds2)).min);
				});
				Vector3 val4 = componentsInChildren2.Aggregate(Vector3.negativeInfinity, [<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (Vector3 cur, MeshRenderer renderer) =>
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					Bounds bounds = ((Renderer)renderer).bounds;
					return Vector3.Max(cur, ((Bounds)(ref bounds)).max);
				});
				val.transform.position = new Vector3(10000f, 10000f, 10000f) - (val3 + val4) / 2f;
				Vector3 val5 = val4 - val3;
				TimedDestruction val6 = val.AddComponent<TimedDestruction>();
				val6.Trigger(1f);
				Rect val7 = default(Rect);
				((Rect)(ref val7))..ctor(0f, 0f, 128f, 128f);
				component.targetTexture = RenderTexture.GetTemporary((int)((Rect)(ref val7)).width, (int)((Rect)(ref val7)).height);
				component.fieldOfView = 20f;
				float num = Mathf.Max(val5.x, val5.y) + 0.1f;
				float num2 = num / Mathf.Tan(component.fieldOfView * ((float)Math.PI / 180f)) * 1.1f;
				((Component)component).transform.position = new Vector3(10000f, 10000f, 10000f) + new Vector3(0f, 0f, num2);
				component.Render();
				RenderTexture active = RenderTexture.active;
				RenderTexture.active = component.targetTexture;
				Texture2D val8 = new Texture2D((int)((Rect)(ref val7)).width, (int)((Rect)(ref val7)).height, (TextureFormat)4, false);
				val8.ReadPixels(new Rect(0f, 0f, (float)(int)((Rect)(ref val7)).width, (float)(int)((Rect)(ref val7)).height), 0, 0);
				val8.Apply();
				RenderTexture.active = active;
				prefab.GetComponent<Piece>().m_icon = Sprite.Create(val8, new Rect(0f, 0f, (float)(int)((Rect)(ref val7)).width, (float)(int)((Rect)(ref val7)).height), Vector2.one / 2f);
				((Component)component2).gameObject.SetActive(false);
				component.targetTexture.Release();
				((Component)component).gameObject.SetActive(false);
				val.SetActive(false);
				Object.DestroyImmediate((Object)(object)val);
				Object.Destroy((Object)(object)component);
				Object.Destroy((Object)(object)component2);
				Object.Destroy((Object)(object)((Component)component).gameObject);
				Object.Destroy((Object)(object)((Component)component2).gameObject);
			}
		}

		private static void DrawConfigTable(ConfigEntryBase cfg)
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Expected O, but got Unknown
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (object a) => (a.GetType().Name == "ConfigurationManagerAttributes") ? ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a)) : null).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
			List<Requirement> list = new List<Requirement>();
			bool flag = false;
			int num = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
				.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			foreach (Requirement req in new SerializedRequirements((string)cfg.BoxedValue).Reqs)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				int num2 = req.amount;
				if (int.TryParse(GUILayout.TextField(num2.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 40f
				}, Array.Empty<GUILayoutOption>()), out var result) && result != num2 && !valueOrDefault)
				{
					num2 = result;
					flag = true;
				}
				string text = GUILayout.TextField(req.itemName, new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = num - 40 - 67 - 21 - 21 - 12
				}, Array.Empty<GUILayoutOption>());
				string text2 = (valueOrDefault ? req.itemName : text);
				flag = flag || text2 != req.itemName;
				bool flag2 = req.recover;
				if (GUILayout.Toggle(req.recover, "Recover", new GUIStyle(GUI.skin.toggle)
				{
					fixedWidth = 67f
				}, Array.Empty<GUILayoutOption>()) != req.recover)
				{
					flag2 = !flag2;
					flag = true;
				}
				if (GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
				{
					flag = true;
				}
				else
				{
					list.Add(new Requirement
					{
						amount = num2,
						itemName = text2,
						recover = flag2
					});
				}
				if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
				{
					flag = true;
					list.Add(new Requirement
					{
						amount = 1,
						itemName = "",
						recover = false
					});
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new SerializedRequirements(list).ToString();
			}
		}

		private static ConfigEntry<T> config<[<491f810f-c1a6-41bf-97fd-013e785d0824>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<[<491f810f-c1a6-41bf-97fd-013e785d0824>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>()));
		}
	}
	public static class GoExtensions
	{
		[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
		public static T GetOrAddComponent<[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)] T>(this GameObject gameObject) where T : Component
		{
			return gameObject.GetComponent<T>() ?? gameObject.AddComponent<T>();
		}
	}
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	[PublicAPI]
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	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));
				}
			}
		}
	}
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	public static class LocalizationCache
	{
		private static readonly Dictionary<string, Localization> localizations = new Dictionary<string, Localization>();

		internal static void LocalizationPostfix(Localization __instance, string language)
		{
			string key = localizations.FirstOrDefault([<aef20687-8678-4387-b184-c7fda4f8966b>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([<491f810f-c1a6-41bf-97fd-013e785d0824>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;
		}
	}
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	public class AdminSyncing
	{
		private static bool isServer;

		internal static bool registeredOnClient;

		[HarmonyPriority(700)]
		internal static void AdminStatusSync(ZNet __instance)
		{
			isServer = __instance.IsServer();
			if (BuildPiece._plugin != null)
			{
				if (isServer)
				{
					ZRoutedRpc.instance.Register<ZPackage>(BuildPiece._plugin.Info.Metadata.Name + " PMAdminStatusSync", (Action<long, ZPackage>)RPC_AdminPieceAddRemove);
				}
				else if (!registeredOnClient)
				{
					ZRoutedRpc.instance.Register<ZPackage>(BuildPiece._plugin.Info.Metadata.Name + " PMAdminStatusSync", (Action<long, ZPackage>)RPC_AdminPieceAddRemove);
					registeredOnClient = true;
				}
			}
			if (isServer)
			{
				((MonoBehaviour)ZNet.instance).StartCoroutine(WatchAdminListChanges());
			}
			static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				ZPackage val = new ZPackage();
				val.Write(isAdmin);
				((MonoBehaviour)ZNet.instance).StartCoroutine(sendZPackage(peers, val));
			}
			static IEnumerator WatchAdminListChanges()
			{
				List<string> currentList = new List<string>(ZNet.instance.m_adminList.GetList());
				while (true)
				{
					yield return (object)new WaitForSeconds(30f);
					if (!ZNet.instance.m_adminList.GetList().SequenceEqual(currentList))
					{
						currentList = new List<string>(ZNet.instance.m_adminList.GetList());
						List<ZNetPeer> adminPeer = (from p in ZNet.instance.GetPeers()
							where ZNet.instance.ListContainsId(ZNet.instance.m_adminList, p.m_rpc.GetSocket().GetHostName())
							select p).ToList();
						List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
						SendAdmin(nonAdminPeer, isAdmin: false);
						SendAdmin(adminPeer, isAdmin: true);
					}
				}
			}
		}

		private static IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write(4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select TellPeerAdminStatus(p, package)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private static IEnumerator<bool> TellPeerAdminStatus(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc != null)
			{
				SendPackage(package);
			}
			void SendPackage(ZPackage pkg)
			{
				BaseUnityPlugin plugin = BuildPiece._plugin;
				string text = ((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			yield break;
		}

		internal static void RPC_AdminPieceAddRemove(long sender, ZPackage package)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			bool flag = false;
			try
			{
				flag = package.ReadBool();
			}
			catch
			{
			}
			if (isServer)
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				long everybody = ZRoutedRpc.Everybody;
				BaseUnityPlugin plugin = BuildPiece._plugin;
				instance.InvokeRoutedRPC(everybody, ((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { (object)new ZPackage() });
				if (ZNet.instance.ListContainsId(ZNet.instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()))
				{
					ZPackage val = new ZPackage();
					val.Write(true);
					ZRpc rpc = peer.m_rpc;
					BaseUnityPlugin plugin2 = BuildPiece._plugin;
					rpc.Invoke(((plugin2 != null) ? plugin2.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { val });
				}
				return;
			}
			foreach (BuildPiece registeredPiece in BuildPiece.registeredPieces)
			{
				if (!registeredPiece.SpecialProperties.AdminOnly)
				{
					continue;
				}
				Piece component = registeredPiece.Prefab.GetComponent<Piece>();
				string name = component.m_name;
				string text = Localization.instance.Localize(name).Trim();
				if (!Object.op_Implicit((Object)(object)ObjectDB.instance) || (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") == (Object)null)
				{
					continue;
				}
				Piece[] array = Object.FindObjectsOfType<Piece>();
				foreach (Piece val2 in array)
				{
					if (flag)
					{
						if (val2.m_name == name)
						{
							val2.m_enabled = true;
						}
					}
					else if (val2.m_name == name)
					{
						val2.m_enabled = false;
					}
				}
				List<GameObject> pieces = ObjectDB.instance.GetItemPrefab("Hammer").GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
				if (flag)
				{
					if (!pieces.Contains(ZNetScene.instance.GetPrefab(((Object)component).name)))
					{
						pieces.Add(ZNetScene.instance.GetPrefab(((Object)component).name));
					}
				}
				else if (pieces.Contains(ZNetScene.instance.GetPrefab(((Object)component).name)))
				{
					pieces.Remove(ZNetScene.instance.GetPrefab(((Object)component).name));
				}
			}
		}
	}
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	internal class RegisterClientRPCPatch
	{
		private static void Postfix(ZNet __instance, ZNetPeer peer)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			if (!__instance.IsServer())
			{
				ZRpc rpc = peer.m_rpc;
				BaseUnityPlugin plugin = BuildPiece._plugin;
				rpc.Register<ZPackage>(((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync", (Action<ZRpc, ZPackage>)RPC_InitialAdminSync);
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(__instance.ListContainsId(__instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()));
			ZRpc rpc2 = peer.m_rpc;
			BaseUnityPlugin plugin2 = BuildPiece._plugin;
			rpc2.Invoke(((plugin2 != null) ? plugin2.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { val });
		}

		private static void RPC_InitialAdminSync(ZRpc rpc, ZPackage package)
		{
			AdminSyncing.RPC_AdminPieceAddRemove(0L, package);
		}
	}
	[<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(1)]
	[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
	public static class PiecePrefabManager
	{
		[<491f810f-c1a6-41bf-97fd-013e785d0824>Nullable(0)]
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		private static readonly List<GameObject> piecePrefabs;

		private static readonly Dictionary<string, PieceCategory> PieceCategories;

		private static readonly Dictionary<string, PieceCategory> OtherPieceCategories;

		private const string _hiddenCategoryMagic = "(HiddenCategory)";

		static PiecePrefabManager()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Expected O, but got Unknown
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Expected O, but got Unknown
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Expected O, but got Unknown
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Expected O, but got Unknown
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Expected O, but got Unknown
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Expected O, but got Unknown
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Expected O, but got Unknown
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Expected O, but got Unknown
			//IL_040d: Expected O, but got Unknown
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Expected O, but got Unknown
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Expected O, but got Unknown
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Expected O, but got Unknown
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fd: Expected O, but got Unknown
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			piecePrefabs = new List<GameObject>();
			PieceCategories = new Dictionary<string, PieceCategory>();
			OtherPieceCategories = new Dictionary<string, PieceCategory>();
			Harmony val = new Harmony("org.bepinex.helpers.PieceManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_FejdStartup", (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(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(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(AdminSyncing), "AdminStatusSync", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RefFixPatch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "PrevCategory", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_PieceTable_PrevCategory", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "PrevCategory", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "PrevCategory_Transpiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "NextCategory", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_PieceTable_NextCategory", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "NextCategory", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "NextCategory_Transpiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "SetCategory", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "SetCategory_Transpiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "UpdateAvailable", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Transpiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "UpdateAvailable", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Prefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Postfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "SetPlaceMode", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_SetPlaceMode", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Hud), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Hud_AwakeCreateTabs", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Enum), "GetValues", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "EnumGetValuesPatch", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Enum), "GetNames", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "EnumGetNamesPatch", (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>)([<aef20687-8678-4387-b184-c7fda4f8966b>NullableContext(0)] (AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + folderName + "." + assetBundleFileName));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static IEnumerable<GameObject> FixRefs(AssetBundle assetBundle)
		{
			return assetBundle.LoadAllAssets<GameObject>();
		}

		public static GameObject RegisterPrefab(string assetBundleFileName, string prefabName, string folderName = "assets")
		{
			return RegisterPrefab(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
		}

		public static GameObject RegisterPrefab(AssetBundle assets, string prefabName)
		{
			if ((Object)(object)assets == (Object)null)
			{
				ModBase.DebugError("Failed to load asset bundle. Please make sure to mark all asset bundles as embedded resources.");
				return null;
			}
			GameObject val = assets.LoadAsset<GameObject>(prefabName);
			if ((Object)(object)val == (Object)null)
			{
				ModBase.DebugError("Failed to load prefab " + prefabName + " from asset bundle " + ((Object)assets).name);
				return null;
			}
			piecePrefabs.Add(val);
			return val;
		}

		public static Sprite RegisterSprite(string assetBundleFileName, string prefabName, string folderName = "assets")
		{
			return RegisterSprite(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
		}

		public static Sprite RegisterSprite(AssetBundle assets, string prefabName)
		{
			return assets.LoadAsset<Sprite>(prefabName);
		}

		private static void EnumGetValuesPatch(Type enumType, ref Array __result)
		{
			if (!(enumType != typeof(PieceCategory)) && PieceCategories.Count != 0)
			{
				PieceCategory[] array = (PieceCategory[])(object)new PieceCategory[__result.Length + PieceCategories.Count];
				__result.CopyTo(array, 0);
				PieceCategories.Values.CopyTo(array, __result.Length);
				__result = array;
			}
		}

		private static void EnumGetNamesPatch(Type enumType, ref string[] __result)
		{
			if (!(enumType != typeof(PieceCategory)) && PieceCategories.Count != 0)
			{
				__result = CollectionExtensions.AddRangeToArray<string>(__result, PieceCategories.Keys.ToArray());
			}
		}

		public static Dictionary<PieceCategory, string> GetPieceCategoriesMap()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Array values = Enum.GetValues(typeof(PieceCategory));
			string[] names = Enum.GetNames(typeof(PieceCategory));
			Dictionary<PieceCategory, string> dictionary = new Dictionary<PieceCategory, string>();
			for (int i = 0; i < values.Length; i++)
			{
				dictionary[(PieceCategory)values.GetValue(i)] = names[i];
			}
			return dictionary;
		}

		public static PieceCategory GetCategory(string name)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c