using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AzuCraftyBoxes;
using AzuCraftyBoxes.IContainers;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using ComfyGizmo;
using CraftFromContainers;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.GUI;
using Jotunn.Managers;
using Jotunn.Utils;
using On;
using PlanBuild.Blueprints;
using PlanBuild.Blueprints.Components;
using PlanBuild.ModCompat;
using PlanBuild.Plans;
using PlanBuild.Utils;
using SimpleJson;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using ValheimRAFT;
using ValheimRAFT.Patches;
using Valheim_Build_Camera;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("PlanBuild")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PlanBuild")]
[assembly: AssemblyCopyright("WTFPL")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("0.18.8")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.18.8.0")]
[module: UnverifiableCode]
namespace PlanBuild
{
	internal static class Config
	{
		public enum DefaultBuildMode
		{
			Planned,
			Direct
		}

		private const string ServerSection = "Server Settings";

		public static ConfigEntry<bool> AllowDirectBuildConfig;

		public static ConfigEntry<bool> AllowTerrainmodConfig;

		public static ConfigEntry<bool> AllowServerBlueprints;

		public static ConfigEntry<bool> AllowBlueprintRune;

		public static ConfigEntry<bool> AllowMarketHotkey;

		public static ConfigEntry<string> PlanBlacklistConfig;

		private const string RuneSection = "Blueprints";

		public static ConfigEntry<DefaultBuildMode> DefaultBuildModeConfig;

		public static ConfigEntry<bool> UnlimitedHealthConfig;

		public static ConfigEntry<float> RayDistanceConfig;

		public static ConfigEntry<float> TerrainSmoothConfig;

		public static ConfigEntry<float> CameraOffsetIncrementConfig;

		public static ConfigEntry<bool> InvertCameraOffsetScrollConfig;

		public static ConfigEntry<float> PlacementOffsetIncrementConfig;

		public static ConfigEntry<bool> InvertPlacementOffsetScrollConfig;

		public static ConfigEntry<float> SelectionIncrementConfig;

		public static ConfigEntry<bool> InvertSelectionScrollConfig;

		public static ConfigEntry<int> RotationIncrementConfig;

		public static ConfigEntry<bool> InvertRotationScrollConfig;

		public static ConfigEntry<float> SelectionConnectedMarginConfig;

		public static ConfigEntry<bool> ShowGridConfig;

		public static ConfigEntry<bool> TooltipEnabledConfig;

		public static ConfigEntry<Color> TooltipBackgroundConfig;

		public static ConfigEntry<string> BlueprintUndoQueueNameConfig;

		public static ConfigEntry<bool> AddPlayerNameConfig;

		private const string DirectorySection = "Directories";

		public static ConfigEntry<string> BlueprintSearchDirectoryConfig;

		public static ConfigEntry<string> BlueprintSaveDirectoryConfig;

		private const string KeybindSection = "Keybindings";

		public static ConfigEntry<KeyCode> MarketHotkeyConfig;

		public static ButtonConfig MarketHotkeyButton;

		public static ConfigEntry<KeyCode> ShiftModifierConfig;

		public static ButtonConfig ShiftModifierButton;

		public static ConfigEntry<KeyCode> CtrlModifierConfig;

		public static ButtonConfig CtrlModifierButton;

		public static ConfigEntry<KeyCode> ToggleConfig;

		public static ButtonConfig ToggleButton;

		public static ConfigEntry<KeyCode> AltModifierConfig;

		public static ButtonConfig AltModifierButton;

		private const string PlansSection = "Plans";

		public static ConfigEntry<bool> ShowAllPieces;

		public static ConfigEntry<float> RadiusConfig;

		public static ConfigEntry<bool> ShowParticleEffects;

		private const string VisualSection = "Visual";

		public static ConfigEntry<bool> ConfigTransparentGhostPlacement;

		public static ConfigEntry<Color> UnsupportedColorConfig;

		public static ConfigEntry<Color> SupportedPlanColorConfig;

		public static ConfigEntry<float> TransparencyConfig;

		public static ConfigEntry<Color> GlowColorConfig;

		public static bool DirectBuildDefault => DefaultBuildModeConfig.Value == DefaultBuildMode.Direct;

		internal static void Init()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Expected O, but got Unknown
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Expected O, but got Unknown
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Expected O, but got Unknown
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Expected O, but got Unknown
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Expected O, but got Unknown
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Expected O, but got Unknown
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Expected O, but got Unknown
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Expected O, but got Unknown
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Expected O, but got Unknown
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Expected O, but got Unknown
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Expected O, but got Unknown
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Expected O, but got Unknown
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Expected O, but got Unknown
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Expected O, but got Unknown
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Expected O, but got Unknown
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Expected O, but got Unknown
			//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Expected O, but got Unknown
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0509: Expected O, but got Unknown
			//IL_0509: Unknown result type (might be due to invalid IL or missing references)
			//IL_0513: Expected O, but got Unknown
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Expected O, but got Unknown
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_055b: Expected O, but got Unknown
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Unknown result type (might be due to invalid IL or missing references)
			//IL_0599: Expected O, but got Unknown
			//IL_0599: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Expected O, but got Unknown
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e1: Expected O, but got Unknown
			//IL_05e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05eb: Expected O, but got Unknown
			//IL_0617: Unknown result type (might be due to invalid IL or missing references)
			//IL_061c: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Expected O, but got Unknown
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0637: Expected O, but got Unknown
			//IL_065f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0664: Unknown result type (might be due to invalid IL or missing references)
			//IL_0675: Expected O, but got Unknown
			//IL_0675: Unknown result type (might be due to invalid IL or missing references)
			//IL_067f: Expected O, but got Unknown
			//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bd: Expected O, but got Unknown
			//IL_06bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c7: Expected O, but got Unknown
			//IL_06f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0707: Unknown result type (might be due to invalid IL or missing references)
			//IL_070c: Unknown result type (might be due to invalid IL or missing references)
			//IL_071d: Expected O, but got Unknown
			//IL_071d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0727: Expected O, but got Unknown
			//IL_0753: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Unknown result type (might be due to invalid IL or missing references)
			//IL_0769: Expected O, but got Unknown
			//IL_0769: Unknown result type (might be due to invalid IL or missing references)
			//IL_0773: Expected O, but got Unknown
			//IL_079b: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b1: Expected O, but got Unknown
			//IL_07b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bb: Expected O, but got Unknown
			//IL_07e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fd: Expected O, but got Unknown
			//IL_07fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0807: Expected O, but got Unknown
			//IL_0833: Unknown result type (might be due to invalid IL or missing references)
			//IL_0838: Unknown result type (might be due to invalid IL or missing references)
			//IL_0849: Expected O, but got Unknown
			//IL_0849: Unknown result type (might be due to invalid IL or missing references)
			//IL_0853: Expected O, but got Unknown
			//IL_087f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0884: Unknown result type (might be due to invalid IL or missing references)
			//IL_0895: Expected O, but got Unknown
			//IL_0895: Unknown result type (might be due to invalid IL or missing references)
			//IL_089f: Expected O, but got Unknown
			//IL_08cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e1: Expected O, but got Unknown
			//IL_08e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08eb: Expected O, but got Unknown
			//IL_0917: Unknown result type (might be due to invalid IL or missing references)
			//IL_091c: Unknown result type (might be due to invalid IL or missing references)
			//IL_092d: Expected O, but got Unknown
			//IL_092d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0937: Expected O, but got Unknown
			//IL_0963: Unknown result type (might be due to invalid IL or missing references)
			//IL_0968: Unknown result type (might be due to invalid IL or missing references)
			//IL_0979: Expected O, but got Unknown
			//IL_0979: Unknown result type (might be due to invalid IL or missing references)
			//IL_0983: Expected O, but got Unknown
			//IL_09ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c2: Expected O, but got Unknown
			//IL_09c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cc: Expected O, but got Unknown
			//IL_0a46: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a52: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a63: Expected O, but got Unknown
			//IL_0a63: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a6d: Expected O, but got Unknown
			//IL_0a99: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab6: Expected O, but got Unknown
			//IL_0ab6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac0: Expected O, but got Unknown
			//IL_0ae8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b05: Expected O, but got Unknown
			//IL_0b05: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0f: Expected O, but got Unknown
			//IL_0b60: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b76: Expected O, but got Unknown
			//IL_0b76: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b80: Expected O, but got Unknown
			//IL_0bad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd6: Expected O, but got Unknown
			//IL_0bd6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be0: Expected O, but got Unknown
			//IL_0c0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c25: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c36: Expected O, but got Unknown
			//IL_0c36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c40: Expected O, but got Unknown
			//IL_0c7a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c7f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c90: Expected O, but got Unknown
			//IL_0c90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c9a: Expected O, but got Unknown
			//IL_0cb3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cc6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ccb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cdc: Expected O, but got Unknown
			//IL_0cdc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ce6: Expected O, but got Unknown
			int num = 0;
			AllowBlueprintRune = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Server Settings", "Allow blueprint rune", true, new ConfigDescription("Allow usage of blueprint rune for clients connecting to the server." + Environment.NewLine + "Admins are always allowed to use it.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				Order = (num -= 1)
			} }));
			AllowDirectBuildConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Server Settings", "Allow direct build", false, new ConfigDescription("Allow placement of blueprints without materials on this server." + Environment.NewLine + "Admins are always allowed to use it.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				Order = (num -= 1)
			} }));
			AllowTerrainmodConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Server Settings", "Allow terrain tools", false, new ConfigDescription("Allow usage of the terrain modification tools on this server." + Environment.NewLine + "Admins are always allowed to use them.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				Order = (num -= 1)
			} }));
			AllowServerBlueprints = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Server Settings", "Allow serverside blueprints", false, new ConfigDescription("Allow sharing of blueprints on this server.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				Order = (num -= 1)
			} }));
			AllowMarketHotkey = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Server Settings", "Allow clients to use the GUI toggle key", true, new ConfigDescription("Allow clients to use the Hotkey to access server blueprints." + Environment.NewLine + "Admins are always allowed to use it.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				Order = (num -= 1)
			} }));
			PlanBlacklistConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<string>("Server Settings", "Excluded plan prefabs", "AltarPrefab,FloatingIslandMO", new ConfigDescription("Comma separated list of prefab names to exclude from the planned piece table on this server" + Environment.NewLine + "Admins are always allowed to build them.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				Order = (num -= 1),
				Browsable = false
			} }));
			DefaultBuildModeConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<DefaultBuildMode>("Blueprints", "Default build mode", DefaultBuildMode.Planned, new ConfigDescription("Default build mode when placing blueprints.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			DefaultBuildModeConfig.SettingChanged += delegate
			{
				foreach (Blueprint value in BlueprintManager.LocalBlueprints.Values)
				{
					value.CreateKeyHint();
				}
			};
			UnlimitedHealthConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Blueprints", "Unlimited health", false, new ConfigDescription("Set Piece health to its maximum value when directly building blueprints.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			RayDistanceConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<float>("Blueprints", "Place distance", 50f, new ConfigDescription("Place distance while using the Blueprint Rune.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(8f, 80f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			TerrainSmoothConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<float>("Blueprints", "Terrain smoothing", 0.5f, new ConfigDescription("Smoothing value of the terrain tool when flattening with smoothing modifier key pressed.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			CameraOffsetIncrementConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<float>("Blueprints", "Camera offset increment", 2f, new ConfigDescription("Camera height change when holding the camera modifier key and scrolling.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			InvertCameraOffsetScrollConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Blueprints", "Invert camera offset scroll", false, new ConfigDescription("Invert the direction of camera offset scrolling.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			PlacementOffsetIncrementConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<float>("Blueprints", "Placement offset increment", 0.1f, new ConfigDescription("Placement height change when holding the modifier key and scrolling.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			InvertPlacementOffsetScrollConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Blueprints", "Invert placement height change scroll", false, new ConfigDescription("Invert the direction of placement offset scrolling.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			SelectionIncrementConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<float>("Blueprints", "Selection increment", 1f, new ConfigDescription("Selection radius increment when scrolling.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			InvertSelectionScrollConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Blueprints", "Invert selection scroll", false, new ConfigDescription("Invert the direction of selection scrolling.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			RotationIncrementConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<int>("Blueprints", "Rotation increment", 5, new ConfigDescription("Selection rotation increment when scrolling.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			InvertRotationScrollConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Blueprints", "Invert rotation scroll", false, new ConfigDescription("Invert the direction of rotation scrolling.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			SelectionConnectedMarginConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<float>("Blueprints", "Selection connected check margin", 0.01f, new ConfigDescription("Distance of the shell used to check for connectedness.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			ShowGridConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Blueprints", "Show the transform bound grid", false, new ConfigDescription("Shows a grid around the blueprints' bounds to visualize the blueprints' edges.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			TooltipEnabledConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Blueprints", "Tooltip enabled", true, new ConfigDescription("Show a tooltip with a bigger thumbnail for blueprint pieces.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			TooltipBackgroundConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<Color>("Blueprints", "Tooltip Color", new Color(0.13f, 0.13f, 0.13f, 0.65f), new ConfigDescription("Set the background color for the tooltip on blueprint pieces.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			BlueprintUndoQueueNameConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<string>("Blueprints", "Undo queue name", "blueprintqueue", new ConfigDescription("Global name of the blueprint undo queue used for bp.undo and bp.redo commands. Can be set to the same value as other mods' config (if supported) to combine their undo queues.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			AddPlayerNameConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Blueprints", "Add player prefix to file name", true, new ConfigDescription("Add your current player profile name to any blueprint file created with that player.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			BlueprintSearchDirectoryConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<string>("Directories", "Search directory", ".", new ConfigDescription("Base directory to scan (recursively) for blueprints and vbuild files, relative paths are relative to the valheim.exe location", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			BlueprintSaveDirectoryConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<string>("Directories", "Save directory", "BepInEx/config/PlanBuild/blueprints", new ConfigDescription("Directory to save blueprint files, relative paths are relative to the valheim.exe location", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			MarketHotkeyConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<KeyCode>("Keybindings", "Blueprint Marketplace GUI toggle key", (KeyCode)279, new ConfigDescription("Hotkey to show the blueprint marketplace GUI", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			ShiftModifierConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<KeyCode>("Keybindings", "ShiftModifier", (KeyCode)304, new ConfigDescription("First modifier key to change behaviours on various tools (defaults to LeftShift)", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			CtrlModifierConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<KeyCode>("Keybindings", "CtrlModifier", (KeyCode)306, new ConfigDescription("Second modifier key to change behaviours on various tools (defaults to LeftCtrl)", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			AltModifierConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<KeyCode>("Keybindings", "AltModifier", (KeyCode)308, new ConfigDescription("Third modifier key to change behaviours on various tools (defaults to LeftAlt)", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			ToggleConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<KeyCode>("Keybindings", "Toggle", (KeyCode)113, new ConfigDescription("Key to switch between modes on various tools", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			CtrlModifierConfig.SettingChanged += delegate
			{
				foreach (Blueprint value2 in BlueprintManager.LocalBlueprints.Values)
				{
					value2.CreateKeyHint();
				}
			};
			AltModifierConfig.SettingChanged += delegate
			{
				foreach (Blueprint value3 in BlueprintManager.LocalBlueprints.Values)
				{
					value3.CreateKeyHint();
				}
			};
			ShowAllPieces = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Plans", "Plan unknown pieces", false, new ConfigDescription("Show all plans, even for pieces you don't know yet", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				Order = (num -= 1)
			} }));
			RadiusConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<float>("Plans", "Plan totem build radius", 30f, new ConfigDescription("Build radius of the plan totem", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				Order = (num -= 1)
			} }));
			ShowParticleEffects = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Plans", "Plan totem particle effects", true, new ConfigDescription("Show particle effects when building pieces with the plan totem", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				Order = (num -= 1)
			} }));
			ShowAllPieces.SettingChanged += delegate
			{
				PlanManager.UpdateKnownRecipes();
			};
			ConfigTransparentGhostPlacement = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<bool>("Visual", "Transparent Ghost Placement", true, new ConfigDescription("Apply plan shader to ghost placement (currently placing piece)", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			UnsupportedColorConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<Color>("Visual", "Unsupported color", new Color(1f, 1f, 1f, 0.1f), new ConfigDescription("Color of unsupported plan pieces", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			SupportedPlanColorConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<Color>("Visual", "Supported color", new Color(1f, 1f, 1f, 0.5f), new ConfigDescription("Color of supported plan pieces", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			TransparencyConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<float>("Visual", "Transparency", 0.3f, new ConfigDescription("Additional transparency for finer control.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			GlowColorConfig = ((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Bind<Color>("Visual", "Plan totem glow color", Color.cyan, new ConfigDescription("Color of the glowing lines on the Plan totem", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = (num -= 1)
			} }));
			ConfigTransparentGhostPlacement.SettingChanged += UpdateGhostPlanPieceTextures;
			UnsupportedColorConfig.SettingChanged += UpdateAllPlanPieceTextures;
			SupportedPlanColorConfig.SettingChanged += UpdateAllPlanPieceTextures;
			TransparencyConfig.SettingChanged += UpdateAllPlanPieceTextures;
			GlowColorConfig.SettingChanged += UpdateAllPlanTotems;
			CreateCustomButtons();
		}

		private static void CreateCustomButtons()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			MarketHotkeyButton = new ButtonConfig
			{
				Name = "GUIToggle",
				Config = MarketHotkeyConfig,
				ActiveInCustomGUI = true
			};
			InputManager.Instance.AddButton("marcopogo.PlanBuild", MarketHotkeyButton);
			ShiftModifierButton = new ButtonConfig
			{
				Name = "ShiftModifierButton",
				Config = ShiftModifierConfig
			};
			InputManager.Instance.AddButton("marcopogo.PlanBuild", ShiftModifierButton);
			CtrlModifierButton = new ButtonConfig
			{
				Name = "CtrlModifierButton",
				Config = CtrlModifierConfig
			};
			InputManager.Instance.AddButton("marcopogo.PlanBuild", CtrlModifierButton);
			AltModifierButton = new ButtonConfig
			{
				Name = "AltModifierButton",
				Config = AltModifierConfig
			};
			InputManager.Instance.AddButton("marcopogo.PlanBuild", AltModifierButton);
			ToggleButton = new ButtonConfig
			{
				Name = "ToggleButton",
				Config = ToggleConfig
			};
			InputManager.Instance.AddButton("marcopogo.PlanBuild", ToggleButton);
		}

		private static void UpdateGhostPlanPieceTextures(object sender, EventArgs e)
		{
			PlanManager.UpdateAllPlanPieceTextures();
		}

		private static void UpdateAllPlanPieceTextures(object sender, EventArgs e)
		{
			ShaderHelper.ClearCache();
			PlanManager.UpdateAllPlanPieceTextures();
		}

		private static void UpdateAllPlanTotems(object sender, EventArgs e)
		{
			PlanManager.UpdateAllPlanTotems();
		}
	}
	internal static class Extensions
	{
		public static void Highlight(this WearNTear self, Color color, float highlightTime = 0f)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			if (self.m_oldMaterials == null)
			{
				self.m_oldMaterials = new List<OldMeshData>();
				foreach (Renderer highlightRenderer in self.GetHighlightRenderers())
				{
					OldMeshData val = default(OldMeshData);
					val.m_materials = highlightRenderer.sharedMaterials;
					val.m_color = (Color[])(object)new Color[val.m_materials.Length];
					val.m_emissiveColor = (Color[])(object)new Color[val.m_materials.Length];
					for (int i = 0; i < val.m_materials.Length; i++)
					{
						if (val.m_materials[i].HasProperty("_Color"))
						{
							val.m_color[i] = val.m_materials[i].GetColor("_Color");
						}
						if (val.m_materials[i].HasProperty("_EmissionColor"))
						{
							val.m_emissiveColor[i] = val.m_materials[i].GetColor("_EmissionColor");
						}
					}
					val.m_renderer = highlightRenderer;
					self.m_oldMaterials.Add(val);
				}
			}
			IEnumerable<OldMeshData> enumerable = self.m_oldMaterials.Where((OldMeshData mat) => Object.op_Implicit((Object)(object)mat.m_renderer));
			foreach (OldMeshData item in enumerable)
			{
				Material[] materials = item.m_renderer.materials;
				IEnumerable<Material> enumerable2 = materials.Where((Material material) => material.HasProperty("_EmissionColor") && material.HasProperty("_Color"));
				foreach (Material item2 in enumerable2)
				{
					item2.SetColor("_EmissionColor", color * 0.3f);
					item2.color = color;
				}
			}
			((MonoBehaviour)self).CancelInvoke("ResetHighlight");
			if (highlightTime > 0f)
			{
				((MonoBehaviour)self).Invoke("ResetHighlight", highlightTime);
			}
		}

		public static ZDOID? GetZDOID(this Piece piece)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (piece == null)
			{
				return null;
			}
			ZNetView nview = piece.m_nview;
			if (nview == null)
			{
				return null;
			}
			return nview.GetZDO()?.m_uid;
		}

		public static ZDOID? GetZDOID(this WearNTear wearNTear)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (wearNTear == null)
			{
				return null;
			}
			ZNetView nview = wearNTear.m_nview;
			if (nview == null)
			{
				return null;
			}
			return nview.GetZDO()?.m_uid;
		}
	}
	internal class Patches
	{
		public const string BuildCameraGUID = "org.gittywithexcitement.plugins.valheim.buildCamera";

		public const string CraftFromContainersGUID = "aedenthorn.CraftFromContainers";

		public const string AzuCraftyBoxesGUID = "Azumatt.AzuCraftyBoxes";

		public const string GizmoGUID = "bruce.valheim.comfymods.gizmo";

		public const string ValheimRaftGUID = "BepIn.Sarcen.ValheimRAFT";

		public const string ItemDrawersGUID = "mkz.itemdrawers";

		private static Harmony Harmony;

		internal static void Apply()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			Harmony = new Harmony("marcopogo.PlanBuild");
			Harmony.PatchAll(typeof(PlanPiece));
			if (Chainloader.PluginInfos.ContainsKey("org.gittywithexcitement.plugins.valheim.buildCamera"))
			{
				Logger.LogInfo((object)"Applying BuildCamera patches");
				Harmony.PatchAll(typeof(PatcherBuildCamera));
			}
			if (Chainloader.PluginInfos.ContainsKey("aedenthorn.CraftFromContainers"))
			{
				Logger.LogInfo((object)"Applying CraftFromContainers patches");
				Harmony.PatchAll(typeof(PatcherCraftFromContainers));
			}
			else if (Chainloader.PluginInfos.ContainsKey("Azumatt.AzuCraftyBoxes"))
			{
				Logger.LogInfo((object)"Applying AzuCraftyBoxes patches");
				Harmony.PatchAll(typeof(PatcherAzuCraftyBoxes));
			}
			if (Chainloader.PluginInfos.ContainsKey("bruce.valheim.comfymods.gizmo"))
			{
				Logger.LogInfo((object)"Applying Gizmo patches");
				Harmony.PatchAll(typeof(PatcherGizmo));
			}
			if (Chainloader.PluginInfos.ContainsKey("BepIn.Sarcen.ValheimRAFT"))
			{
				Logger.LogInfo((object)"Applying ValheimRAFT patches");
				Harmony.PatchAll(typeof(PatcherValheimRaft));
			}
		}
	}
	[BepInPlugin("marcopogo.PlanBuild", "PlanBuild", "0.18.8")]
	[BepInDependency("com.jotunn.jotunn", "2.30.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	internal class PlanBuildPlugin : BaseUnityPlugin
	{
		public const string PluginGUID = "marcopogo.PlanBuild";

		public const string PluginName = "PlanBuild";

		public const string PluginVersion = "0.18.8";

		public static PlanBuildPlugin Instance;

		public void Awake()
		{
			Instance = this;
			Assembly assembly = typeof(PlanBuildPlugin).Assembly;
			Config.Init();
			AssetBundle val = AssetUtils.LoadAssetBundleFromResources("blueprints", assembly);
			BlueprintAssets.Load(val);
			val.Unload(false);
			BlueprintManager.Init();
			AssetBundle val2 = AssetUtils.LoadAssetBundleFromResources("planbuild", assembly);
			PlanTotemPrefab.Create(val2);
			PlanCrystalPrefab.Create(val2);
			PlanHammerPrefab.Create(val2);
			val2.Unload(false);
			PlanManager.Init();
			CustomLocalization localization = LocalizationManager.Instance.GetLocalization();
			string text = "English";
			string text2 = "$hud_snappoint";
			localization.AddTranslation(ref text, ref text2, "Recreated Snappoint");
			Patches.Apply();
		}

		public void Update()
		{
			if (ZInput.instance != null && (!Object.op_Implicit((Object)(object)Settings.instance) || !((Behaviour)Settings.instance).isActiveAndEnabled))
			{
				if (BlueprintGUI.IsAvailable() && !SelectionSaveGUI.IsVisible() && !TerrainModGUI.IsVisible() && !SelectionGUI.IsVisible() && (Config.AllowMarketHotkey.Value || SynchronizationManager.Instance.PlayerIsAdmin) && ZInput.GetButtonDown(Config.MarketHotkeyButton.Name))
				{
					BlueprintGUI.Instance.Toggle();
				}
				if (BlueprintGUI.IsVisible() && !BlueprintGUI.TextFieldHasFocus() && ZInput.GetButtonDown("Use"))
				{
					BlueprintGUI.Instance.Toggle(shutWindow: true);
					ZInput.ResetButtonStatus("Use");
				}
			}
		}

		public void UpdateScanPieces()
		{
			PlanDB.Instance.ScanPieceTables();
		}
	}
}
namespace PlanBuild.ModCompat
{
	internal class PatcherBuildCamera
	{
		internal static bool UpdateCamera = true;

		[HarmonyPatch(typeof(Valheim_Build_Camera), "IsTool")]
		[HarmonyPrefix]
		private static bool ValheimBuildCamera_IsTool_Prefix(ItemData itemData, ref bool __result)
		{
			if (itemData?.m_shared.m_name == "$item_blueprintrune" || itemData?.m_shared.m_name == "$item_plan_hammer")
			{
				__result = true;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(Valheim_Build_Camera), "EnableBuildMode")]
		[HarmonyPostfix]
		internal static void ValheimBuildCamera_EnableBuildMode_Postfix()
		{
			UpdateCamera = false;
		}

		[HarmonyPatch(typeof(Valheim_Build_Camera), "DisableBuildMode")]
		[HarmonyPostfix]
		internal static void ValheimBuildCamera_DisableBuildMode_Postfix()
		{
			UpdateCamera = true;
		}
	}
	internal class PatcherCraftFromContainers
	{
		[HarmonyPatch(typeof(PlanPiece), "GetInventories")]
		[HarmonyPostfix]
		private static void PlanPiece_GetInventories_Postfix(Humanoid player, ref List<PlanPiece.IInventory> __result)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!CraftFromContainers.modEnabled.Value)
			{
				return;
			}
			List<Container> nearbyContainers = CraftFromContainers.GetNearbyContainers(((Component)player).transform.position);
			foreach (Container item in nearbyContainers)
			{
				__result.Add(new PlanPiece.StandardInventory(item.GetInventory()));
			}
		}
	}
	internal class PatcherAzuCraftyBoxes
	{
		internal class AzuCraftyBoxesInventory : PlanPiece.IInventory
		{
			private IContainer container;

			internal static Dictionary<string, string> resource_prefab_mapping = new Dictionary<string, string>();

			internal static string GetResourcePrefabName(string resourceName)
			{
				if (!resource_prefab_mapping.TryGetValue(resourceName, out var value))
				{
					value = null;
					foreach (GameObject item in ObjectDB.instance.m_items)
					{
						ItemDrop component = item.GetComponent<ItemDrop>();
						if ((Object)(object)component != (Object)null && component.m_itemData != null && component.m_itemData.m_shared.m_name == resourceName)
						{
							value = Utils.GetPrefabName(item);
							break;
						}
					}
					resource_prefab_mapping.Add(resourceName, value);
				}
				return value;
			}

			public AzuCraftyBoxesInventory(IContainer container)
			{
				this.container = container;
			}

			public int CountItems(string resourceName)
			{
				return container.ItemCount(resourceName);
			}

			public bool HaveItem(string resourceName)
			{
				string resourcePrefabName = GetResourcePrefabName(resourceName);
				if (API.CanItemBePulled(container.GetPrefabName(), resourcePrefabName))
				{
					return container.ItemCount(resourceName) > 0;
				}
				return false;
			}

			public void RemoveItem(string resourceName, int amount)
			{
				container.RemoveItem(resourceName, amount);
			}
		}

		[HarmonyPatch(typeof(PlanPiece), "GetInventories")]
		[HarmonyPostfix]
		private static void PlanPiece_GetInventories_Postfix(Humanoid player, ref List<PlanPiece.IInventory> __result)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if ((int)AzuCraftyBoxesPlugin.ModEnabled.Value != 1)
			{
				return;
			}
			foreach (IContainer nearbyContainer in API.GetNearbyContainers<Humanoid>(player, AzuCraftyBoxesPlugin.mRange.Value))
			{
				__result.Add(new AzuCraftyBoxesInventory(nearbyContainer));
			}
		}
	}
	internal class PatcherValheimRaft
	{
		private PatcherValheimRaft()
		{
		}

		[HarmonyPatch(typeof(PlanPiece), "CalculateSupported")]
		[HarmonyPrefix]
		private static bool PlanPiece_CalculateSupported_Prefix(PlanPiece __instance, ref bool __result)
		{
			if (Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<MoveableBaseRootComponent>()))
			{
				__result = true;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(PlanPiece), "OnPieceReplaced")]
		[HarmonyPrefix]
		private static void PlanPiece_OnPieceReplaced_Postfix(GameObject originatingPiece, GameObject placedPiece)
		{
			MoveableBaseRootComponent componentInParent = originatingPiece.GetComponentInParent<MoveableBaseRootComponent>();
			if (Object.op_Implicit((Object)(object)componentInParent))
			{
				componentInParent.AddNewPiece(placedPiece.GetComponent<Piece>());
			}
		}

		[HarmonyPatch(typeof(PlacementComponent), "OnPiecePlaced")]
		[HarmonyPrefix]
		private static void BlueprintManager_OnPiecePlaced_Postfix(GameObject placedPiece)
		{
			ValheimRAFT_Patch.PlacedPiece(Player.m_localPlayer, placedPiece);
		}
	}
	internal static class PatcherGizmo
	{
		[HarmonyPatch(typeof(PlayerPatch), "UpdatePlacementPostfix")]
		[HarmonyPrefix]
		private static bool ComfyGizmo_UpdatePlacementPostfix_Prefix()
		{
			bool flag = Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces);
			if (!flag || !Object.op_Implicit((Object)(object)Player.m_localPlayer.m_placementGhost) || Gizmos._gizmoInstances.Count <= 0)
			{
				return true;
			}
			Action action = delegate
			{
				foreach (Gizmos gizmoInstance in Gizmos._gizmoInstances)
				{
					gizmoInstance.Hide();
				}
			};
			ToolComponentBase toolComponentBase = default(ToolComponentBase);
			if (Player.m_localPlayer.m_placementGhost.TryGetComponent<ToolComponentBase>(ref toolComponentBase) && toolComponentBase.SuppressGizmo)
			{
				action();
				return false;
			}
			bool flag2 = ((Object)Player.m_localPlayer.m_buildPieces).name.StartsWith("_PlanHammerPieceTable", StringComparison.Ordinal);
			bool flag3 = ((Object)Player.m_localPlayer.m_placementGhost).name.StartsWith("piece_plan_delete", StringComparison.Ordinal);
			if (flag2 && flag3)
			{
				action();
				return false;
			}
			bool flag4 = ((Object)Player.m_localPlayer.m_buildPieces).name.StartsWith("_BlueprintPieceTable", StringComparison.Ordinal);
			bool flag5 = ZInput.GetButton(Config.ShiftModifierButton.Name) || ZInput.GetButton(Config.AltModifierButton.Name) || ZInput.GetButton(Config.CtrlModifierButton.Name);
			if (flag && flag4 && flag5)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(ToolComponentBase), "Player_UpdatePlacementGhost")]
		[HarmonyPostfix]
		private static void PlanBuild_Player_UpdatePlacementGhost_Postfix(Player self)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)self.m_placementGhost))
			{
				return;
			}
			foreach (Gizmos gizmoInstance in Gizmos._gizmoInstances)
			{
				gizmoInstance.SetPosition(self.m_placementGhost.transform.position);
			}
		}
	}
}
namespace PlanBuild.Utils
{
	internal class ShapedProjector : MonoBehaviour
	{
		internal enum ProjectorShape
		{
			Circle,
			Square
		}

		private static GameObject _segment;

		private ProjectorShape Shape;

		private float Radius = 10f;

		private int Rotation;

		private CircleProjector Circle;

		private SquareProjector Square;

		private static GameObject SelectionSegment
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)_segment))
				{
					GameObject prefab = PrefabManager.Instance.GetPrefab("piece_workbench");
					_segment = Object.Instantiate<GameObject>(prefab.GetComponentInChildren<CircleProjector>().m_prefab);
					_segment.SetActive(false);
				}
				return _segment;
			}
		}

		public void Enable()
		{
			if (Shape == ProjectorShape.Circle && (Object)(object)Circle == (Object)null)
			{
				Circle = ((Component)this).gameObject.AddComponent<CircleProjector>();
				Circle.m_prefab = SelectionSegment;
				Circle.m_prefab.SetActive(true);
				Circle.m_radius = Radius;
				Circle.m_nrOfSegments = (int)Radius * 4;
			}
			if (Shape == ProjectorShape.Square && (Object)(object)Square == (Object)null)
			{
				Square = ((Component)this).gameObject.AddComponent<SquareProjector>();
				Square.prefab = SelectionSegment;
				Square.radius = Radius;
				Square.rotation = Rotation;
			}
		}

		public void Disable()
		{
			if ((Object)(object)Circle != (Object)null)
			{
				foreach (GameObject segment in Circle.m_segments)
				{
					Object.DestroyImmediate((Object)(object)segment);
				}
				Object.DestroyImmediate((Object)(object)Circle);
			}
			if ((Object)(object)Square != (Object)null)
			{
				Square.StopProjecting();
				Object.DestroyImmediate((Object)(object)Square);
			}
		}

		public bool IsEnabled()
		{
			if (Shape == ProjectorShape.Circle && (Object)(object)Circle != (Object)null)
			{
				return true;
			}
			if (Shape == ProjectorShape.Square && (Object)(object)Square != (Object)null)
			{
				return true;
			}
			return false;
		}

		public void ToggleEnabled()
		{
			if (IsEnabled())
			{
				Disable();
			}
			else
			{
				Enable();
			}
		}

		public void SwitchShape()
		{
			if (Shape == ProjectorShape.Circle)
			{
				SetShape(ProjectorShape.Square);
			}
			else if (Shape == ProjectorShape.Square)
			{
				SetShape(ProjectorShape.Circle);
			}
		}

		public void SetShape(ProjectorShape newShape)
		{
			if (Shape != newShape)
			{
				Disable();
				Shape = newShape;
				Enable();
			}
		}

		public ProjectorShape GetShape()
		{
			return Shape;
		}

		public Vector3 GetPosition()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		public void SetRadius(float newRadius)
		{
			Radius = newRadius;
			if (Shape == ProjectorShape.Circle && (Object)(object)Circle != (Object)null)
			{
				Circle.m_radius = Radius;
				Circle.m_nrOfSegments = (int)Radius * 4;
			}
			if (Shape == ProjectorShape.Square && (Object)(object)Square != (Object)null)
			{
				Square.radius = Radius;
			}
		}

		public float GetRadius()
		{
			return Radius;
		}

		public void SetRotation(int newRotation)
		{
			Rotation = newRotation;
			if (Shape == ProjectorShape.Square && (Object)(object)Square != (Object)null)
			{
				Square.rotation = Rotation;
			}
		}

		public int GetRotation()
		{
			return Rotation;
		}

		public void EnableMask()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (Shape == ProjectorShape.Circle && (Object)(object)Circle != (Object)null && LayerMask.op_Implicit(Circle.m_mask) != 2048)
			{
				Circle.m_mask = LayerMask.op_Implicit(2048);
			}
			if (Shape == ProjectorShape.Square && (Object)(object)Square != (Object)null && LayerMask.op_Implicit(Square.mask) != 2048)
			{
				Square.mask = LayerMask.op_Implicit(2048);
			}
		}

		public void DisableMask()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (Shape == ProjectorShape.Circle && (Object)(object)Circle != (Object)null && LayerMask.op_Implicit(Circle.m_mask) != 0)
			{
				Circle.m_mask = LayerMask.op_Implicit(0);
			}
			if (Shape == ProjectorShape.Square && (Object)(object)Square != (Object)null && LayerMask.op_Implicit(Square.mask) != 0)
			{
				Square.mask = LayerMask.op_Implicit(0);
			}
		}
	}
	internal class SquareProjector : MonoBehaviour
	{
		public float cubesSpeed = 1f;

		public float radius = 2f;

		public int rotation;

		public GameObject prefab;

		private GameObject cube;

		private float cubesThickness = 0.15f;

		private float cubesHeight = 0.1f;

		private float cubesLength = 1f;

		public LayerMask mask = LayerMask.op_Implicit(0);

		private float updatesPerSecond = 60f;

		private int cubesPerSide;

		private float sideLength;

		private float cubesLength100;

		private float sideLengthHalved;

		private Quaternion translatedRotation;

		private bool isRunning;

		private Transform center;

		private Transform parentNorth;

		private Transform parentEast;

		private Transform parentSouth;

		private Transform parentWest;

		private List<Transform> cubesNorth = new List<Transform>();

		private List<Transform> cubesEast = new List<Transform>();

		private List<Transform> cubesSouth = new List<Transform>();

		private List<Transform> cubesWest = new List<Transform>();

		public void Start()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			cube = new GameObject("cube");
			GameObject val = Object.Instantiate<GameObject>(prefab);
			val.transform.SetParent(cube.transform);
			val.transform.localScale = new Vector3(1f, 1f, 1f);
			val.transform.localPosition = new Vector3(0f, 0f, -0.5f);
			cube.transform.localScale = new Vector3(cubesThickness, cubesHeight, cubesLength);
			cube.SetActive(false);
			RefreshStuff();
			StartProjecting();
		}

		private void OnEnable()
		{
			if (!isRunning && !((Object)(object)parentNorth == (Object)null))
			{
				isRunning = true;
				((MonoBehaviour)this).StartCoroutine(AnimateElements(parentNorth, cubesNorth));
				((MonoBehaviour)this).StartCoroutine(AnimateElements(parentEast, cubesEast));
				((MonoBehaviour)this).StartCoroutine(AnimateElements(parentSouth, cubesSouth));
				((MonoBehaviour)this).StartCoroutine(AnimateElements(parentWest, cubesWest));
			}
		}

		private void OnDisable()
		{
			isRunning = false;
		}

		public void StartProjecting()
		{
			//IL_0016: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			if (!isRunning)
			{
				isRunning = true;
				center = new GameObject("center").transform;
				center.SetParent(((Component)this).transform);
				center.position = ((Component)this).transform.position;
				center.rotation = Quaternion.Euler(0f, (float)rotation, 0f);
				parentNorth = CreateElements(rotation, cubesNorth);
				parentEast = CreateElements(rotation + 90, cubesEast);
				parentSouth = CreateElements(rotation + 180, cubesSouth);
				parentWest = CreateElements(rotation + 270, cubesWest);
				((MonoBehaviour)this).StartCoroutine(AnimateElements(parentNorth, cubesNorth));
				((MonoBehaviour)this).StartCoroutine(AnimateElements(parentEast, cubesEast));
				((MonoBehaviour)this).StartCoroutine(AnimateElements(parentSouth, cubesSouth));
				((MonoBehaviour)this).StartCoroutine(AnimateElements(parentWest, cubesWest));
			}
		}

		public void StopProjecting()
		{
			if (isRunning)
			{
				isRunning = false;
				((MonoBehaviour)this).StopAllCoroutines();
				Object.Destroy((Object)(object)((Component)center).gameObject);
				cubesNorth.Clear();
				cubesEast.Clear();
				cubesSouth.Clear();
				cubesWest.Clear();
			}
		}

		private void RefreshStuff()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			cubesPerSide = Mathf.FloorToInt(radius);
			sideLength = radius * 2f;
			cubesLength100 = sideLength / (float)cubesPerSide;
			sideLengthHalved = sideLength / 2f;
			translatedRotation = Quaternion.Euler(0f, (float)rotation, 0f);
			if (isRunning)
			{
				if (cubesPerSide + 1 != cubesNorth.Count)
				{
					StopProjecting();
					StartProjecting();
				}
				if (translatedRotation != center.rotation)
				{
					center.rotation = translatedRotation;
				}
			}
		}

		private Transform CreateElements(int localRotation, List<Transform> cubes)
		{
			//IL_0007: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = new GameObject(localRotation.ToString()).transform;
			((Component)transform).transform.position = center.position;
			((Component)transform).transform.RotateAround(center.position, Vector3.up, (float)localRotation);
			transform.SetParent(center);
			for (int i = 0; i < cubesPerSide + 1; i++)
			{
				cubes.Add(Object.Instantiate<GameObject>(cube, ((Component)this).transform.position, Quaternion.identity, transform).transform);
			}
			Transform transform2 = new GameObject("Start").transform;
			Transform transform3 = new GameObject("End").transform;
			transform2.SetParent(transform);
			transform3.SetParent(transform);
			for (int j = 0; j < cubes.Count; j++)
			{
				cubes[j].forward = transform.right;
			}
			return transform;
		}

		private IEnumerator AnimateElements(Transform cubeParent, List<Transform> cubes)
		{
			Transform a = cubeParent.Find("Start");
			Transform b = cubeParent.Find("End");
			Vector3 localScale = default(Vector3);
			RaycastHit val4 = default(RaycastHit);
			while (true)
			{
				RefreshStuff();
				a.position = cubeParent.forward * (sideLengthHalved - cubesThickness / 2f) - cubeParent.right * sideLengthHalved + cubeParent.position;
				b.position = cubeParent.forward * (sideLengthHalved - cubesThickness / 2f) + cubeParent.right * sideLengthHalved + cubeParent.position;
				Vector3 val = b.position - a.position;
				for (int i = 0; i < cubes.Count; i++)
				{
					Transform val2 = cubes[i];
					((Component)val2).gameObject.SetActive(true);
					float num = (Time.time * cubesSpeed + sideLength / (float)cubesPerSide * (float)i) % (sideLength + cubesLength100);
					Vector3 val3;
					if (num < cubesLength)
					{
						val3 = ((Vector3)(ref val)).normalized * num + a.position;
						((Vector3)(ref localScale))..ctor(val2.localScale.x, val2.localScale.y, cubesLength - (cubesLength - num));
					}
					else if (num >= sideLength && num <= sideLength + cubesLength)
					{
						val3 = ((Vector3)(ref val)).normalized * sideLength + a.position;
						((Vector3)(ref localScale))..ctor(val2.localScale.x, val2.localScale.y, cubesLength - (num - sideLength));
					}
					else
					{
						if (num >= sideLength && num >= sideLength + cubesLength)
						{
							((Component)val2).gameObject.SetActive(false);
							continue;
						}
						val3 = ((Vector3)(ref val)).normalized * num + a.position;
						((Vector3)(ref localScale))..ctor(val2.localScale.x, val2.localScale.y, cubesLength);
					}
					if (Physics.Raycast(val3 + Vector3.up * 500f, Vector3.down, ref val4, 1000f, ((LayerMask)(ref mask)).value))
					{
						val3.y = ((RaycastHit)(ref val4)).point.y;
					}
					val2.position = val3;
					val2.localScale = localScale;
				}
				yield return (object)new WaitForSecondsRealtime(1f / updatesPerSecond);
			}
		}
	}
	internal class DebugUtils
	{
		public static void InitLaserGrid(GameObject gameObject, Bounds bounds)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = gameObject.transform;
			Material material = Resources.FindObjectsOfTypeAll<Material>().First((Material k) => ((Object)k).name == "Default-Line");
			int num = 0;
			for (int num2 = -1; num2 <= 1; num2++)
			{
				for (int num3 = -1; num3 <= 1; num3++)
				{
					Color color = ((num2 == 0 && num3 == 0) ? Color.red : Color.gray);
					CreateLaser(transform, num++, bounds, new Vector3(-1f, (float)num2, (float)num3), new Vector3(1f, (float)num2, (float)num3), material, color);
					CreateLaser(transform, num++, bounds, new Vector3((float)num2, -1f, (float)num3), new Vector3((float)num2, 1f, (float)num3), material, color);
					CreateLaser(transform, num++, bounds, new Vector3((float)num2, (float)num3, -1f), new Vector3((float)num2, (float)num3, 1f), material, color);
				}
			}
		}

		private static void CreateLaser(Transform parent, int i, Bounds bounds, Vector3 first, Vector3 second, Material material, Color color)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("laser_" + i, new Type[1] { typeof(LineRenderer) });
			val.transform.SetParent(parent);
			LineRenderer component = val.GetComponent<LineRenderer>();
			component.useWorldSpace = false;
			((Renderer)component).material = material;
			component.startColor = color;
			component.endColor = color;
			component.startWidth = 0.005f;
			component.endWidth = 0.005f;
			Vector3 extents = ((Bounds)(ref bounds)).extents;
			component.SetPositions((Vector3[])(object)new Vector3[2]
			{
				((Bounds)(ref bounds)).center + Vector3.Scale(first, extents),
				((Bounds)(ref bounds)).center + Vector3.Scale(second, extents)
			});
		}
	}
	public class ShaderHelper
	{
		public enum ShaderState
		{
			Supported,
			Floating,
			Skuld
		}

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

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

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

		private static Shader _planShader;

		public static Shader PlanShader => _planShader ?? (_planShader = Cache.GetPrefab<Shader>("Lux Lit Particles/ Bumped"));

		public static void ClearCache()
		{
			UnsupportedMaterialDict.Clear();
			SupportedMaterialDict.Clear();
		}

		public static Texture2D GetTexture(Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(1, 1);
			val.SetPixel(0, 0, color);
			return val;
		}

		public static Texture2D CreateScaledTexture(Texture2D texture, int width)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			Texture2D val = new Texture2D(((Texture)texture).width, ((Texture)texture).height, texture.format, false);
			val.SetPixels(texture.GetPixels());
			val.Apply();
			ScaleTexture(val, width);
			return val;
		}

		public static void ScaleTexture(Texture2D texture, int width)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(((Texture)texture).width, ((Texture)texture).height, texture.format, false);
			val.SetPixels(texture.GetPixels());
			val.Apply();
			int num = (int)Math.Round((float)width * (float)((Texture)texture).height / (float)((Texture)texture).width);
			texture.Reinitialize(width, num);
			texture.Apply();
			Color[] pixels = texture.GetPixels(0);
			float num2 = 1f / (float)width;
			float num3 = 1f / (float)num;
			for (int i = 0; i < pixels.Length; i++)
			{
				pixels[i] = val.GetPixelBilinear(num2 * ((float)i % (float)width), num3 * Mathf.Floor((float)i / (float)width));
			}
			texture.SetPixels(pixels, 0);
			texture.Apply();
			Object.Destroy((Object)(object)val);
		}

		public static List<Renderer> GetRenderers(GameObject gameObject)
		{
			List<Renderer> list = new List<Renderer>();
			list.AddRange((IEnumerable<Renderer>)(object)gameObject.GetComponentsInChildren<MeshRenderer>());
			list.AddRange((IEnumerable<Renderer>)(object)gameObject.GetComponentsInChildren<SkinnedMeshRenderer>());
			return list;
		}

		public static void UpdateTextures(GameObject gameObject, ShaderState shaderState)
		{
			WearNTear val = default(WearNTear);
			if (gameObject.TryGetComponent<WearNTear>(ref val) && val.m_oldMaterials != null)
			{
				val.ResetHighlight();
			}
			foreach (Renderer renderer in GetRenderers(gameObject))
			{
				if ((Object)(object)renderer.sharedMaterial != (Object)null)
				{
					Material[] sharedMaterials = renderer.sharedMaterials;
					UpdateMaterials(shaderState, sharedMaterials);
					renderer.sharedMaterials = sharedMaterials;
					renderer.shadowCastingMode = (ShadowCastingMode)0;
				}
			}
		}

		private static string AdjustMaterialName(string name)
		{
			return name.Split(new char[1] { ' ' })[0];
		}

		private static void UpdateMaterials(ShaderState shaderState, Material[] sharedMaterials)
		{
			for (int i = 0; i < sharedMaterials.Length; i++)
			{
				Material val = sharedMaterials[i];
				if (!((Object)(object)val == (Object)null))
				{
					string key = AdjustMaterialName(((Object)val).name);
					if (!OriginalMaterialDict.ContainsKey(key))
					{
						OriginalMaterialDict[key] = val;
					}
					sharedMaterials[i] = GetMaterial(shaderState, val);
				}
			}
		}

		private static Material GetMaterial(ShaderState shaderState, Material originalMaterial)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			float value = Config.TransparencyConfig.Value;
			value *= value;
			switch (shaderState)
			{
			case ShaderState.Skuld:
				return OriginalMaterialDict[AdjustMaterialName(((Object)originalMaterial).name)];
			case ShaderState.Supported:
			{
				if (!SupportedMaterialDict.TryGetValue(((Object)originalMaterial).name, out var value4))
				{
					value4 = new Material(originalMaterial)
					{
						name = ((Object)originalMaterial).name
					};
					value4.SetOverrideTag("RenderType", "Transparent");
					value4.shader = PlanShader;
					Color value5 = Config.SupportedPlanColorConfig.Value;
					value5.a *= value;
					value4.color = value5;
					value4.EnableKeyword("_EMISSION");
					value4.DisableKeyword("DIRECTIONAL");
					SupportedMaterialDict[((Object)originalMaterial).name] = value4;
				}
				return value4;
			}
			case ShaderState.Floating:
			{
				if (!UnsupportedMaterialDict.TryGetValue(((Object)originalMaterial).name, out var value2))
				{
					value2 = new Material(originalMaterial)
					{
						name = ((Object)originalMaterial).name
					};
					value2.SetOverrideTag("RenderType", "Transparent");
					value2.shader = PlanShader;
					Color value3 = Config.UnsupportedColorConfig.Value;
					value3.a *= value;
					value2.color = value3;
					value2.EnableKeyword("_EMISSION");
					value2.DisableKeyword("DIRECTIONAL");
					UnsupportedMaterialDict[((Object)originalMaterial).name] = value2;
				}
				return value2;
			}
			default:
				throw new ArgumentException("Unknown shaderState: " + shaderState);
			}
		}

		internal static void SetEmissionColor(GameObject gameObject, Color color)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			foreach (Renderer renderer in GetRenderers(gameObject))
			{
				if (renderer.sharedMaterials.Length != 0)
				{
					SetEmissionColor(renderer.materials, color);
				}
			}
		}

		private static void SetEmissionColor(Material[] sharedMaterials, Color color)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			foreach (Material val in sharedMaterials)
			{
				if (val.HasProperty("_EmissionColor"))
				{
					val.SetColor("_EmissionColor", color);
				}
			}
		}

		public static Texture2D FromHeightmap(Heightmap terrain)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return FromHeightmap(terrain, Color.gray, Color.black);
		}

		public static Texture2D FromHeightmap(Heightmap terrain, Color bandColor, Color bkgColor)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			int width = terrain.m_width;
			int width2 = terrain.m_width;
			Texture2D val = new Texture2D(width, width2)
			{
				anisoLevel = 16
			};
			Color[] array = (Color[])(object)new Color[width * width2];
			for (int i = 0; i < width2; i++)
			{
				for (int j = 0; j < width; j++)
				{
					array[i * width + j] = bkgColor;
				}
			}
			float num = 1f;
			float num2 = 0f;
			for (int k = 0; k < width2; k++)
			{
				for (int l = 0; l < width; l++)
				{
					float height = terrain.GetHeight(l, k);
					if (num > height)
					{
						num = height;
					}
					if (num2 < height)
					{
						num2 = height;
					}
				}
			}
			float num3 = 1f;
			List<float> list = new List<float>();
			for (float num4 = num + num3; num4 < num2; num4 += num3)
			{
				list.Add(num4);
			}
			bool[,] array2 = new bool[width, width2];
			for (int m = 0; m < list.Count; m++)
			{
				for (int n = 0; n < width2; n++)
				{
					for (int num5 = 0; num5 < width; num5++)
					{
						if (terrain.GetHeight(num5, n) >= list[m])
						{
							array2[num5, n] = true;
						}
						else
						{
							array2[num5, n] = false;
						}
					}
				}
				for (int num6 = 1; num6 < width2 - 1; num6++)
				{
					for (int num7 = 1; num7 < width - 1; num7++)
					{
						if (array2[num7, num6] && (!array2[num7 - 1, num6] || !array2[num7 + 1, num6] || !array2[num7, num6 - 1] || !array2[num7, num6 + 1]))
						{
							int num8 = (width2 - num6 - 1) * width + (width - num7 - 1);
							array[num8] = bandColor;
						}
					}
				}
			}
			val.SetPixels(array);
			val.Apply();
			return val;
		}
	}
}
namespace PlanBuild.Plans
{
	internal class PlanCommands
	{
		private class PrintBlacklistCommand : ConsoleCommand
		{
			public override string Name => "plan.blacklist.print";

			public override string Help => "Print out the server's plan blacklist";

			public override void Run(string[] args)
			{
				if (Object.op_Implicit((Object)(object)ZNet.instance))
				{
					if (!SynchronizationManager.Instance.PlayerIsAdmin)
					{
						Console.instance.Print("You need to be admin for this");
					}
					else
					{
						Console.instance.Print(GeneralExtensions.Join<string>((IEnumerable<string>)PlanBlacklist.GetNames(), (Func<string, string>)null, ", ") ?? "");
					}
				}
			}
		}

		private class AddBlacklistCommand : ConsoleCommand
		{
			public override string Name => "plan.blacklist.add";

			public override string Help => "[prefab_name] Add a prefab to the server's plan blacklist";

			public override void Run(string[] args)
			{
				if (!Object.op_Implicit((Object)(object)ZNet.instance))
				{
					return;
				}
				if (!SynchronizationManager.Instance.PlayerIsAdmin)
				{
					Console.instance.Print("You need to be admin for this");
					return;
				}
				if (args.Length != 1 || string.IsNullOrWhiteSpace(args[0]))
				{
					Console.instance.Print("Usage: " + ((ConsoleCommand)this).Name + " [prefab_name]");
					return;
				}
				string text = args[0].Trim();
				GameObject prefab = PrefabManager.Instance.GetPrefab(text);
				if (!Object.op_Implicit((Object)(object)prefab))
				{
					Console.instance.Print("Prefab " + text + " does not exist");
				}
				else if (!Object.op_Implicit((Object)(object)prefab.GetComponent<Piece>()))
				{
					Console.instance.Print("Prefab " + text + " has no piece component");
				}
				else
				{
					PlanBlacklist.Add(text);
				}
			}

			public override List<string> CommandOptionList()
			{
				return ZNetScene.instance.GetPrefabNames();
			}
		}

		private class RemoveBlacklistCommand : ConsoleCommand
		{
			public override string Name => "plan.blacklist.remove";

			public override string Help => "[prefab_name] Removes a prefab from the server's plan blacklist";

			public override void Run(string[] args)
			{
				if (Object.op_Implicit((Object)(object)ZNet.instance))
				{
					if (!SynchronizationManager.Instance.PlayerIsAdmin)
					{
						Console.instance.Print("You need to be admin for this");
						return;
					}
					if (args.Length != 1 || string.IsNullOrWhiteSpace(args[0]))
					{
						Console.instance.Print("Usage: " + ((ConsoleCommand)this).Name + " [prefab_name]");
						return;
					}
					string prefabName = args[0].Trim();
					PlanBlacklist.Remove(prefabName);
				}
			}

			public override List<string> CommandOptionList()
			{
				return PlanBlacklist.GetNames();
			}
		}

		public static void Init()
		{
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new PrintBlacklistCommand());
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AddBlacklistCommand());
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new RemoveBlacklistCommand());
		}
	}
	internal class PlanBlacklist
	{
		private static readonly List<string> Names = new List<string>();

		private static readonly List<int> Hashes = new List<int>();

		public static void Init()
		{
			Reload();
			SynchronizationManager.OnConfigurationSynchronized += delegate
			{
				Reload();
			};
			SynchronizationManager.OnAdminStatusChanged += PlanManager.UpdateKnownRecipes;
		}

		public static void Reload()
		{
			Names.Clear();
			Hashes.Clear();
			foreach (string item in from x in Config.PlanBlacklistConfig.Value.Split(new char[1] { ',' })
				select x.Trim() into x
				where !string.IsNullOrEmpty(x)
				select x)
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode(item);
				if (!Hashes.Contains(stableHashCode))
				{
					Logger.LogDebug((object)("Adding " + item + " to plan blacklist"));
					Names.Add(item);
					Hashes.Add(stableHashCode);
				}
			}
			PlanManager.UpdateKnownRecipes();
		}

		public static List<string> GetNames()
		{
			return Names.OrderBy((string x) => x).ToList();
		}

		public static void Add(string prefabName)
		{
			if (!SynchronizationManager.Instance.PlayerIsAdmin)
			{
				return;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(prefabName.Trim());
			if (!Hashes.Contains(stableHashCode))
			{
				Names.Add(prefabName);
				Hashes.Add(stableHashCode);
				Config.PlanBlacklistConfig.Value = GeneralExtensions.Join<string>((IEnumerable<string>)Names.OrderBy((string x) => x), (Func<string, string>)null, ", ");
				((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Reload();
			}
		}

		public static void Remove(string prefabName)
		{
			if (!SynchronizationManager.Instance.PlayerIsAdmin)
			{
				return;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(prefabName.Trim());
			if (Hashes.Contains(stableHashCode))
			{
				Names.Remove(prefabName);
				Hashes.Remove(stableHashCode);
				Config.PlanBlacklistConfig.Value = GeneralExtensions.Join<string>((IEnumerable<string>)Names.OrderBy((string x) => x), (Func<string, string>)null, ", ");
				((BaseUnityPlugin)PlanBuildPlugin.Instance).Config.Reload();
			}
		}

		public static bool Contains(PlanPiecePrefab planPiecePrefab)
		{
			if (SynchronizationManager.Instance.PlayerIsAdmin)
			{
				return false;
			}
			if (!Object.op_Implicit((Object)(object)planPiecePrefab.OriginalPiece))
			{
				return false;
			}
			return Hashes.Contains(planPiecePrefab.OriginalHash);
		}

		public static bool Contains(Piece piece)
		{
			if (SynchronizationManager.Instance.PlayerIsAdmin)
			{
				return false;
			}
			if (!Object.op_Implicit((Object)(object)piece))
			{
				return false;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)piece).name.Split(new char[1] { '(' })[0].Trim());
			return Hashes.Contains(stableHashCode);
		}

		public static bool Contains(string pieceName)
		{
			if (SynchronizationManager.Instance.PlayerIsAdmin)
			{
				return false;
			}
			if (string.IsNullOrEmpty(pieceName))
			{
				return false;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(pieceName);
			return Hashes.Contains(stableHashCode);
		}
	}
	internal class PlanDB
	{
		private class PieceRequirements
		{
			private readonly Dictionary<string, int> requirements;

			public PieceRequirements(Dictionary<string, int> requirements)
			{
				this.requirements = requirements;
			}

			public override int GetHashCode()
			{
				int num = 13;
				IOrderedEnumerable<KeyValuePair<string, int>> orderedEnumerable = requirements.OrderBy((KeyValuePair<string, int> kvp) => kvp.Key);
				foreach (KeyValuePair<string, int> item in orderedEnumerable)
				{
					num = num * 7 + item.Key.GetHashCode();
					num = num * 7 + item.Value.GetHashCode();
				}
				return num;
			}

			public override bool Equals(object obj)
			{
				if (!(obj is PieceRequirements pieceRequirements))
				{
					return false;
				}
				if (requirements.Count == pieceRequirements.requirements.Count)
				{
					return !requirements.Except(pieceRequirements.requirements).Any();
				}
				return false;
			}

			public override string ToString()
			{
				return string.Join(", ", requirements.Select((KeyValuePair<string, int> x) => x.Key + ":" + x.Value));
			}
		}

		private static PlanDB _instance;

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

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

		public Dictionary<string, List<Piece>> NamePiecePrefabMapping = new Dictionary<string, List<Piece>>();

		public static PlanDB Instance => _instance ?? (_instance = new PlanDB());

		private static bool IsValidPieceTable(PieceTable pieceTable)
		{
			if (Object.op_Implicit((Object)(object)pieceTable))
			{
				if (!((Object)pieceTable).name.Equals("_PlanHammerPieceTable"))
				{
					return !((Object)pieceTable).name.Equals("_BlueprintPieceTable");
				}
				return false;
			}
			return false;
		}

		public void ScanPieceTables()
		{
			Logger.LogDebug((object)"Scanning PieceTables for Pieces");
			PieceTable pieceTable = PieceManager.Instance.GetPieceTable("_PlanHammerPieceTable");
			IEnumerable<PieceTable> enumerable = Resources.FindObjectsOfTypeAll<PieceTable>().Where(IsValidPieceTable);
			HashSet<string> hashSet = new HashSet<string>();
			foreach (PieceTable item in enumerable)
			{
				foreach (GameObject piece in item.m_pieces)
				{
					if (!Object.op_Implicit((Object)(object)piece))
					{
						Logger.LogWarning((object)("Invalid prefab in " + ((Object)item).name + " PieceTable"));
						continue;
					}
					Piece component = piece.GetComponent<Piece>();
					if (!Object.op_Implicit((Object)(object)component))
					{
						Logger.LogWarning((object)("Prefab " + ((Object)piece).name + " has no Piece?!"));
					}
					else
					{
						if (((Object)component).name == "piece_repair" || ((Object)component).name == "piece_remove_feaster")
						{
							continue;
						}
						if (hashSet.Contains(((Object)component).name))
						{
							Logger.LogDebug((object)("Multiple prefabs with name: " + ((Object)component).name));
						}
						else
						{
							hashSet.Add(((Object)component).name);
						}
						try
						{
							if (OriginalToPlanMap.TryGetValue(((Object)component).name, out var value))
							{
								((CustomPiece)value).Piece.m_enabled = component.m_enabled;
								((CustomPiece)value).Piece.m_icon = component.m_icon;
							}
							else if (CanCreatePlan(component) && EnsurePrefabRegistered(component))
							{
								PlanPiecePrefab planPiecePrefab = new PlanPiecePrefab(component);
								PrefabManager.Instance.RegisterToZNetScene(((CustomPiece)planPiecePrefab).PiecePrefab);
								PieceManager.Instance.AddPiece((CustomPiece)(object)planPiecePrefab);
								PlanToOriginalMap.Add(((Object)((CustomPiece)planPiecePrefab).PiecePrefab).name, planPiecePrefab.OriginalPiece);
								OriginalToPlanMap.Add(((Object)component).name, planPiecePrefab);
								if (!NamePiecePrefabMapping.TryGetValue(component.m_name, out var value2))
								{
									value2 = new List<Piece>();
									NamePiecePrefabMapping.Add(component.m_name, value2);
								}
								value2.Add(component);
							}
						}
						catch (Exception arg)
						{
							Logger.LogWarning((object)$"Error while creating plan of {((Object)component).name}: {arg}");
						}
					}
				}
			}
			pieceTable.m_pieces.Clear();
			foreach (string key in OriginalToPlanMap.Keys)
			{
				try
				{
					if (hashSet.Contains(key) && OriginalToPlanMap.TryGetValue(key, out var value3))
					{
						pieceTable.m_pieces.Add(((CustomPiece)value3).PiecePrefab);
					}
				}
				catch (Exception arg2)
				{
					Logger.LogWarning((object)$"Error while adding plan {key} to table: {arg2}");
				}
			}
			WarnDuplicatesWithDifferentResources();
		}

		private void WarnDuplicatesWithDifferentResources()
		{
			Dictionary<string, IEnumerable<IGrouping<PieceRequirements, Piece>>> dictionary = new Dictionary<string, IEnumerable<IGrouping<PieceRequirements, Piece>>>();
			foreach (KeyValuePair<string, List<Piece>> item in NamePiecePrefabMapping)
			{
				List<Piece> value = item.Value;
				if (value.Count != 1)
				{
					IEnumerable<IGrouping<PieceRequirements, Piece>> enumerable = from x in value
						group x by GetResourceMap(x);
					if (enumerable.Count() > 1)
					{
						dictionary[item.Key] = enumerable;
					}
				}
			}
			if (!dictionary.Any())
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Warning for mod developers:\nMultiple pieces with the same m_name but different resource requirements, this will cause issues with Player.m_knownRecipes!");
			foreach (KeyValuePair<string, IEnumerable<IGrouping<PieceRequirements, Piece>>> item2 in dictionary)
			{
				stringBuilder.AppendLine("Piece.m_name: " + item2.Key);
				foreach (IGrouping<PieceRequirements, Piece> item3 in item2.Value)
				{
					stringBuilder.AppendLine($" Requirements: {item3.Key}");
					stringBuilder.AppendLine(" Pieces: " + string.Join(", ", item3.Select((Piece x) => ((Object)x).name)) + "\n");
				}
			}
			Logger.LogWarning((object)stringBuilder.ToString());
		}

		private PieceRequirements GetResourceMap(Piece y)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(y.m_resources.Length);
			Requirement[] resources = y.m_resources;
			foreach (Requirement val in resources)
			{
				dictionary[val.m_resItem.m_itemData.m_shared.m_name] = val.m_amount;
			}
			return new PieceRequirements(dictionary);
		}

		internal IEnumerable<PlanPiecePrefab> GetPlanPiecePrefabs()
		{
			return OriginalToPlanMap.Values;
		}

		private bool EnsurePrefabRegistered(Piece piece)
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab = PrefabManager.Instance.GetPrefab(((Object)((Component)piece).gameObject).name);
			if (Object.op_Implicit((Object)(object)prefab))
			{
				return true;
			}
			Logger.LogWarning((object)("Piece " + ((Object)piece).name + " in Hammer not fully registered? Could not find prefab " + ((Object)((Component)piece).gameObject).name));
			if (!ZNetScene.instance.m_prefabs.Contains(((Component)piece).gameObject))
			{
				Logger.LogWarning((object)" Not registered in ZNetScene.m_prefabs! Adding now");
				ZNetScene.instance.m_prefabs.Add(((Component)piece).gameObject);
			}
			if (!ZNetScene.instance.m_namedPrefabs.ContainsKey(StringExtensionMethods.GetStableHashCode(((Object)((Component)piece).gameObject).name)))
			{
				Logger.LogWarning((object)" Not registered in ZNetScene.m_namedPrefabs! Adding now");
				ZNetScene.instance.m_namedPrefabs[StringExtensionMethods.GetStableHashCode(((Object)((Component)piece).gameObject).name)] = ((Component)piece).gameObject;
			}
			Transform parent = ((Component)piece).gameObject.transform.parent;
			GameObject val = ((parent != null) ? ((Component)parent).gameObject : null);
			if (!Object.op_Implicit((Object)(object)val))
			{
				Logger.LogWarning((object)" Prefab has no parent?! Adding to Jotunn");
				PrefabManager.Instance.AddPrefab(((Component)piece).gameObject);
			}
			else
			{
				Scene scene = val.scene;
				if (((Scene)(ref scene)).buildIndex != -1)
				{
					Logger.LogWarning((object)" Prefab container not marked as DontDestroyOnLoad! Marking now");
					Object.DontDestroyOnLoad((Object)(object)val);
				}
			}
			return (Object)(object)PrefabManager.Instance.GetPrefab(((Object)((Component)piece).gameObject).name) != (Object)null;
		}

		internal bool FindOriginalByPrefabName(string name, out Piece originalPiece)
		{
			return PlanToOriginalMap.TryGetValue(name, out originalPiece);
		}

		internal bool FindOriginalByPieceName(string m_name, out List<Piece> originalPieces)
		{
			return NamePiecePrefabMapping.TryGetValue(m_name, out originalPieces);
		}

		internal bool FindPlanByPrefabName(string name, out PlanPiecePrefab planPiecePrefab)
		{
			int num = name.IndexOf("(Clone)", StringComparison.Ordinal);
			if (num != -1)
			{
				name = name.Substring(0, num);
			}
			return OriginalToPlanMap.TryGetValue(name, out planPiecePrefab);
		}

		public bool CanCreatePlan(Piece piece)
		{
			if ((Object)(object)((Component)piece).GetComponent<Plant>() == (Object)null && (Object)(object)((Component)piece).GetComponent<TerrainOp>() == (Object)null && (Object)(object)((Component)piece).GetComponent<TerrainModifier>() == (Object)null && (Object)(object)((Component)piece).GetComponent<Ship>() == (Object)null && (Object)(object)((Component)piece).GetComponent<PlanPiece>() == (Object)null)
			{
				return !((Object)piece).name.Equals("piece_plan_totem");
			}
			return false;
		}
	}
	internal class PlanHammerPrefab
	{
		private class DeletePlansComponent : MonoBehaviour
		{
			private Piece LastHoveredPiece;

			private void Start()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				Player.PieceRayTest += new hook_PieceRayTest(Player_PieceRayTest);
				Player.TryPlacePiece += new hook_TryPlacePiece(Player_TryPlacePiece);
				Logger.LogDebug((object)(((Object)((Component)this).gameObject).name + " started"));
			}

			private void OnDestroy()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				Player.TryPlacePiece -= new hook_TryPlacePiece(Player_TryPlacePiece);
				Player.PieceRayTest -= new hook_PieceRayTest(Player_PieceRayTest);
				Logger.LogDebug((object)(((Object)((Component)this).gameObject).name + " destroyed"));
			}

			private bool Player_PieceRayTest(orig_PieceRayTest orig, Player self, out Vector3 point, out Vector3 normal, out Piece piece, out Heightmap heightmap, out Collider waterSurface, bool water)
			{
				bool result = orig.Invoke(self, ref point, ref normal, ref piece, ref heightmap, ref waterSurface, water);
				LastHoveredPiece = piece;
				return result;
			}

			private bool Player_TryPlacePiece(orig_TryPlacePiece orig, Player self, Piece piece)
			{
				PlanPiece planPiece = default(PlanPiece);
				if (Object.op_Implicit((Object)(object)LastHoveredPiece) && ((Component)LastHoveredPiece).TryGetComponent<PlanPiece>(ref planPiece))
				{
					planPiece.m_wearNTear.Remove(false);
				}
				return false;
			}
		}

		public const string PlanHammerName = "PlanHammer";

		public const string PlanHammerItemName = "$item_plan_hammer";

		public const string PieceTableName = "_PlanHammerPieceTable";

		public const string PieceDeletePlansName = "piece_plan_delete";

		private static Sprite HammerIcon;

		private static GameObject PieceDeletePlansPrefab;

		private static CustomItem PlanHammerItem;

		public static void Create(AssetBundle planbuildBundle)
		{
			HammerIcon = planbuildBundle.LoadAsset<Sprite>("plan_hammer");
			PieceDeletePlansPrefab = planbuildBundle.LoadAsset<GameObject>("piece_plan_delete");
			PrefabManager.OnVanillaPrefabsAvailable += CreatePlanHammerItem;
			PieceManager.OnPiecesRegistered += CreatePlanTable;
			GUIManager.OnCustomGUIAvailable += CreateCustomKeyHints;
		}

		private static void CreatePlanHammerItem()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			try
			{
				Logger.LogDebug((object)"Creating PlanHammer item");
				ItemConfig val = new ItemConfig();
				val.Name = "$item_plan_hammer";
				val.Description = "$item_plan_hammer_description";
				val.Icons = (Sprite[])(object)new Sprite[1] { HammerIcon };
				val.Requirements = (RequirementConfig[])(object)new RequirementConfig[1]
				{
					new RequirementConfig
					{
						Item = "Wood",
						Amount = 1
					}
				};
				PlanHammerItem = new CustomItem("PlanHammer", "Hammer", val);
				ItemManager.Instance.AddItem(PlanHammerItem);
				SharedData shared = PlanHammerItem.ItemDrop.m_itemData.m_shared;
				shared.m_useDurability = false;
				shared.m_maxQuality = 1;
				shared.m_weight = 0f;
				shared.m_buildPieces = null;
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"Error caught while creating the PlanHammer item: {arg}");
			}
			finally
			{
				PrefabManager.OnVanillaPrefabsAvailable -= CreatePlanHammerItem;
			}
		}

		private static void CreatePlanTable()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			try
			{
				Logger.LogDebug((object)"Creating PlanHammer piece table");
				List<string> list = (from x in PieceManager.Instance.GetPieceCategoriesMap()
					where x.Value != "Blueprints" && x.Value != "Clipboard" && x.Value != "Tools"
					select x.Value).ToList();
				CustomPieceTable val = new CustomPieceTable("_PlanHammerPieceTable", new PieceTableConfig
				{
					CanRemovePieces = true,
					UseCategories = true,
					UseCustomCategories = true,
					CustomCategories = list.ToArray()
				});
				PieceManager.Instance.AddPieceTable(val);
				for (int num = val.PieceTable.m_availablePiecesByCategory.Count; num < 100; num++)
				{
					val.PieceTable.m_availablePiecesByCategory.Add(new List<Piece>());
				}
				Array.Resize(ref val.PieceTable.m_selectedPiece, val.PieceTable.m_availablePiecesByCategory.Count);
				PlanHammerItem.ItemDrop.m_itemData.m_shared.m_buildPieces = val.PieceTable;
				PieceDeletePlansPrefab.AddComponent<DeletePlansComponent>();
				CustomPiece val2 = new CustomPiece(PieceDeletePlansPrefab, "_PlanHammerPieceTable", false);
				PieceManager.Instance.AddPiece(val2);
				PieceManager.Instance.RegisterPieceInPieceTable(PieceDeletePlansPrefab, "_PlanHammerPieceTable", "All");
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"Error caught while creating the PlanHammer table: {arg}");
			}
			finally
			{
				PieceManager.OnPiecesRegistered -= CreatePlanTable;
			}
		}

		private static void CreateCustomKeyHints()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			KeyHintManager instance = KeyHintManager.Instance;
			KeyHintConfig val = new KeyHintConfig();
			val.Item = "PlanHammer";
			val.Piece = "piece_plan_delete";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[1]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_plandelete"
				}
			};
			instance.AddKeyHint(val);
			GUIManager.OnCustomGUIAvailable -= CreateCustomKeyHints;
		}
	}
	internal class OdinLevel : MonoBehaviour, Interactable, Hoverable
	{
		public string GetHoverName()
		{
			return "Level";
		}

		public string GetHoverText()
		{
			return Localization.instance.Localize("[<color=yellow>$KEY_Use</color>] Toggle grid");
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			return true;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}

		public float GetHoverOffset()
		{
			return 0f;
		}
	}
	internal class OdinLevelPrefab
	{
		private int radius = 10;

		private float distance = 1f;

		private KitbashObject odinLevelPrefab;

		public OdinLevelPrefab(AssetBundle planbuildBundle)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_008b: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			odinLevelPrefab = KitbashManager.Instance.AddKitbash(planbuildBundle.LoadAsset<GameObject>("piece_odin_level"), new KitbashConfig
			{
				Layer = "piece",
				KitbashSources = new List<KitbashSourceConfig>
				{
					new KitbashSourceConfig
					{
						SourcePrefab = "SurtlingCore",
						SourcePath = "attach/core",
						TargetParentPath = "new",
						Scale = Vector3.one * 0.1104584f
					}
				}
			});
			KitbashObject obj = odinLevelPrefab;
			obj.OnKitbashApplied = (Action)Delegate.Combine(obj.OnKitbashApplied, new Action(InitLaserGrid));
			GameObject prefab = odinLevelPrefab.Prefab;
			PieceConfig val = new PieceConfig();
			val.PieceTable = "Hammer";
			val.Requirements = (RequirementConfig[])(object)new RequirementConfig[1]
			{
				new RequirementConfig
				{
					Item = "SurtlingCore",
					Recover = true
				}
			};
			CustomPiece val2 = new CustomPiece(prefab, false, val);
			PieceManager.Instance.AddPiece(val2);
			val2.PiecePrefab.AddComponent<OdinLevel>();
		}

		private void InitLaserGrid()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Material material = Resources.FindObjectsOfTypeAll<Material>().First((Material k) => ((Object)k).name == "Default-Line");
			int num = 1 + (int)Math.Ceiling((float)radius * 2f / distance);
			List<GameObject> list = new List<GameObject>();
			int num2 = 0;
			for (int num3 = -2; num3 <= 2; num3++)
			{
				for (int num4 = -2; num4 <= 2; num4++)
				{
					Color color = ((num3 == 0 && num4 == 0) ? Color.red : Color.gray);
					list.Add(CreateLaser(num2++, new Vector3(-2f, (float)num3, (float)num4), new Vector3(2f, (float)num3, (float)num4), material, color));
					list.Add(CreateLaser(num2++, new Vector3((float)num3, -2f, (float)num4), new Vector3((float)num3, 2f, (float)num4), material, color));
					list.Add(CreateLaser(num2++, new Vector3((float)num3, (float)num4, -2f), new Vector3((float)num3, (float)num4, 2f), material, color));
				}
			}
		}

		private GameObject CreateLaser(int i, Vector3 first, Vector3 second, Material material, Color color)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("laser_" + i, new Type[1] { typeof(LineRenderer) });
			LineRenderer component = val.GetComponent<LineRenderer>();
			component.useWorldSpace = false;
			((Renderer)component).material = material;
			component.startColor = color;
			component.endColor = color;
			component.startWidth = 0.005f;
			component.endWidth = 0.005f;
			component.SetPositions((Vector3[])(object)new Vector3[2] { first, second });
			val.transform.SetParent(odinLevelPrefab.Prefab.transform);
			return val;
		}
	}
	internal class PlanCrystalPrefab
	{
		private const string PrefabName = "PlanCrystal";

		private const string LocalizationName = "plan_crystal";

		public static bool ShowRealTextures;

		private static Sprite CrystalIcon;

		private static CustomItem PlanCrystalItem;

		public static void Create(AssetBundle planbuildBundle)
		{
			CrystalIcon = planbuildBundle.LoadAsset<Sprite>("plan_crystal");
			PrefabManager.OnVanillaPrefabsAvailable += CreatePlanCrystalItem;
			ItemManager.OnItemsRegistered += FixShader;
		}

		private static void CreatePlanCrystalItem()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_0129: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Logger.LogDebug((object)"Creating PlanCrystal item");
				ItemConfig val = new ItemConfig();
				val.Name = "$item_plan_crystal";
				val.Description = "$item_plan_crystal_description";
				val.Icons = (Sprite[])(object)new Sprite[1] { CrystalIcon };
				val.CraftingStation = "piece_workbench";
				val.Requirements = (RequirementConfig[])(object)new RequirementConfig[1]
				{
					new RequirementConfig
					{
						Item = "GreydwarfEye",
						Amount = 1
					}
				};
				PlanCrystalItem = new CustomItem("PlanCrystal", "GreydwarfEye", val);
				SharedData shared = PlanCrystalItem.ItemDrop.m_itemData.m_shared;
				ScriptableObject obj = ScriptableObject.CreateInstance(typeof(StatusEffect));
				StatusEffect val2 = (StatusEffect)(object)((obj is StatusEffect) ? obj : null);
				val2.m_icon = CrystalIcon;
				val2.m_startMessageType = (MessageType)2;
				val2.m_startMessage = "$message_plan_crystal_start";
				val2.m_stopMessageType = (MessageType)2;
				val2.m_stopMessage = "$message_plan_crystal_stop";
				GameObject val3 = PrefabManager.Instance.CreateClonedPrefab("PlanCrystalStartEffect", "vfx_blocked");
				val3.AddComponent<StartPlanCrystalStatusEffect>();
				EffectList val4 = new EffectList();
				val4.m_effectPrefabs = (EffectData[])(object)new EffectData[1]
				{
					new EffectData
					{
						m_enabled = true,
						m_prefab = val3,
						m_attach = true
					}
				};
				val2.m_startEffects = val4;
				GameObject val5 = PrefabManager.Instance.CreateClonedPrefab("PlanCrystalStopEffect", "vfx_blocked");
				val5.AddComponent<StopPlanCrystalStatusEffect>();
				val4 = new EffectList();
				val4.m_effectPrefabs = (EffectData[])(object)new EffectData[1]
				{
					new EffectData
					{
						m_enabled = true,
						m_prefab = val5,
						m_attach = true
					}
				};
				val2.m_stopEffects = val4;
				shared.m_equipStatusEffect = val2;
				shared.m_itemType = (ItemType)18;
				shared.m_maxStackSize = 1;
				shared.m_centerCamera = true;
				shared.m_maxQuality = 1;
				ItemManager.Instance.AddItem(PlanCrystalItem);
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"Error caught while creating the PlanCrytal item: {arg}");
			}
			finally
			{
				PrefabManager.OnVanillaPrefabsAvailable -= CreatePlanCrystalItem;
			}
		}

		private static void FixShader()
		{
			ShaderHelper.UpdateTextures(PlanCrystalItem.ItemDrop.m_itemData.m_dropPrefab, ShaderHelper.ShaderState.Supported);
		}
	}
	public class StartPlanCrystalStatusEffect : MonoBehaviour
	{
		public void Awake()
		{
			if (((Component)this).gameObject.GetComponent<ZNetView>().IsOwner())
			{
				PlanCrystalPrefab.ShowRealTextures = true;
				PlanManager.UpdateAllPlanPieceTextures();
			}
		}
	}
	public class StopPlanCrystalStatusEffect : MonoBehaviour
	{
		public void Awake()
		{
			if (((Component)this).gameObject.GetComponent<ZNetView>().IsOwner())
			{
				PlanCrystalPrefab.ShowRealTextures = false;
				PlanManager.UpdateAllPlanPieceTextures();
			}
		}
	}
	internal static class PlanManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_Start <>9__0_0;

			internal void <Init>b__0_0(orig_Start orig, DungeonDB self)
			{
				orig.Invoke(self);
				PlanDB.Instance.ScanPieceTables();
			}
		}

		internal static void Init()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			Logger.LogInfo((object)"Initializing PlanManager");
			PlanBlacklist.Init();
			PlanCommands.Init();
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				hook_Start val = delegate(orig_Start orig, DungeonDB self)
				{
					orig.Invoke(self);
					PlanDB.Instance.ScanPieceTables();
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			DungeonDB.Start += (hook_Start)obj;
			Player.AddKnownPiece += new hook_AddKnownPiece(Player_AddKnownPiece);
			Player.HaveRequirements_Piece_RequirementMode += new hook_HaveRequirements_Piece_RequirementMode(Player_HaveRequirements);
			Player.SetupPlacementGhost += new hook_SetupPlacementGhost(Player_SetupPlacementGhost);
			Player.CheckCanRemovePiece += new hook_CheckCanRemovePiece(Player_CheckCanRemovePiece);
			WearNTear.Highlight += new hook_Highlight(WearNTear_Highlight);
			WearNTear.Destroy += new hook_Destroy(WearNTear_Destroy);
		}

		public static void UpdateKnownRecipes()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			Logger.LogDebug((object)"Updating known Recipes");
			foreach (PlanPiecePrefab planPiecePrefab in PlanDB.Instance.GetPlanPiecePrefabs())
			{
				if (PlanBlacklist.Contains(planPiecePrefab) || (!Config.ShowAllPieces.Value && !PlayerKnowsPiece(localPlayer, planPiecePrefab.OriginalPiece)))
				{
					if (localPlayer.m_knownRecipes.Contains(((CustomPiece)planPiecePrefab).Piece.m_name))
					{
						localPlayer.m_knownRecipes.Remove(((CustomPiece)planPiecePrefab).Piece.m_name);
						Logger.LogDebug((object)("Removing planned piece from m_knownRecipes: " + ((CustomPiece)planPiecePrefab).Piece.m_name));
					}
				}
				else if (!localPlayer.m_knownRecipes.Contains(((CustomPiece)planPiecePrefab).Piece.m_name))
				{
					localPlayer.m_knownRecipes.Add(((CustomPiece)planPiecePrefab).Piece.m_name);
					Logger.LogDebug((object)("Adding planned piece to m_knownRecipes: " + ((CustomPiece)planPiecePrefab).Piece.m_name));
				}
			}
			PieceManager.Instance.GetPieceTable("_PlanHammerPieceTable").UpdateAvailable(localPlayer.m_knownRecipes, localPlayer, true, false);
		}

		public static void UpdateAllPlanPieceTextures()
		{
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer) && Object.op_Implicit((Object)(object)localPlayer.m_placementGhost) && (((Object)localPlayer.m_placementGhost).name.StartsWith("piece_blueprint") || ((Object)localPlayer.m_placementGhost).name.Split(new char[1] { '(' })[0].EndsWith("_planned")))
			{
				if (PlanCrystalPrefab.ShowRealTextures || !Config.ConfigTransparentGhostPlacement.Value)
				{
					ShaderHelper.UpdateTextures(localPlayer.m_placementGhost, ShaderHelper.ShaderState.Skuld);
				}
				else
				{
					ShaderHelper.UpdateTextures(localPlayer.m_placementGhost, ShaderHelper.ShaderState.Supported);
				}
			}
			PlanPiece[] array = Object.FindObjectsOfType<PlanPiece>();
			foreach (PlanPiece planPiece in array)
			{
				planPiece.UpdateTextures();
			}
		}

		public static void UpdateAllPlanTotems()
		{
			KitbashObject planTotemKitbash = PlanTotemPrefab.PlanTotemKitbash;
			PlanTotemPrefab.UpdateGlowColor((planTotemKitbash != null) ? planTotemKitbash.Prefab : null);
			foreach (PlanTotem allPlanTotem in PlanTotem.m_allPlanTotems)
			{
				PlanTotemPrefab.UpdateGlowColor(((Component)allPlanTotem).gameObject);
			}
		}

		private static void Player_AddKnownPiece(orig_AddKnownPiece orig, Player self, Piece piece)
		{
			if (((Object)piece).name.EndsWith("_planned"))
			{
				Player.m_localPlayer.m_knownRecipes.Add(piece.m_name);
			}
			else
			{
				orig.Invoke(self, piece);
			}
		}

		private static bool PlayerKnowsPiece(Player player, Piece originalPiece)
		{
			if (!PlanDB.Instance.FindOriginalByPieceName(originalPiece.m_name, out var originalPieces))
			{
				return player.HaveRequirements(originalPiece, (RequirementMode)1);
			}
			foreach (Piece item in originalPieces)
			{
				if (player.HaveRequirements(item, (RequirementMode)1))
				{
					return true;
				}
			}
			return false;
		}

		private static bool Player_HaveRequirements(orig_HaveRequirements_Piece_RequirementMode orig, Player self, Piece piece, RequirementMode mode)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (Object.op_Implicit((Object)(object)piece) && PlanDB.Instance.FindOriginalByPrefabName(((Object)((Component)piece).gameObject).name, out var originalPiece))
				{
					if (PlanBlacklist.Contains(originalPiece))
					{
						return false;
					}
					if (Config.ShowAllPieces.Value)
					{
						return true;
					}
					return self.HaveRequirements(originalPiece, (RequirementMode)1);
				}
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"Error while executing Player.HaveRequirements({piece},{mode}): {arg}");
			}
			return orig.Invoke(self, piece, mode);
		}

		private static void Player_SetupPlacementGhost(orig_SetupPlacementGhost orig, Player self)
		{
			try
			{
				PlanPiece.m_forceDisableInit = true;
				orig.Invoke(self);
				if (Object.op_Implicit((Object)(object)self.m_placementGhost))
				{
					if (PlanCrystalPrefab.ShowRealTextures)
					{
						ShaderHelper.UpdateTextures(self.m_placementGhost, ShaderHelper.ShaderState.Skuld);
					}
					else if (Config.ConfigTransparentGhostPlacement.Value && (((Object)self.m_placementGhost).name.StartsWith("piece_blueprint") || ((Object)self.m_placementGhost).name.Split(new char[1] { '(' })[0].EndsWith("_planned")))
					{
						ShaderHelper.UpdateTextures(self.m_placementGhost, ShaderHelper.ShaderState.Supported);
					}
				}
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"Exception caught while executing Player.SetupPlacementGhost(): {arg}");
			}
			finally
			{
				PlanPiece.m_forceDisableInit = false;
			}
		}

		private static bool Player_CheckCanRemovePiece(orig_CheckCanRemovePiece orig, Player self, Piece piece)
		{
			bool flag = ((Humanoid)self).m_visEquipment.m_rightItem.Equals("PlanHammer");
			PlanPiece planPiece = default(PlanPiece);
			bool flag2 = ((Component)piece).TryGetComponent<PlanPiece>(ref planPiece);
			if (flag)
			{
				return flag2;
			}
			if (flag2)
			{
				return false;
			}
			return orig.Invoke(self, piece);
		}

		private static void WearNTear_Highlight(orig_Highlight orig, WearNTear self)
		{
			PlanPiece planPiece = default(PlanPiece);
			if (!PlanCrystalPrefab.ShowRealTextures && ((Component)self).TryGetComponent<PlanPiece>(ref planPiece))
			{
				planPiece.Highlight();
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private static void WearNTear_Destroy(orig_Destroy orig, WearNTear wearNTear, HitData hitData, bool blockDrop)
		{
			if (Object.op_Implicit((Object)(object)wearNTear.m_nview) && wearNTear.m_nview.IsOwner() && (hitData != null || wearNTear.m_support <= 0f) && PlanDB.Instance.FindPlanByPrefabName(((Object)wearNTear).name, out var planPiecePrefab))
			{
				foreach (PlanTotem allPlanTotem in PlanTotem.m_allPlanTotems)
				{
					if (allPlanTotem.GetEnabled())
					{
						GameObject gameObject = ((Component)wearNTear).gameObject;
						if (allPlanTotem.InRange(gameObject))
						{
							allPlanTotem.Replace(gameObject, planPiecePrefab);
							break;
						}
					}
				}
			}
			orig.Invoke(wearNTear, hitData, blockDrop);
		}
	}
	public class PlanPiece : MonoBehaviour, Interactable, Hoverable
	{
		public interface IInventory
		{
			int CountItems(string resourceName);

			void RemoveItem(string resourceName, int amount);

			bool HaveItem(string resourceName);
		}

		internal class StandardInventory : IInventory
		{
			private Inventory inventory;

			public StandardInventory(Inventory inventory)
			{
				this.inventory = inventory;
			}

			public int CountItems(string resourceName)
			{
				return inventory.CountItems(resourceName, -1, true);
			}

			public bool HaveItem(string resourceName)
			{
				return inventory.HaveItem(resourceName, true);
			}

			public void RemoveItem(string resourceName, int amount)
			{
				inventory.RemoveItem(resourceName, amount, -1, true);
			}
		}

		public const string zdoPlanResource = "PlanResource";

		internal static readonly List<PlanPiece> m_planPieces = new List<PlanPiece>();

		private Piece m_piece;

		private ZNetView m_nView;

		internal WearNTear m_wearNTear;

		public Piece originalPiece;

		public static bool m_forceDisableInit;

		private bool hasSupport;

		private static readonly List<Type> typesToDestroyInChildren = new List<Type>
		{
			typeof(Joint),
			typeof(Rigidbody),
			typeof(TerrainModifier),
			typeof(GuidePoint),
			typeof(Light),
			typeof(LightLod),
			typeof(Interactable),
			typeof(Hoverable)
		};

		public static int m_planLayer = LayerMask.NameToLayer("piece_nonsolid");

		public static int m_placeRayMask = LayerMask.GetMask(new string[7] { "Default", "static_solid", "Default_small", "piece", "piece_nonsolid", "terrain", "vehicle" });

		private float m_lastLookedTime = -9999f;

		private float m_lastUseTime = -9999f;

		private readonly float m_holdRepeatInterval = 1f;

		private float m_minSupport;

		internal float m_maxSupport;

		public void Awake()
		{
			if (m_forceDisableInit)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			if (!Object.op_Implicit((Object)(object)originalPiece))
			{
				InvalidPlanPiece();
				return;
			}
			WearNTear val = default(WearNTear);
			if (((Component)originalPiece).TryGetComponent<WearNTear>(ref val))
			{
				m_minSupport = val.GetMinSupport();
				m_maxSupport = val.GetMaxSupport();
			}
			m_planPieces.Add(this);
			m_wearNTear = ((Component)this).GetComponent<WearNTear>();
			m_nView = ((Component)this).GetComponent<ZNetView>();
			m_piece = ((Component)this).GetComponent<Piece>();
			DisablePiece(((Component)this).gameObject);
			WearNTear wearNTear = m_wearNTear;
			wearNTear.m_onDestroyed = (Action)Delegate.Combine(wearNTear.m_onDestroyed, new Action(OnDestroyed));
			if (m_nView.IsOwner())
			{
				m_nView.GetZDO().Set("support", 0f);
			}
			m_nView.Register<bool>("Refund", (Action<long, bool>)RPC_Refund);
			m_nView.Register<string, int>("AddResource", (Action<long, string, int>)RPC_AddResource);
			m_nView.Register<long>("SpawnPieceAndDestroy", (Action<long, long>)RPC_SpawnPieceAndDestroy);
		}

		private void OnDestroyed()
		{
			if (m_nView.IsOwner())
			{
				Refund(all: true);
			}
		}

		public void OnDestroy()
		{
			m_planPieces.Remove(this);
		}

		private void RPC_Refund(long sender, bool all)
		{
			if (m_nView.IsOwner())
			{
				Refund(all);
			}
		}

		internal bool CalculateSupported()
		{
			return m_nView.GetZDO().GetFloat("support", 0f) >= m_minSupport;
		}

		public void Update()
		{
			if (m_nView.IsValid())
			{
				bool flag = CalculateSupported();
				if (flag != hasSupport)
				{
					hasSupport = flag;
					UpdateTextures();
				}
			}
		}

		internal void Highlight()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			m_wearNTear.Highlight(Config.UnsupportedColorConfig.Value, 0.6f);
		}

		public void DisablePiece(GameObject gameObject)
		{
			foreach (Type typesToDestroyInChild in typesToDestroyInChildren)
			{
				Component[] componentsInChildren = gameObject.GetComponentsInChildren(typesToDestroyInChild);
				foreach (Component val in componentsInChildren)
				{
					if (!(((object)val).GetType() == typeof(PlanPiece)))
					{
						Object.Destroy((Object)(object)val);
					}
				}
			}
			Collider[] componentsInChildren2 = gameObject.GetComponentsInChildren<Collider>();
			Collider[] array = componentsInChildren2;
			foreach (Collider val2 in array)
			{
				if (((1 << ((Component)val2).gameObject.layer) & m_placeRayMask) == 0)
				{
					((Component)val2).gameObject.layer = m_planLayer;
				}
			}
			Transform[] componentsInChildren3 = gameObject.GetComponentsInChildren<Transform>();
			int planLayer = m_planLayer;
			Transform[] array2 = componentsInChildren3;
			for (int k = 0; k < array2.Length; k++)
			{
				((Component)array2[k]).gameObject.layer = planLayer;
			}
			AudioSource[] componentsInChildren4 = gameObject.GetComponentsInChildren<AudioSource>();
			for (int l = 0; l < componentsInChildren4.Length; l++)
			{
				((Behaviour)componentsInChildren4[l]).enabled = false;
			}
			ZSFX[] componentsInChildren5 = gameObject.GetComponentsInChildren<ZSFX>();
			for (int m = 0; m < componentsInChildren5.Length; m++)
			{
				((Behaviour)componentsInChildren5[m]).enabled = false;
			}
			Windmill componentInChildren = gameObject.GetComponentInChildren<Windmill>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				((Behaviour)componentInChildren).enabled = false;
			}
			ParticleSystem[] componentsInChildren6 = gameObject.GetComponentsInChildren<ParticleSystem>();
			for (int n = 0; n < componentsInChildren6.Length; n++)
			{
				((Component)componentsInChildren6[n]).gameObject.SetActive(false);
			}
			UpdateTextures();
		}

		internal bool HasRequiredCraftingStationInRange()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)originalPiece.m_craftingStation))
			{
				return Object.op_Implicit((Object)(object)CraftingStation.HaveBuildStationInRange(originalPiece.m_craftingStation.m_name, ((Component)this).transform.position));
			}
			return true;
		}

		private void InvalidPlanPiece()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogWarning((object)("Invalid PlanPiece , destroying self: " + ((Object)this).name + " @ " + ((object)((Component)this).gameObject.transform.position/*cast due to .constrained prefix*/).ToString()));
			ZNetScene.instance.Destroy(((Component)this).gameObject);
		}

		internal void UpdateTextures()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			bool flag = Selection.Instance.IsHighlighted(m_piece);
			if (flag)
			{
				Selection.Instance.Unhighlight(m_piece.GetZDOID().Value, ((Component)this).gameObject);
			}
			ShaderHelper.UpdateTextures(((Component)this).gameObject, GetShaderState());
			if (flag)
			{
				Selection.Instance.Highlight(m_piece.GetZDOID().Value, ((Component)this).gameObject);
			}
		}

		private ShaderHelper.ShaderState GetShaderState()
		{
			if (PlanCrystalPrefab.ShowRealTextures)
			{
				return ShaderHelper.ShaderState.Skuld;
			}
			if (HasSupport())
			{
				return ShaderHelper.ShaderState.Supported;
			}
			return ShaderHelper.ShaderState.Floating;
		}

		public string GetHoverName()
		{
			return "Planned " + originalPiece.m_name;
		}

		public string GetHoverText()
		{
			if (Time.time - m_lastLookedTime > 0.2f)
			{
				m_lastLookedTime = Time.time;
				SetupPieceInfo(originalPiece);
			}
			Hud.instance.m_buildHud.SetActive(true);
			if (!HasAllResources())
			{
				return Localization.instance.Localize("[<color=yellow>$KEY_Use</color>] [<color=yellow>1-8</color>] $plan_piece_hover_add_material\n[$plan_piece_hover_hold <color=yellow>$KEY_Use</color>] $plan_piece_hover_add_all_materials");
			}
			return Localization.instance.Localize("[<color=yellow>$KEY_Use</color>] $plan_piece_hover_build");
		}

		public float GetHoverOffset()
		{
			return 0f;
		}

		private void SetupPieceInfo(Piece piece)
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			Hud.instance.m_buildSelection.text = Localization.instance.Localize(piece.m_name);
			Hud.instance.m_pieceDescription.text = Localization.instance.Localize(piece.m_description);
			((Behaviour)Hud.instance.m_buildIcon).enabled = true;
			Hud.instance.m_buildIcon.sprite = piece.m_icon;
			GameObject[] requirementItems = Hud.instance.m_requirementItems;
			for (int i = 0; i < requirementItems.Length; i++)
			{
				if (i < piece.m_resources.Length)
				{
					Requirement req = piece.m_resources[i];
					requirementItems[i].SetActive(true);
					SetupRequirement(requirementItems[i].transform, req, GetResourceCount(GetResourceName(req)));
				}
				else
				{
					requirementItems[i].SetActive(false);
				}
			}
			if (Object.op_Implicit((Object)(object)piece.m_craftingStation))
			{
				CraftingStation val = CraftingStation.HaveBuildStationInRange(piece.m_craftingStation.m_name, ((Component)localPlayer).transform.position);
				GameObject val2 = requirementItems[piece.m_resources.Length];
				val2.SetActive(true);
				Image component = ((Component)val2.transform.Find("res_icon")).GetComponent<Image>();
				TMP_Text component2 = ((Component)val2.transform.Find("res_name")).GetComponent<TMP_Text>();
				TMP_Text component3 = ((Component)val2.transform.Find("res_amount")).GetComponent<TMP_Text>();
				UITooltip component4 = val2.GetComponent<UITooltip>();
				component.sprite = piece.m_craftingStation.m_icon;
				component2.text = Localization.instance.Localize(piece.m_craftingStation.m_name);
				component4.m_text = piece.m_craftingStation.m_name;
				if ((Object)(object)val != (Object)null)
				{
					val.ShowAreaMarker();
					((Graphic)component).color = Color.white;
					component3.text = "";
					((Graphic)component3).color = Color.white;
				}
				else
				{
					((Graphic)component).color = Color.gray;
					component3.text = "None";
					((Graphic)component3).color = ((Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : Color.white);
				}
			}
		}

		public bool SetupRequirement(Transform elementRoot, Requirement req, int currentAmount)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			Image component = ((Component)((Component)elementRoot).transform.Find("res_icon")).GetComponent<Image>();
			TMP_Text component2 = ((Component)((Component)elementRoot).transform.Find("res_name")).GetComponent<TMP_Text>();
			TMP_Text component3 = ((Component)((Component)elementRoot).transform.Find("res_amount")).GetComponent<TMP_Text>();
			UITooltip component4 = ((Component)elementRoot).GetComponent<UITooltip>();
			if ((Object)(object)req.m_resItem != (Object)null)
			{
				((Component)component).gameObject.SetActive(true);
				((Component)component2).gameObject.SetActive(true);
				((Component)component3).gameObject.SetActive(true);
				component.sprite = req.m_resItem.m_itemData.GetIcon();
				((Graphic)component).color = Color.white;
				component4.m_text = Localization.instance.Localize(req.m_resItem.m_itemData.m_shared.m_name);
				component2.text = Localization.instance.Localize(req.m_resItem.m_itemData.m_shared.m_name);
				int amount = req.GetAmount(0);
				string resourceName = GetResourceName(req);
				bool flag = GetInventories((Humanoid)(object)Player.m_localPlayer).Exists((IInventory inv) => inv.HaveItem(resourceName));
				int num = amount - currentAmount;
				component3.text = currentAmount + "/" + amount;
				if (num > 0 && !flag)
				{
					((Graphic)component).color = Color.gray;
					((Graphic)component3).color = ((Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : Color.white);
				}
				else
				{
					((Graphic)component).color = Color.white;
					((Graphic)component3).color = Color.white;
				}
			}
			return true;
		}

		public List<IInventory> GetInventories(Humanoid player)
		{
			return new List<IInventory>
			{
				new StandardInventory(player.GetInventory())
			};
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			Player val = (Player)(object)((user is Player) ? user : null);
			if (val == null)
			{
				return false;
			}
			if (val.m_noPlacementCost)
			{
				Build(val.GetPlayerID());
				return false;
			}
			if (hold)
			{
				if (Time.time - m_lastUseTime < m_holdRepeatInterval)
				{
					return false;
				}
				m_lastUseTime = Time.time;
				bool flag = false;
				{
					foreach (IInventory inventory in GetInventories(user))
					{
						flag |= AddAllMaterials(inventory);
					}
					return flag;
				}
			}
			List<IInventory> inventories = GetInventories(user);
			Requirement[] resources = originalPiece.m_resources;
			foreach (Requirement val2 in resources)
			{
				string resourceName = GetResourceName(val2);
				int resourceCount = GetResourceCount(resourceName);
				if (resourceCount >= val2.m_amount)
				{
					continue;
				}
				foreach (IInventory item in inventories)
				{
					if (item.HaveItem(resourceName))
					{
						m_nView.InvokeRPC("AddResource", new object[2] { resourceName, 1 });
						item.RemoveItem(resourceName, 1);
						return true;
					}
				}
			}
			if (!HasAllResources())
			{
				((Character)user).Message((MessageType)2, "$msg_missingrequirement", 0, (Sprite)null, false);
				return false;
			}
			if (user.GetInventory().GetItem("$item_plan_hammer", -1, false) == null)
			{
				((Character)user).Message((MessageType)2, "$message_plan_piece_need_hammer", 0, (Sprite)null, false);
				return false;
			}
			if (Object.op_Implicit((Object)(object)originalPiece.m_craftingStation))
			{
				CraftingStation val3 = CraftingStation.HaveBuildStationInRange(originalPiece.m_craftingStation.m_name, ((Component)user).transform.position);
				if (!Object.op_Implicit((Object)(object)val3))
				{
					((Character)user).Message((MessageType)2, "$msg_missingstation", 0, (Sprite)null, false);
					return false;
				}
			}
			if (!HasSupport())
			{
				((Character)user).Message((MessageType)2, "$message_plan_piece_not_enough_support", 0, (Sprite)null, false);
				return false;
			}
			Build(val.GetPlayerID());
			return false;
		}

		public bool HasSupport()
		{
			return hasSupport;
		}

		public void Build(long playerID)
		{
			m_nView.InvokeRPC("Refund", new object[1] { false });
			m_nView.InvokeRPC("SpawnPieceAndDestroy", new object[1] { playerID });
		}

		public bool AddAllMaterials(IInventory inventory)
		{
			bool result = false;
			Requirement[] resources = originalPiece.m_resources;
			foreach (Requirement req in resources)
			{
				string resourceName = GetResourceName(req);
				int remaining = GetRemaining(req);
				if (remaining > 0 && inventory.HaveItem(resourceName))
				{
					int num = Math.Min(remaining, inventory.CountItems(resourceName));
					if (num > 0)
					{
						m_nView.InvokeRPC("AddResource", new object[2] { resourceName, num });
						inventory.RemoveItem(resourceName, num);
						result = true;
					}
				}
			}
			return result;
		}

		public Dictionary<string, int> GetRemaining()
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			Requirement[] resources = originalPiece.m_resources;
			foreach (Requirement req in resources)
			{
				dictionary.Add(GetResourceName(req), GetRemaining(req));
			}
			return dictionary;
		}

		private int GetRemaining(Requirement req)
		{
			int resourceCount = GetResourceCount(req);
			return req.m_amount - resourceCount;
		}

		private int GetResourceCount(Requirement req)
		{
			return GetResourceCount(GetResourceName(req));
		}

		private static string GetResourceName(Requirement req)
		{
			return req.m_resItem.m_itemData.m_shared.m_name;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			Requirement[] resources = originalPiece.m_resources;
			foreach (Requirement val in resources)
			{
				string resourceName = GetResourceName(val);
				if (!(resourceName != item.m_shared.m_name))
				{
					int resourceCount = GetResourceCount(resourceName);
					int num = val.m_amount - resourceCount;
					if (num > 0)
					{
						m_nView.InvokeRPC("AddResource", new object[2] { resourceName, 1 });
						user.GetInventory().RemoveOneItem(item);
						return true;
					}
				}
			}
			return false;
		}

		private void Refund(bool all)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			Requirement[] resources = originalPiece.m_resources;
			foreach (Requirement val in resources)
			{
				string resourceName = GetResourceName(val);
				int num = GetResourceCount(resourceName);
				if (!all)
				{
					num -= val.m_amount;
				}
				while (num > 0)
				{
					ItemData val2 = val.m_resItem.m_itemData.Clone();
					int num2 = (val2.m_stack = Mathf.Min(num, val2.m_shared.m_maxStackSize));
					num -= num2;
					Object.Instantiate<GameObject>(((Component)val.m_resItem).gameObject, ((Component)this).transform.position + Vector3.up, Quaternion.identity).GetComponent<ItemDrop>().SetStack(num2);
				}
			}
		}

		internal void Remove()
		{
			m_wearNTear.Remove(false);
		}

		public bool HasAllResources()
		{
			Requirement[] resources = originalPiece.m_resources;
			foreach (Requirement val in resources)
			{
				string resourceName = GetResourceName(val);
				int resourceCount = GetResourceCount(resourceName);
				if (resourceCount < val.m_amount)
				{
					return false;
				}
			}
			return true;
		}

		public void RPC_AddResource(long sender, string resource, int amount)
		{
			if (m_nView.IsOwner())
			{
				AddResource(resource, amount);
			}
		}

		private void AddResource(string resource, int amount)
		{
			int resourceCount = GetResourceCount(resource);
			SetResourceCount(resource, resourceCount + amount);
		}

		private void SetResourceCount(string resource, int count)
		{
			m_nView.GetZDO().Set("PlanResource_" + resource, count);
		}

		private int GetResourceCount(string resource)
		{
			if (!m_nView.IsValid())
			{
				return 0;
			}
			return m_nView.GetZDO().GetInt("PlanResource_" + resource, 0);
		}

		private void RPC_SpawnPieceAndDestroy(long sender, long creatorID)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (m_nView.IsOwner())
			{
				GameObject val = SpawnPiece(((Component)this).gameObject, creatorID, ((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)originalPiece).gameObject, m_nView.GetZDO().GetString("AdditionalText", ""));
				ZNetScene.instance.Destroy(((Component)this).gameObject);
			}
		}

		internal static GameObject SpawnPiece(GameObject originatingObject, long creatorID, Vector3 position, Quaternion rotation, GameObject prefab, string additionalInfo)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(prefab, position, rotation);
			OnPieceReplaced(originatingObject, val);
			Player localPlayer = Player.m_localPlayer;
			if (creatorID == ((localPlayer != null) ? new long?(localPlayer.GetPlayerID()) : ((long?)null)))
			{
				CraftingStation componentInChildren = val.GetComponentInChildren<CraftingStation>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					Player.m_localPlayer.AddKnownStation(componentInChildren);
				}
				PrivateArea component = val.GetComponent<PrivateArea>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.Setup(Game.instance.GetPlayerProfile().GetName());
				}
				Piece val2 = default(Piece);
				if (val.TryGetComponent<Piece>(ref val2))
				{
					val2.m_placeEffect.Create(val.transform.position, val.transform.rotation, val.transform, 1f, -1, default(ZDOID));
				}
				Game.instance.GetPlayerProfile().IncrementStat((PlayerStatType)2, 1f, false);
			}
			WearNTear component2 = val.GetComponent<WearNTear>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				component2.OnPlaced();
			}
			TextReceiver component3 = val.GetComponent<TextReceiver>();
			if (component3 != null)
			{
				component3.SetText(additionalInfo);
			}
			ItemDrop component4 = val.GetComponent<ItemDrop>();
			if ((Object)(object)component4 != (Object)null)
			{
				component4.MakePiece(true);
			}
			val.GetComponent<Piece>().SetCreator(creatorID, PlatformUserID.None);
			return val;
		}

		internal static void OnPieceReplaced(GameObject originatingPiece, GameObject placedPiece)
		{
		}

		[HarmonyPatch(typeof(WearNTear), "Damage")]
		[HarmonyPrefix]
		private static bool WearNTear_Damage_Prefix(WearNTear __instance)
		{
			if (Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<PlanPiece>()))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(WearNTear), "GetSupport")]
		[HarmonyPrefix]
		private static bool WearNTear_GetSupport_Prefix(WearNTear __instance, ref float __result)
		{
			if (Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<PlanPiece>()))
			{
				__result = 0f;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(WearNTear), "HaveSupport")]
		[HarmonyPrefix]
		private static bool WearNTear_HaveSupport_Prefix(WearNTear __instance, ref bool __result)
		{
			if (Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<PlanPiece>()))
			{
				__result = true;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(WearNTear), "ResetHighlight")]
		[HarmonyPrefix]
		private static bool WearNTear_ResetHighlight_Prefix(WearNTear __instance)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.m_oldMaterials == null)
			{
				return true;
			}
			IEnumerable<OldMeshData> enumerable = __instance.m_oldMaterials.Where((OldMeshData mat) => Object.op_Implicit((Object)(object)mat.m_renderer));
			foreach (OldMeshData oldMaterial in enumerable)
			{
				Material[] materials = oldMaterial.m_renderer.materials;
				var enumerable2 = materials.Select((Material mat, int idx) => new
				{
					Material = mat,
					OriginalColor = oldMaterial.m_color[idx],
					OriginalEmissionColor = oldMaterial.m_emissiveColor[idx]
				});
				foreach (var item in enumerable2)
				{
					item.Material.SetColor("_EmissionColor", item.OriginalEmissionColor);
					item.Material.color = item.OriginalColor;
				}
			}
			__instance.m_oldMaterials = null;
			return true;
		}
	}
	internal class PlanPiecePrefab : CustomPiece
	{
		public const string PlannedSuffix = "_planned";

		public Piece OriginalPiece;

		public int OriginalHash;

		private static readonly List<Type> TypesToKeepInChildren = new List<Type>
		{
			typeof(ZNetView),
			typeof(WearNTear),
			typeof(Piece),
			typeof(Interactable),
			typeof(Hoverable),
			typeof(PlanPiece),
			typeof(ItemDrop)
		};

		public static int PlanLayer = LayerMask.NameToLayer("piece_nonsolid");

		public static int PlaceRayMask = LayerMask.GetMask(new string[7] { "Default", "static_solid", "Default_small", "piece", "piece_nonsolid", "terrain", "vehicle" });

		public PlanPiecePrefab(Piece piece)
			: base(((Object)((Component)piece).gameObject).name + "_planned", ((Object)((Component)piece).gameObject).name, "_PlanHammerPieceTable")
		{
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Invalid comparison between Unknown and I4
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Expected O, but got Unknown
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Expected O, but got Unknown
			OriginalPiece = piece;
			OriginalHash = StringExtensionMethods.GetStableHashCode(((Object)piece).name);
			((CustomPiece)this).Piece.m_name = Localization.instance.Localize("$item_plan_piece_name", new string[1] { OriginalPiece.m_name });
			((CustomPiece)this).Piece.m_description = Localization.instance.Localize("$item_plan_piece_description", new string[1] { OriginalPiece.m_name });
			((CustomPiece)this).Piece.m_resources = Array.Empty<Requirement>();
			((CustomPiece)this).Piece.m_craftingStation = null;
			((CustomPiece)this).Piece.m_placeEffect.m_effectPrefabs = Array.Empty<EffectData>();
			((CustomPiece)this).Piece.m_comfort = 0;
			((CustomPiece)this).Piece.m_canBeRemoved = true;
			((StaticTarget)((CustomPiece)this).Piece).m_randomTarget = false;
			((StaticTarget)((CustomPiece)this).Piece).m_primaryTarget = false;
			((CustomPiece)this).Piece.m_enabled = OriginalPiece.m_enabled;
			((CustomPiece)this).Piece.m_category = (PieceCategory)(((int)OriginalPiece.m_category != 9) ? ((int)OriginalPiece.m_category) : 0);
			((CustomPiece)this).Piece.m_groundOnly = OriginalPiece.m_groundOnly;
			((CustomPiece)this).Piece.m_groundPiece = OriginalPiece.m_groundPiece;
			((CustomPiece)this).Piece.m_icon = OriginalPiece.m_icon;
			((CustomPiece)this).Piece.m_inCeilingOnly = OriginalPiece.m_inCeilingOnly;
			((CustomPiece)this).Piece.m_isUpgrade = OriginalPiece.m_isUpgrade;
			((StaticTarget)((CustomPiece)this).Piece).m_haveCenter = ((StaticTarget)OriginalPiece).m_haveCenter;
			((CustomPiece)this).Piece.m_dlc = OriginalPiece.m_dlc;
			((CustomPiece)this).Piece.m_allowAltGroundPlacement = OriginalPiece.m_allowAltGroundPlacement;
			((CustomPiece)this).Piece.m_allowedInDungeons = OriginalPiece.m_allowedInDungeons;
			((CustomPiece)this).PieceTable = "_PlanHammerPieceTable";
			WearNTear orAddComponent = ExposedGameObjectExtension.GetOrAddComponent<WearNTear>(((CustomPiece)this).PiecePrefab);
			orAddComponent.m_noSupportWear = true;
			orAddComponent.m_noRoofWear = false;
			orAddComponent.m_autoCreateFragments = false;
			orAddComponent.m_supports = true;
			orAddComponent.m_hitEffect = new EffectList();
			orAddComponent.m_hitNoise = 0f;
			orAddComponent.m_destroyedEffect = new EffectList();
			orAddComponent.m_destroyNoise = 0f;
			PlanPiece planPiece = ((CustomPiece)this).PiecePrefab.AddComponent<PlanPiece>();
			planPiece.originalPiece = OriginalPiece;
			DisablePiece(((CustomPiece)this).PiecePrefab);
		}

		public void DisablePiece(GameObject gameObject)
		{
			gameObject.layer = PlanLayer;
			EffectArea[] componentsInChildren = gameObject.GetComponentsInChildren<EffectArea>();
			foreach (EffectArea val in componentsInChildren)
			{
				Object.DestroyImmediate((Object)(object)((Component)val).gameObject);
			}
			MonoBehaviour[] componentsInChildren2 = gameObject.GetComponentsInChildren<MonoBehaviour>();
			foreach (MonoBehaviour component in componentsInChildren2)
			{
				if (!TypesToKeepInChildren.Any((Type x) => ReflectionHelper.IsSameOrSubclass(x, ((object)component).GetType())))
				{
					Object.DestroyImmediate((Object)(object)component);
				}
			}
		}
	}
	internal class PlanTotem : Container
	{
		public static readonly List<PlanTotem> m_allPlanTotems;

		private CircleProjector m_areaMarker;

		private GameObject m_activeMarker;

		private MeshRenderer m_model;

		private int m_supportedPieces;

		internal static GameObject m_connectionPrefab;

		private Bounds m_chestBounds;

		private List<KeyValuePair<string, int>> m_sortedRequired;

		private readonly List<PlanPiece> m_connectedPieces = new List<PlanPiece>();

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

		private readonly HashSet<string> m_missingCraftingStations = new HashSet<string>();

		static PlanTotem()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			m_allPlanTotems = new List<PlanTotem>();
			Container.GetHoverText += new hook_GetHoverText(OnContainerHoverText);
			Container.Interact += new hook_Interact(OnContainerInteract);
		}

		private static bool OnContainerInteract(orig_Interact orig, Container self, Humanoid character, bool hold, bool alt)
		{
			PlanTotem planTotem = self as PlanTotem;
			if (Object.op_Implicit((Object)(object)planTotem) && !hold && ZInput.GetButton("Crouch") && !self.IsInUse())
			{
				((Container)planTotem).m_nview.InvokeRPC("ToggleEnabled", Array.Empty<object>());
				return true;
			}
			return orig.Invoke(self, character, hold, alt);
		}

		private static string OnContainerHoverText(orig_GetHoverText orig, Container self)
		{
			PlanTotem planTotem = self as PlanTotem;
			if (Object.op_Implicit((Object)(object)planTotem))
			{
				return planTotem.GetHoverText();
			}
			return orig.Invoke(self);
		}

		public void Awake()
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			base.m_width = 7;
			base.m_height = 4;
			((Container)this).Awake();
			((MonoBehaviour)this).StartCoroutine((IEnumerator)UpdatePlanTotem());
			m_areaMarker = ((Component)this).GetComponentInChildren<CircleProjector>(true);
			m_activeMarker = ((Component)((Component)this).transform.Find("new/pivot")).gameObject;
			m_model = ((Component)((Component)this).transform.Find("new/totem")).GetComponent<MeshRenderer>();
			m_areaMarker.m_radius = Config.RadiusConfig.Value;
			m_chestBounds = ((Collider)((Component)((Component)this).transform.Find("new/chest/privatechest")).GetComponent<BoxCollider>()).bounds;
			m_allPlanTotems.Add(this);
			if (Object.op_Implicit((Object)(object)base.m_nview))
			{
				base.m_nview.Register("ToggleEnabled", (Action<long>)RPC_ToggleEnabled);
			}
			HideMarker();
		}

		internal void Replace(GameObject gameObject, PlanPiecePrefab planPrefab)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = gameObject.transform;
			TextReceiver component = gameObject.GetComponent<TextReceiver>();
			string additionalInfo = ((component != null) ? component.GetText() : null);
			GameObject val = PlanPiece.SpawnPiece(gameObject, base.m_piece.m_creator, transform.position, transform.rotation, ((CustomPiece)planPrefab).PiecePrefab, additionalInfo);
			TriggerConnection(val.transform.position);
		}

		public void OnDestroy()
		{
			m_allPlanTotems.Remove(this);
		}

		public bool InRange(GameObject go)
		{
			return GetDistanceTo(go) <= Config.RadiusConfig.Value;
		}

		private float GetDistanceTo(GameObject go)
		{
			//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_000e: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			Vector3 center = GetCenter(go);
			return Vector2.Distance(new Vector2(((Component)this).transform.position.x, ((Component)this).transform.position.z), new Vector2(center.x, center.z));
		}

		private List<PlanPiece> FindPlanPiecesInRange()
		{
			Dictionary<PlanPiece, float> dictionary = new Dictionary<PlanPiece, float>();
			foreach (Piece s_allPiece in Piece.s_allPieces)
			{
				try
				{
					float distanceTo = GetDistanceTo(((Component)s_allPiece).gameObject);
					if (distanceTo <= Config.RadiusConfig.Value)
					{
						PlanPiece component = ((Component)s_allPiece).GetComponent<PlanPiece>();
						if (Object.op_Implicit((Object)(object)component))
						{
							dictionary.Add(component, distanceTo);
						}
					}
				}
				catch (Exception arg)
				{
					Logger.LogWarning((object)$"Exception caught while collecting plan piece {s_allPiece}: {arg}");
				}
			}
			return (from pair in dictionary.AsEnumerable()
				orderby pair.Key.m_maxSupport descending, ((Component)pair.Key).transform.position.y, pair.Value
				select pair.Key).ToList();
		}

		public IEnumerator<YieldInstruction> UpdatePlanTotem()
		{
			if (!Object.op_Implicit((Object)(object)base.m_nview) || !base.m_nview.IsValid())
			{
				yield break;
			}
			while (true)
			{
				yield return (YieldInstruction)new WaitForSeconds(3f);
				if (!GetEnabled())
				{
					continue;
				}
				m_remainingRequirements.Clear();
				m_supportedPieces = 0;
				m_connectedPieces.Clear();
				m_missingCraftingStations.Clear();
				PlanPiece.IInventory inventory = new PlanPiece.StandardInventory(base.m_inventory);
				List<PlanPiece> list = FindPlanPiecesInRange();
				foreach (PlanPiece item in list)
				{
					if (item.HasSupport())
					{
						m_supportedPieces++;
					}
					if (base.m_nview.IsOwner() && item.HasSupport())
					{
						if (base.m_inventory.m_inventory.Count != 0)
						{
							item.AddAllMaterials(inventory);
						}
						if (item.HasAllResources())
						{
							if (item.HasRequiredCraftingStationInRange())
							{
								if (Config.ShowParticleEffects.Value)
								{
									TriggerConnection(GetCenter(((Component)item).gameObject));
								}
								item.Build(base.m_piece.m_creator);
								continue;
							}
							m_missingCraftingStations.Add(item.originalPiece.m_craftingStation.m_name);
						}
					}
					m_connectedPieces.Add(item);
					Dictionary<string, int> remaining = item.GetRemaining();
					foreach (string key in remaining.Keys)
					{
						int num = remaining[key];
						if (m_remainingRequirements.TryGetValue(key, out var value))
						{
							num += value;
						}
						m_remainingRequirements[key] = num;
					}
				}
				m_sortedRequired = (from pair in m_remainingRequirements.Select(delegate(KeyValuePair<string, int> pair)
					{
						int num2 = pair.Value;
						if (pair.Value > 0)
						{
							num2 -= base.m_inventory.CountItems(pair.Key, -1, true);
						}
						return new KeyValuePair<string, int>(pair.Key, num2);
					})
					where pair.Value > 0
					orderby pair.Value descending
					select pair).ToList();
				bool active = m_connectedPieces.Count > 0;
				SetActive(active);
			}
		}

		private void SetActive(bool active)
		{
			m_activeMarker.SetActive(active);
			Material[] materials = ((Renderer)m_model).materials;
			Material[] array = materials;
			foreach (Material val in array)
			{
				if (active)
				{
					val.EnableKeyword("_EMISSION");
				}
				else
				{
					val.DisableKeyword("_EMISSION");
				}
			}
		}

		internal void RPC_ToggleEnabled(long sender)
		{
			if (base.m_nview.IsOwner())
			{
				SetEnabled(!GetEnabled());
			}
		}

		private void SetEnabled(bool enabled)
		{
			if (Object.op_Implicit((Object)(object)base.m_nview) && base.m_nview.IsValid())
			{
				base.m_nview.GetZDO().Set("enabled", enabled);
			}
			SetActive(enabled);
		}

		internal bool GetEnabled()
		{
			if (Object.op_Implicit((Object)(object)base.m_nview) && base.m_nview.IsValid())
			{
				return base.m_nview.GetZDO().GetBool("enabled", true);
			}
			return false;
		}

		public void ShowAreaMarker()
		{
			if (Object.op_Implicit((Object)(object)m_areaMarker))
			{
				((Component)m_areaMarker).gameObject.SetActive(true);
				((MonoBehaviour)this).CancelInvoke("HideMarker");
				((MonoBehaviour)this).Invoke("HideMarker", 0.5f);
			}
		}

		public void HideMarker()
		{
			((Component)m_areaMarker).gameObject.SetActive(false);
		}

		public string GetHoverText()
		{
			ShowAreaMarker();
			bool enabled = GetEnabled();
			StringBuilder stringBuilder = new StringBuilder("$piece_plan_totem " + (enabled ? "" : "(<color=red>$piece_plan_totem_disabled</color>)") + "\n[<color=yellow>$KEY_Use</color>] $piece_container_open\n[<color=yellow>$KEY_Crouch + $KEY_Use</color>] " + (enabled ? "$piece_plan_totem_disable" : "$piece_plan_totem_enable") + "\n\n");
			if (m_missingCraftingStations.Count > 0)
			{
				stringBuilder.Append("$piece_plan_totem_missing \n");
				foreach (string missingCraftingStation in m_missingCraftingStations)
				{
					stringBuilder.Append("<color=red>" + missingCraftingStation + "</color>\n");
				}
			}
			stringBuilder.Append(Localization.instance.Localize("$piece_plan_totem_connected \n", new string[2]
			{
				m_connectedPieces.Count.ToString(),
				m_supportedPieces.ToString()
			}));
			if (m_remainingRequirements.Count > 0)
			{
				stringBuilder.Append("$piece_plan_totem_required\n");
				foreach (KeyValuePair<string, int> item in m_sortedRequired)
				{
					stringBuilder.Append($" <color=yellow>{item.Value}</color> {item.Key}\n");
				}
			}
			return Localization.instance.Localize(stringBuilder.ToString());
		}

		public Vector3 GetCenter(GameObject target)
		{
			//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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Collider[] componentsInChildren = target.GetComponentsInChildren<Collider>();
			Vector3 val = target.transform.position;
			Collider[] array = componentsInChildren;
			Collider[] array2 = array;
			foreach (Collider val2 in array2)
			{
				Vector3 val3 = val;
				Bounds bounds = val2.bounds;
				val = (val3 + ((Bounds)(ref bounds)).center) / 2f;
			}
			return val;
		}

		public void TriggerConnection(Vector3 targetPos)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			Vector3 center = ((Bounds)(ref m_chestBounds)).center;
			GameObject val = Object.Instantiate<GameObject>(m_connectionPrefab, center, Quaternion.identity);
			TimedDestruction val2 = val.AddComponent<TimedDestruction>();
			Vector3 val3 = targetPos - center;
			val2.Trigger(((Vector3)(ref val3)).magnitude);
			val.transform.position = center;
			val.transform.rotation = Quaternion.LookRotation(((Vector3)(ref val3)).normalized);
			val.transform.localScale = new Vector3(1f, 1f, ((Vector3)(ref val3)).magnitude);
		}
	}
	internal class PlanTotemPrefab
	{
		public const string PlanTotemPieceName = "piece_plan_totem";

		public static KitbashObject PlanTotemKitbash;

		public static void UpdateGlowColor(GameObject prefab)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)prefab))
			{
				MeshRenderer component = ((Component)prefab.transform.Find("new/totem")).GetComponent<MeshRenderer>();
				((Renderer)component).materials.First((Material material) => ((Object)material).name.StartsWith("Guardstone_OdenGlow_mat")).SetColor("_EmissionColor", Config.GlowColorConfig.Value);
			}
		}

		public static void Create(AssetBundle planbuildBundle)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			//IL_0178: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Expected O, but got Unknown
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Expected O, but got Unknown
			PlanTotemKitbash = KitbashManager.Instance.AddKitbash(planbuildBundle.LoadAsset<GameObject>("piece_plan_totem"), new KitbashConfig
			{
				FixReferences = true,
				KitbashSources = new List<KitbashSourceConfig>
				{
					new KitbashSourceConfig
					{
						Name = "totem",
						TargetParentPath = "new",
						SourcePrefab = "guard_stone",
						SourcePath = "new/default",
						Scale = Vector3.one * 0.6f
					},
					new KitbashSourceConfig
					{
						Name = "chest",
						TargetParentPath = "new",
						SourcePrefab = "piece_chest_private",
						SourcePath = "New",
						Position = new Vector3(0f, 0f, 0.591f),
						Scale = Vector3.one * 0.9f,
						Rotation = Quaternion.Euler(180f, 180f, 180f)
					},
					new KitbashSourceConfig
					{
						Name = "hammer",
						TargetParentPath = "new/pivot",
						SourcePrefab = "Hammer",
						SourcePath = "attach/hammer",
						Position = new Vector3(0.07f, 1.9f, 0f),
						Rotation = Quaternion.Euler(0f, 0f, 20f),
						Scale = Vector3.one * 0.3f
					}
				}
			});
			KitbashObject planTotemKitbash = PlanTotemKitbash;
			planTotemKitbash.OnKitbashApplied = (Action)Delegate.Combine(planTotemKitbash.OnKitbashApplied, (Action)delegate
			{
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				GameObject connectionPrefab = PrefabManager.Instance.GetPrefab("forge_ext1").GetComponent<StationExtension>().m_connectionPrefab;
				GameObject connectionPrefab2 = PrefabManager.Instance.CreateClonedPrefab("vfx_PlanBuildConnection", connectionPrefab);
				GameObject prefab2 = PlanTotemKitbash.Prefab;
				ShaderHelper.UpdateTextures(((Component)prefab2.transform.Find("new/pivot/hammer")).gameObject, ShaderHelper.ShaderState.Supported);
				PlanTotem planTotem = prefab2.AddComponent<PlanTotem>();
				PlanTotem.m_connectionPrefab = connectionPrefab2;
				((Container)planTotem).m_name = "$piece_plan_totem_container";
				((Container)planTotem).m_open = ((Component)prefab2.transform.Find("new/chest/privatechesttop_open")).gameObject;
				((Container)planTotem).m_closed = ((Component)prefab2.transform.Find("new/chest/privatechesttop_closed")).gameObject;
				((Container)planTotem).m_height = 2;
				((Container)planTotem).m_width = 6;
				MeshRenderer component = ((Component)prefab2.transform.Find("new/totem")).GetComponent<MeshRenderer>();
				((Renderer)component).materials.First((Material material) => ((Object)material).name.StartsWith("Guardstone_OdenGlow_mat")).SetColor("_EmissionColor", Config.GlowColorConfig.Value);
				CircleProjector componentInChildren = prefab2.GetComponentInChildren<CircleProjector>(true);
				componentInChildren.m_prefab = PrefabManager.Instance.GetPrefab("guard_stone").GetComponentInChildren<CircleProjector>().m_prefab;
				componentInChildren.m_radius = Config.RadiusConfig.Value;
			});
			GameObject prefab = PlanTotemKitbash.Prefab;
			PieceConfig val = new PieceConfig();
			val.PieceTable = "Hammer";
			val.Requirements = (RequirementConfig[])(object)new RequirementConfig[2]
			{
				new RequirementConfig
				{
					Item = "Wood",
					Amount = 1,
					Recover = true
				},
				new RequirementConfig
				{
					Item = "GreydwarfEye",
					Amount = 1,
					Recover = true
				}
			};
			CustomPiece val2 = new CustomPiece(prefab, false, val);
			PieceManager.Instance.AddPiece(val2);
		}
	}
}
namespace PlanBuild.Blueprints
{
	internal class Blueprint
	{
		public enum Format
		{
			VBuild,
			Blueprint
		}

		private enum ParserState
		{
			SnapPoints,
			Terrain,
			Pieces
		}

		public const string PieceBlueprintName = "piece_blueprint";

		public const string PlaceColliderName = "place_collider";

		public const string AdditionalInfo = "AdditionalText";

		private const string HeaderName = "#Name:";

		private const string HeaderCreator = "#Creator:";

		private const string HeaderDescription = "#Description:";

		private const string HeaderCategory = "#Category:";

		private const string HeaderSnapPoints = "#SnapPoints";

		private const string HeaderTerrain = "#Terrain";

		private const string HeaderPieces = "#Pieces";

		private const int ThumbnailSize = 256;

		public string FileLocation;

		public Format FileFormat;

		public string ThumbnailLocation;

		public string ID;

		public string Name;

		public string Creator;

		public string Description = string.Empty;

		public string Category = "Blueprints";

		public PieceEntry[] PieceEntries;

		public SnapPointEntry[] SnapPoints;

		public TerrainModEntry[] TerrainMods;

		private Texture2D ResizedThumbnail;

		private GameObject Prefab;

		private KeyHintConfig KeyHint;

		private Bounds Bounds;

		internal float GhostActiveTime;

		public Texture2D Thumbnail
		{
			get
			{
				return ResizedThumbnail;
			}
			set
			{
				if (((Texture)value).width > 256)
				{
					ShaderHelper.ScaleTexture(value, 256);
				}
				ResizedThumbnail = value;
			}
		}

		private string PrefabName => "piece_blueprint:" + ID;

		public static string CreateIDString(string name)
		{
			string text = string.Concat(name.Split(Path.GetInvalidFileNameChars()));
			string text2 = text.Replace(' ', '_').Trim();
			if (Config.AddPlayerNameConfig.Value)
			{
				text2 = Player.m_localPlayer.GetPlayerName() + "_" + text2;
			}
			return text2;
		}

		public static Blueprint FromFile(string fileLocation)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileLocation);
			string text = Path.GetExtension(fileLocation).ToLowerInvariant();
			Format format;
			if (!(text == ".vbuild"))
			{
				if (!(text == ".blueprint"))
				{
					throw new Exception("Format " + text + " not recognized");
				}
				format = Format.Blueprint;
			}
			else
			{
				format = Format.VBuild;
			}
			string[] array = File.ReadAllLines(fileLocation);
			Logger.LogDebug((object)$"Read {array.Length} lines from {fileLocation}");
			Blueprint blueprint = FromArray(fileNameWithoutExtension, array, format);
			blueprint.FileFormat = format;
			blueprint.FileLocation = fileLocation;
			blueprint.ThumbnailLocation = fileLocation.Replace(text, ".png");
			if (File.Exists(blueprint.ThumbnailLocation))
			{
				blueprint.Thumbnail = AssetUtils.LoadTexture(blueprint.ThumbnailLocation, false);
				Logger.LogDebug((object)("Read thumbnail data from " + blueprint.ThumbnailLocation));
			}
			return blueprint;
		}

		public static Blueprint FromZPackage(ZPackage pkg)
		{
			string id = pkg.ReadString();
			return FromBlob(id, pkg.ReadByteArray());
		}

		public static Blueprint FromBlob(string id, byte[] payload)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			List<string> list = new List<string>();
			using MemoryStream input = new MemoryStream(Utils.Decompress(payload));
			Blueprint blueprint;
			using (BinaryReader binaryReader = new BinaryReader(input))
			{
				int num = binaryReader.ReadInt32();
				for (int i = 0; i < num; i++)
				{
					list.Add(binaryReader.ReadString());
				}
				blueprint = FromArray(id, list.ToArray(), Format.Blueprint);
				int num2 = binaryReader.ReadInt32();
				if (num2 > 0)
				{
					byte[] array = binaryReader.ReadBytes(num2);
					Texture2D val = new Texture2D(1, 1);
					val.LoadRawTextureData(array);
					blueprint.Thumbnail = val;
				}
			}
			return blueprint;
		}

		public static Blueprint FromArray(string id, string[] lines, Format format)
		{
			Blueprint blueprint = new Blueprint();
			blueprint.ID = id;
			blueprint.FileFormat = Format.Blueprint;
			blueprint.FileLocation = Path.Combine(Config.BlueprintSaveDirectoryConfig.Value, id + ".blueprint");
			blueprint.ThumbnailLocation = Path.Combine(Config.BlueprintSaveDirectoryConfig.Value, id + ".png");
			List<PieceEntry> list = new List<PieceEntry>();
			List<SnapPointEntry> list2 = new List<SnapPointEntry>();
			List<TerrainModEntry> list3 = new List<TerrainModEntry>();
			ParserState parserState = ParserState.Pieces;
			foreach (string text in lines)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				if (text.StartsWith("#Name:"))
				{
					blueprint.Name = text.Substring("#Name:".Length);
					continue;
				}
				if (text.StartsWith("#Creator:"))
				{
					blueprint.Creator = text.Substring("#Creator:".Length);
					continue;
				}
				if (text.StartsWith("#Description:"))
				{
					blueprint.Description = text.Substring("#Description:".Length);
					if (blueprint.Description.StartsWith("\""))
					{
						blueprint.Description = SimpleJson.DeserializeObject<string>(blueprint.Description);
					}
					continue;
				}
				if (text.StartsWith("#Category:"))
				{
					blueprint.Category = text.Substring("#Category:".Length);
					if (string.IsNullOrEmpty(blueprint.Category))
					{
						blueprint.Category = "Blueprints";
					}
					continue;
				}
				switch (text)
				{
				case "#SnapPoints":
					parserState = ParserState.SnapPoints;
					continue;
				case "#Terrain":
					parserState = ParserState.Terrain;
					continue;
				case "#Pieces":
					parserState = ParserState.Pieces;
					continue;
				}
				if (text.StartsWith("#"))
				{
					continue;
				}
				switch (parserState)
				{
				case ParserState.SnapPoints:
					list2.Add(new SnapPointEntry(text));
					break;
				case ParserState.Terrain:
					list3.Add(new TerrainModEntry(text));
					break;
				case ParserState.Pieces:
					switch (format)
					{
					case Format.VBuild:
						list.Add(PieceEntry.FromVBuild(text));
						break;
					case Format.Blueprint:
						list.Add(PieceEntry.FromBlueprint(text));
						break;
					}
					break;
				}
			}
			if (string.IsNullOrEmpty(blueprint.Name))
			{
				blueprint.Name = blueprint.ID;
			}
			blueprint.PieceEntries = list.ToArray();
			blueprint.SnapPoints = list2.ToArray();
			blueprint.TerrainMods = list3.ToArray();
			return blueprint;
		}

		public string[] ToArray()
		{
			if (PieceEntries == null)
			{
				return null;
			}
			List<string> list = new List<string>();
			list.Add("#Name:" + Name);
			list.Add("#Creator:" + Creator);
			list.Add("#Description:" + SimpleJson.SerializeObject((object)Description));
			list.Add("#Category:" + Category);
			if (SnapPoints.Any())
			{
				list.Add("#SnapPoints");
				SnapPointEntry[] snapPoints = SnapPoints;
				foreach (SnapPointEntry snapPointEntry in snapPoints)
				{
					list.Add(snapPointEntry.line);
				}
			}
			if (TerrainMods.Any())
			{
				list.Add("#Terrain");
				TerrainModEntry[] terrainMods = TerrainMods;
				foreach (TerrainModEntry terrainModEntry in terrainMods)
				{
					list.Add(terrainModEntry.line);
				}
			}
			list.Add("#Pieces");
			PieceEntry[] pieceEntries = PieceEntries;
			foreach (PieceEntry pieceEntry in pieceEntries)
			{
				list.Add(pieceEntry.line);
			}
			return list.ToArray();
		}

		public byte[] ToBlob(bool includeThumbnail = false)
		{
			string[] array = ToArray();
			if (array == null || array.Length == 0)
			{
				return null;
			}
			using MemoryStream memoryStream = new MemoryStream();
			using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
			{
				binaryWriter.Write(array.Length);
				string[] array2 = array;
				foreach (string value in array2)
				{
					binaryWriter.Write(value);
				}
				if (!includeThumbnail || (Object)(object)Thumbnail == (Object)null)
				{
					binaryWriter.Write(0);
				}
				else
				{
					byte[] array3 = ImageConversion.EncodeToPNG(Thumbnail);
					binaryWriter.Write(array3.Length);
					binaryWriter.Write(array3);
				}
			}
			return Utils.Compress(memoryStream.ToArray());
		}

		public ZPackage ToZPackage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(ID);
			val.Write(ToBlob());
			return val;
		}

		public bool ToFile()
		{
			string[] array = ToArray();
			if (array == null || array.Length == 0)
			{
				return false;
			}
			using (TextWriter textWriter = new StreamWriter(FileLocation))
			{
				string[] array2 = array;
				foreach (string value in array2)
				{
					textWriter.WriteLine(value);
				}
				Logger.LogDebug((object)$"Wrote {PieceEntries.Length} pieces to {FileLocation}");
			}
			if (FileFormat == Format.VBuild)
			{
				string text = FileLocation.Replace(".vbuild", ".blueprint");
				File.Move(FileLocation, text);
				FileLocation = text;
				FileFormat = Format.Blueprint;
			}
			if ((Object)(object)Thumbnail != (Object)null)
			{
				File.WriteAllBytes(ThumbnailLocation, ImageConversion.EncodeToPNG(Thumbnail));
				Logger.LogDebug((object)("Wrote thumbnail data to " + ThumbnailLocation));
			}
			return true;
		}

		public override string ToString()
		{
			return Localization.instance.Localize(ID + " ($gui_bpmarket_pieces)", new string[1] { GetPieceCount().ToString() });
		}

		public string ToGUIString()
		{
			return Localization.instance.Localize("<b>" + Name + "</b>\n ($gui_bpmarket_pieces)", new string[1] { GetPieceCount().ToString() });
		}

		public int GetPieceCount()
		{
			return PieceEntries.Length;
		}

		public int GetSnapPointCount()
		{
			return SnapPoints.Length;
		}

		public int GetTerrainModCount()
		{
			return TerrainMods.Length;
		}

		public Bounds GetBounds()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 size = ((Bounds)(ref Bounds)).size;
			if (((Vector3)(ref size)).magnitude != 0f)
			{
				return Bounds;
			}
			PieceEntry[] pieceEntries = PieceEntries;
			foreach (PieceEntry pieceEntry in pieceEntries)
			{
				((Bounds)(ref Bounds)).Encapsulate(pieceEntry.GetPosition());
			}
			return Bounds;
		}

		public bool Capture(Selection selection, bool captureCurrentSnapPoints = false, bool keepMarkers = false)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_076b: Unknown result type (might be due to invalid IL or missing references)
			//IL_076d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0771: Unknown result type (might be due to invalid IL or missing references)
			//IL_0865: Unknown result type (might be due to invalid IL or missing references)
			//IL_086a: Unknown result type (might be due to invalid IL or missing references)
			//IL_086c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0902: Unknown result type (might be due to invalid IL or missing references)
			//IL_0907: Unknown result type (might be due to invalid IL or missing references)
			//IL_0909: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogDebug((object)"Collecting piece information");
			int num = 0;
			List<Piece> list = new List<Piece>();
			List<Vector3> list2 = new List<Vector3>();
			Transform val = null;
			List<TerrainModEntry> list3 = new List<TerrainModEntry>();
			foreach (ZDOID item2 in selection)
			{
				GameObject gameObject = BlueprintManager.GetGameObject(item2, required: true);
				if (((Object)gameObject).name.StartsWith("piece_bpsnappoint"))
				{
					list2.Add(gameObject.transform.position);
					if (!keepMarkers)
					{
						WearNTear component = gameObject.GetComponent<WearNTear>();
						component.Remove(false);
					}
					continue;
				}
				if (((Object)gameObject).name.StartsWith("piece_bpcenterpoint"))
				{
					if ((Object)(object)val == (Object)null)
					{
						val = gameObject.transform;
					}
					else
					{
						Logger.LogWarning((object)$"Multiple center points! Ignoring @ {gameObject.transform.position}");
					}
					if (!keepMarkers)
					{
						WearNTear component2 = gameObject.GetComponent<WearNTear>();
						component2.Remove(false);
					}
					continue;
				}
				if (((Object)gameObject).name.StartsWith("piece_bpterrainmod"))
				{
					ZDO zDO = gameObject.GetComponent<ZNetView>().GetZDO();
					TerrainModEntry item = new TerrainModEntry(zDO.GetString("shape", ""), gameObject.transform.position, float.Parse(zDO.GetString("radius", ""), CultureInfo.InvariantCulture), int.Parse(zDO.GetString("rotation", ""), CultureInfo.InvariantCulture), float.Parse(zDO.GetString("smooth", ""), CultureInfo.InvariantCulture), zDO.GetString("paint", ""));
					list3.Add(item);
					if (!keepMarkers)
					{
						WearNTear component3 = gameObject.GetComponent<WearNTear>();
						component3.Remove(false);
					}
					continue;
				}
				Piece component4 = gameObject.GetComponent<Piece>();
				if (!BlueprintManager.CanCapture(component4))
				{
					Logger.LogWarning((object)$"Ignoring piece {component4}, not able to make blueprint");
					continue;
				}
				if (captureCurrentSnapPoints)
				{
					Transform[] componentsInChildren = gameObject.GetComponentsInChildren<Transform>(true);
					foreach (Transform val2 in componentsInChildren)
					{
						if (((Object)val2).name.StartsWith("$hud_snappoint"))
						{
							list2.Add(val2.position);
						}
					}
				}
				list.Add(component4);
				num++;
			}
			if (!list.Any())
			{
				return false;
			}
			Logger.LogDebug((object)$"Found {num} pieces");
			Vector3 position = default(Vector3);
			if ((Object)(object)val == (Object)null)
			{
				float num2 = 10000000f;
				float num3 = 10000000f;
				float num4 = 10000000f;
				foreach (Piece item3 in list)
				{
					num3 = Math.Min(item3.m_nview.GetZDO().m_position.x, num3);
					num2 = Math.Min(item3.m_nview.GetZDO().m_position.z, num2);
					num4 = Math.Min(item3.m_nview.GetZDO().m_position.y, num4);
				}
				Logger.LogDebug((object)$"{num3} - {num4} - {num2}");
				((Vector3)(ref position))..ctor(num3, num4, num2);
			}
			else
			{
				position = val.position;
			}
			IOrderedEnumerable<Piece> orderedEnumerable = from x in list
				orderby ((Component)x).transform.position.y, ((Component)x).transform.position.x, ((Component)x).transform.position.z
				select x;
			int num5 = orderedEnumerable.Count();
			if (PieceEntries == null)
			{
				PieceEntries = new PieceEntry[num5];
			}
			else if (PieceEntries.Length != 0)
			{
				Array.Clear(PieceEntries, 0, PieceEntries.Length - 1);
				Array.Resize(ref PieceEntries, num5);
			}
			uint num6 = 0u;
			foreach (Piece item4 in orderedEnumerable)
			{
				Vector3 pos = item4.m_nview.GetZDO().GetPosition() - position;
				Quaternion rotation = item4.m_nview.GetZDO().GetRotation();
				((Quaternion)(ref rotation)).eulerAngles = ((Component)item4).transform.eulerAngles;
				string text = string.Empty;
				TextReceiver component5 = ((Component)item4).GetComponent<TextReceiver>();
				if (component5 != null)
				{
					text = component5.GetText();
				}
				ItemStand component6 = ((Component)item4).GetComponent<ItemStand>();
				if ((Object)(object)component6 != (Object)null && component6.HaveAttachment() && Object.op_Implicit((Object)(object)component6.m_nview))
				{
					text = string.Format("{0}:{1}:{2}:{3}", component6.m_nview.m_zdo.GetString("item", ""), component6.m_nview.m_zdo.GetInt("variant", 0), component6.m_nview.m_zdo.GetInt("quality", 0), component6.m_nview.m_zdo.GetInt("type", 0));
				}
				ArmorStand component7 = ((Component)item4).GetComponent<ArmorStand>();
				if ((Object)(object)component7 != (Object)null && Object.op_Implicit((Object)(object)component7.m_nview))
				{
					text = $"{component7.m_pose}:";
					text += $"{component7.m_slots.Count}:";
					foreach (ArmorStandSlot slot in component7.m_slots)
					{
						text += $"{slot.m_currentItemName}:{slot.m_visualVariant}:";
					}
				}
				Door component8 = ((Component)item4).GetComponent<Door>();
				if ((Object)(object)component8 != (Object)null && Object.op_Implicit((Object)(object)component8.m_nview))
				{
					text = string.Format("{0}", component8.m_nview.m_zdo.GetInt("state", 0));
				}
				PrivateArea component9 = ((Component)item4).GetComponent<PrivateArea>();
				if ((Object)(object)component9 != (Object)null && Object.op_Implicit((Object)(object)component9.m_nview))
				{
					text = string.Format("{0}", component9.m_nview.m_zdo.GetBool("enabled", false));
				}
				Container component10 = ((Component)item4).GetComponent<Container>();
				if ((Object)(object)component10 != (Object)null && Object.op_Implicit((Object)(object)component10.m_nview))
				{
					text = component10.m_nview.GetZDO().GetString("items", "");
				}
				Vector3 localScale = ((Component)item4).transform.localScale;
				string text2 = ((Object)item4).name.Split(new char[1] { '(' })[0];
				ZNetView component11 = ((Component)item4).gameObject.GetComponent<ZNetView>();
				if (component11 != null && component11.m_zdo != null)
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(component11.m_zdo.m_prefab);
					if (prefab != null)
					{
						text2 = ((Object)prefab).name;
					}
				}
				if (text2.EndsWith("_planned"))
				{
					text2 = text2.Replace("_planned", null);
				}
				PieceEntries[num6++] = new PieceEntry(text2, ((object)Unsafe.As<PieceCategory, PieceCategory>(ref item4.m_category)/*cast due to .constrained prefix*/).ToString(), pos, rotation, text, localScale);
			}
			List<Vector3> list4 = (from x in list2
				group x by x into x
				where x.Count() == 1
				select x.Key).ToList();
			if (SnapPoints == null)
			{
				SnapPoints = new SnapPointEntry[list4.Count];
			}
			else if (SnapPoints.Length != 0)
			{
				Array.Clear(SnapPoints, 0, SnapPoints.Length - 1);
				Array.Resize(ref SnapPoints, list4.Count);
			}
			for (int num7 = 0; num7 < list4.Count; num7++)
			{
				SnapPoints[num7] = new SnapPointEntry(list4[num7] - position);
			}
			if (TerrainMods == null)
			{
				TerrainMods = new TerrainModEntry[list3.Count];
			}
			else if (TerrainMods.Length != 0)
			{
				Array.Clear(TerrainMods, 0, TerrainMods.Length - 1);
				Array.Resize(ref TerrainMods, list3.Count);
			}
			uint num8 = 0u;
			foreach (TerrainModEntry item5 in list3)
			{
				TerrainMods[num8++] = new TerrainModEntry(item5.shape, item5.GetPosition() - position, item5.radius, item5.rotation, item5.smooth, item5.paint);
			}
			return true;
		}

		public bool CreatePiece()
		{
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Prefab))
			{
				return false;
			}
			Logger.LogDebug((object)("Creating dynamic prefab " + PrefabName));
			if (PieceEntries == null)
			{
				Logger.LogWarning((object)"Could not create blueprint prefab: No pieces loaded");
				return false;
			}
			GameObject prefab = PrefabManager.Instance.GetPrefab("piece_blueprint");
			if ((Object)(object)prefab == (Object)null)
			{
				Logger.LogWarning((object)"Could not load blueprint stub from prefabs");
				return false;
			}
			ZNetView.m_forceDisableInit = true;
			Prefab = Object.Instantiate<GameObject>(prefab);
			ZNetView.m_forceDisableInit = false;
			((Object)Prefab).name = PrefabName;
			Piece component = Prefab.GetComponent<Piece>();
			component.m_name = Name;
			component.m_enabled = true;
			component.m_description = LocalizationManager.Instance.TryTranslate("$gui_desc_id") + " " + ID;
			if (PieceEntries != null)
			{
				component.m_description += string.Format("{0}{1} {2}", Environment.NewLine, LocalizationManager.Instance.TryTranslate("$gui_desc_pieces"), PieceEntries.Length);
			}
			if (!string.IsNullOrEmpty(Description))
			{
				Piece val = component;
				val.m_description = val.m_description + Environment.NewLine + LocalizationManager.Instance.TryTranslate("$gui_desc_description") + Environment.NewLine + Description;
			}
			if ((Object)(object)Thumbnail != (Object)null)
			{
				component.m_icon = Sprite.Create(Thumbnail, new Rect(0f, 0f, (float)((Texture)Thumbnail).width, (float)((Texture)Thumbnail).height), Vector2.zero);
			}
			PieceManager.Instance.RegisterPieceInPieceTable(Prefab, "_BlueprintPieceTable", Category);
			CreateKeyHint();
			Prefab.AddComponent<PlacementComponent>();
			return true;
		}

		public void CreateKeyHint()
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			if (KeyHint != null)
			{
				KeyHintManager.Instance.RemoveKeyHint(KeyHint);
			}
			string text = LocalizationManager.Instance.TryTranslate("$hud_bpoffsetpiece");
			string text2 = LocalizationManager.Instance.TryTranslate(ZInput.instance.GetBoundKeyString(Config.CtrlModifierButton.Name, false));
			string text3 = LocalizationManager.Instance.TryTranslate(ZInput.instance.GetBoundKeyString(Config.AltModifierButton.Name, false));
			string text4 = text + " " + text2 + " + " + text3 + " = Y\n" + text2 + " = Z, " + text3 + " = X";
			text4 = text4.Replace("[", null);
			text4 = text4.Replace("]", null);
			KeyHintConfig val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = PrefabName;
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[6]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_bpplace"
				},
				new ButtonConfig
				{
					Name = Config.CtrlModifierButton.Name,
					Config = Config.CtrlModifierConfig,
					HintToken = (Config.DirectBuildDefault ? "$hud_bpplanned" : "$hud_bpdirect")
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				},
				new ButtonConfig
				{
					Name = Config.ToggleButton.Name,
					Config = Config.ToggleConfig,
					HintToken = "$hud_bpresetoffset"
				},
				new ButtonConfig
				{
					Name = "Scroll",
					Axis = "Mouse ScrollWheel",
					HintToken = "$hud_bprotatepiece"
				},
				new ButtonConfig
				{
					Name = "Scroll",
					Axis = "Mouse ScrollWheel",
					Hint = text4
				}
			};
			KeyHint = val;
			KeyHintManager.Instance.AddKeyHint(KeyHint);
		}

		public bool CreateThumbnail(int additionalRotation = 0, bool flush = true)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if (!InstantiateGhost())
			{
				return false;
			}
			RenderRequest val = new RenderRequest(Prefab)
			{
				Rotation = RenderManager.IsometricRotation * Quaternion.Euler(0f, (float)additionalRotation, 0f),
				Width = 256,
				Height = 256
			};
			Sprite val2 = RenderManager.Instance.Render(val);
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			Thumbnail = val2.texture;
			Prefab.GetComponent<Piece>().m_icon = Sprite.Create(Thumbnail, new Rect(0f, 0f, (float)((Texture)Thumbnail).width, (float)((Texture)Thumbnail).height), Vector2.zero);
			if (flush)
			{
				File.WriteAllBytes(ThumbnailLocation, ImageConversion.EncodeToPNG(Thumbnail));
			}
			return true;
		}

		public bool InstantiateGhost()
		{
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: 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_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Prefab))
			{
				return false;
			}
			if (Prefab.transform.childCount > 1)
			{
				return true;
			}
			GameObject prefab = Prefab;
			bool result = true;
			ZNetView.m_forceDisableInit = true;
			try
			{
				List<PieceEntry> list = new List<PieceEntry>(PieceEntries);
				SnapPointEntry[] snapPoints = SnapPoints;
				foreach (SnapPointEntry snapPointEntry in snapPoints)
				{
					GameObject val = new GameObject
					{
						name = "$hud_snappoint",
						layer = LayerMask.NameToLayer("piece"),
						tag = "snappoint"
					};
					val.SetActive(false);
					GameObject val2 = Object.Instantiate<GameObject>(val, snapPointEntry.GetPosition(), Quaternion.identity, prefab.transform);
					((Object)val2).name = "$hud_snappoint";
				}
				GameObject val3 = new GameObject("place_collider");
				val3.transform.SetParent(prefab.transform);
				val3.layer = LayerMask.NameToLayer("piece_nonsolid");
				SphereCollider val4 = val3.AddComponent<SphereCollider>();
				val4.radius = 0.002f;
				Transform transform = prefab.transform;
				Dictionary<string, GameObject> dictionary = new Dictionary<string, GameObject>();
				foreach (PieceEntry item in from x in list
					group x by x.name into x
					select x.FirstOrDefault())
				{
					GameObject prefab2 = PrefabManager.Instance.GetPrefab(item.name);
					if (!Object.op_Implicit((Object)(object)prefab2))
					{
						Logger.LogWarning((object)("No prefab found for " + item.name + "! You are probably missing a dependency for blueprint " + Name));
					}
					else
					{
						dictionary.Add(item.name, prefab2);
					}
				}
				for (int num = 0; num < list.Count; num++)
				{
					PieceEntry pieceEntry = list[num];
					try
					{
						Vector3 val5 = transform.position + pieceEntry.GetPosition();
						Quaternion val6 = transform.rotation * pieceEntry.GetRotation();
						Vector3 scale = pieceEntry.GetScale();
						if (dictionary.TryGetValue(pieceEntry.name, out var value))
						{
							GameObject val7 = Object.Instantiate<GameObject>(value, val5, val6, transform);
							val7.transform.localScale = scale;
							PrepareGhostPiece(val7);
						}
					}
					catch (Exception arg)
					{
						Logger.LogWarning((object)$"Error while creating ghost of line: {pieceEntry.line}\n{arg}");
					}
				}
				if (Config.ShowGridConfig.Value)
				{
					DebugUtils.InitLaserGrid(prefab, GetBounds());
				}
			}
			catch (Exception arg2)
			{
				Logger.LogWarning((object)$"Error caught while instantiating {Name}: {arg2}");
				result = false;
			}
			finally
			{
				ZNetView.m_forceDisableInit = false;
			}
			return result;
		}

		private void PrepareGhostPiece(GameObject child)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			MonoBehaviour[] componentsInChildren = child.GetComponentsInChildren<MonoBehaviour>();
			foreach (MonoBehaviour val in componentsInChildren)
			{
				Object.DestroyImmediate((Object)(object)val);
			}
			Collider[] componentsInChildren2 = child.GetComponentsInChildren<Collider>();
			foreach (Collider val2 in componentsInChildren2)
			{
				Object.DestroyImmediate((Object)(object)val2);
			}
			Transform[] componentsInChildren3 = child.GetComponentsInChildren<Transform>(true);
			foreach (Transform val3 in componentsInChildren3)
			{
				if (((Object)val3).name.StartsWith("$hud_snappoint"))
				{
					Object.DestroyImmediate((Object)(object)((Component)val3).gameObject);
				}
			}
			MeshRenderer[] componentsInChildren4 = child.GetComponentsInChildren<MeshRenderer>();
			MeshRenderer[] array = componentsInChildren4;
			foreach (MeshRenderer val4 in array)
			{
				if ((Object)(object)((Renderer)val4).sharedMaterial != (Object)null)
				{
					Material[] sharedMaterials = ((Renderer)val4).sharedMaterials;
					for (int m = 0; m < sharedMaterials.Length; m++)
					{
						Material val5 = new Material(sharedMaterials[m]);
						val5.SetFloat("_RippleDistance", 0f);
						val5.SetFloat("_ValueNoise", 0f);
						sharedMaterials[m] = val5;
					}
					((Renderer)val4).sharedMaterials = sharedMaterials;
					((Renderer)val4).shadowCastingMode = (ShadowCastingMode)0;
				}
			}
		}

		public void DestroyGhost()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)Prefab) || Prefab.transform.childCount <= 1)
			{
				return;
			}
			foreach (Transform item in Prefab.transform)
			{
				Transform val = item;
				if (((Object)val).name != "_GhostOnly")
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			GhostActiveTime = 0f;
		}

		public void DestroyBlueprint()
		{
			if (Object.op_Implicit((Object)(object)Prefab))
			{
				PieceTable pieceTable = PieceManager.Instance.GetPieceTable("_BlueprintPieceTable");
				if ((Object)(object)pieceTable == (Object)null)
				{
					Logger.LogWarning((object)"_BlueprintPieceTable not found");
					return;
				}
				if (pieceTable.m_pieces.Contains(Prefab))
				{
					Logger.LogInfo((object)("Removing " + PrefabName + " from BlueprintRune"));
					pieceTable.m_pieces.Remove(Prefab);
				}
				if (PieceManager.Instance.GetPiece(PrefabName) != null)
				{
					PieceManager.Instance.RemovePiece(PrefabName);
				}
				PrefabManager.Instance.DestroyPrefab(PrefabName);
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Player.m_localPlayer.m_knownRecipes.Contains(PrefabName))
				{
					Player.m_localPlayer.m_knownRecipes.Remove(PrefabName);
				}
				Prefab = null;
			}
			if (KeyHint != null)
			{
				KeyHintManager.Instance.RemoveKeyHint(KeyHint);
				KeyHint = null;
			}
			if (File.Exists(FileLocation))
			{
				File.Delete(FileLocation);
			}
			if (File.Exists(ThumbnailLocation))
			{
				File.Delete(ThumbnailLocation);
			}
		}
	}
	internal class TerrainModGUI
	{
		private class SaveGUIBehaviour : MonoBehaviour
		{
			private void Update()
			{
				if (IsVisible())
				{
					if (Input.GetKeyUp((KeyCode)13))
					{
						Instance.OnOk();
					}
					if (Input.GetKeyUp((KeyCode)27))
					{
						Instance.OnCancel();
					}
				}
			}
		}

		public static TerrainModGUI Instance;

		private GameObject Prefab;

		private GameObject Window;

		private Dropdown Shape;

		private InputField Radius;

		private InputField Rotation;

		private InputField Smooth;

		private Dropdown Paint;

		private Button OkButton;

		private Button CancelButton;

		private Action<string, string, string, string, string> OkAction;

		private Action CancelAction;

		public static void Init(GameObject prefab)
		{
			if (!GUIManager.IsHeadless())
			{
				Instance = new TerrainModGUI();
				Instance.Prefab = prefab;
				GUIManager.OnCustomGUIAvailable += Instance.Register;
			}
		}

		public static bool IsAvailable()
		{
			return Instance != null;
		}

		public static bool IsVisible()
		{
			if (IsAvailable() && (Object)(object)Instance.Window != (Object)null)
			{
				return Instance.Window.activeSelf;
			}
			return false;
		}

		public void Show(string shape, string radius, string rotation, string smooth, string paint, Action<string, string, string, string, string> okAction, Action cancelAction)
		{
			OkAction = okAction;
			CancelAction = cancelAction;
			Shape.value = Shape.options.FindIndex((OptionData x) => x.text.Equals(shape, StringComparison.OrdinalIgnoreCase));
			Radius.text = radius;
			Rotation.text = rotation;
			Smooth.text = smooth;
			Paint.value = Paint.options.FindIndex((OptionData x) => x.text.Equals(paint, StringComparison.OrdinalIgnoreCase));
			Window.SetActive(true);
			((Selectable)Shape).Select();
			GUIManager.BlockInput(true);
		}

		private void Register()
		{
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Expected O, but got Unknown
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)Window))
			{
				Logger.LogDebug((object)"Recreating TerrainModGUI");
				Window = Object.Instantiate<GameObject>(Prefab, GUIManager.CustomGUIFront.transform);
				Window.AddComponent<DragWindowCntrl>();
				Image component = Window.GetComponent<Image>();
				component.sprite = GUIManager.Instance.GetSprite("woodpanel_settings");
				component.type = (Type)1;
				((Graphic)component).material = Cache.GetPrefab<Material>("litpanel");
				Text[] componentsInChildren = Window.GetComponentsInChildren<Text>(true);
				foreach (Text val in componentsInChildren)
				{
					val.font = GUIManager.Instance.AveriaSerif;
				}
				Dropdown[] componentsInChildren2 = Window.GetComponentsInChildren<Dropdown>(true);
				foreach (Dropdown val2 in componentsInChildren2)
				{
					GUIManager.Instance.ApplyDropdownStyle(val2, 15);
				}
				InputField[] componentsInChildren3 = Window.GetComponentsInChildren<InputField>(true);
				foreach (InputField val3 in componentsInChildren3)
				{
					GUIManager.Instance.ApplyInputFieldStyle(val3, 16);
				}
				Button[] componentsInChildren4 = Window.GetComponentsInChildren<Button>(true);
				foreach (Button val4 in componentsInChildren4)
				{
					GUIManager.Instance.ApplyButtonStyle(val4, 16);
				}
				Shape = ((Component)Window.transform.Find("Shape/Dropdown")).GetComponent<Dropdown>();
				Radius = ((Component)Window.transform.Find("Radius/InputField")).GetComponent<InputField>();
				Radius.textComponent.alignment = (TextAnchor)3;
				Rotation = ((Component)Window.transform.Find("Rotation/InputField")).GetComponent<InputField>();
				Rotation.textComponent.alignment = (TextAnchor)3;
				Smooth = ((Component)Window.transform.Find("Smooth/InputField")).GetComponent<InputField>();
				Smooth.textComponent.alignment = (TextAnchor)3;
				Paint = ((Component)Window.transform.Find("Paint/Dropdown")).GetComponent<Dropdown>();
				OkButton = ((Component)Window.transform.Find("Buttons/OkButton")).GetComponent<Button>();
				CancelButton = ((Component)Window.transform.Find("Buttons/CancelButton")).GetComponent<Button>();
				((UnityEvent)OkButton.onClick).AddListener((UnityAction)delegate
				{
					OnOk();
				});
				((UnityEvent)CancelButton.onClick).AddListener((UnityAction)delegate
				{
					OnCancel();
				});
				Localization.instance.Localize(Instance.Window.transform);
				Instance.Window.AddComponent<SaveGUIBehaviour>();
				Window.SetActive(false);
			}
		}

		private void OnOk()
		{
			OkAction(Shape.options[Shape.value].text, Radius.text.Trim(), Rotation.text.Trim(), Smooth.text.Trim(), Paint.options[Paint.value].text);
			Window.SetActive(false);
			GUIManager.BlockInput(false);
		}

		private void OnCancel()
		{
			CancelAction();
			Window.SetActive(false);
			GUIManager.BlockInput(false);
		}
	}
	internal class SelectionSaveGUI
	{
		private class SelectionSaveGUIBehaviour : MonoBehaviour
		{
			private void Update()
			{
				if (IsVisible())
				{
					if (Input.GetKeyUp((KeyCode)13) && !Instance.Description.isFocused)
					{
						Instance.OnOk();
					}
					if (Input.GetKeyUp((KeyCode)27))
					{
						Instance.OnCancel();
					}
					if (Input.GetKeyDown((KeyCode)9) && Instance.Name.isFocused)
					{
						((Selectable)Instance.Category).Select();
					}
					if (Input.GetKeyDown((KeyCode)9) && Instance.Category.isFocused)
					{
						((Selectable)Instance.Description).Select();
					}
				}
			}
		}

		public static SelectionSaveGUI Instance;

		private GameObject Prefab;

		private GameObject Window;

		private Text Pieces;

		private Text SnapPoints;

		private Text CenterMarkers;

		private Text TerrainMods;

		private InputField Name;

		private InputField Category;

		private InputField Description;

		private Button OkButton;

		private Button CancelButton;

		private Action<string, string, string> OkAction;

		private Action CancelAction;

		public static void Init(GameObject prefab)
		{
			if (!GUIManager.IsHeadless())
			{
				Instance = new SelectionSaveGUI();
				Instance.Prefab = prefab;
				GUIManager.OnCustomGUIAvailable += Instance.Register;
			}
		}

		public static bool IsAvailable()
		{
			return Instance != null;
		}

		public static bool IsVisible()
		{
			if (IsAvailable() && (Object)(object)Instance.Window != (Object)null)
			{
				return Instance.Window.activeSelf;
			}
			return false;
		}

		public void Show(Selection selection, string bpname, Action<string, string, string> okAction, Action cancelAction)
		{
			OkAction = okAction;
			CancelAction = cancelAction;
			Pieces.text = Localization.instance.Localize("$gui_bpsave_pieces", new string[1] { selection.Count().ToString() });
			SnapPoints.text = Localization.instance.Localize("$gui_bpsave_snappoints", new string[1] { selection.SnapPoints.ToString() });
			CenterMarkers.text = Localization.instance.Localize("$gui_bpsave_centermarkers", new string[1] { selection.CenterMarkers.ToString() });
			TerrainMods.text = Localization.instance.Localize("$gui_bpsave_terrainmods", new string[1] { selection.TerrainMods.ToString() });
			Name.text = bpname;
			Category.text = "Blueprints";
			Description.text = null;
			Window.SetActive(true);
			((Selectable)Name).Select();
			GUIManager.BlockInput(true);
		}

		private void Register()
		{
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Expected O, but got Unknown
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)Window))
			{
				Logger.LogDebug((object)"Recreating SaveGUI");
				Window = Object.Instantiate<GameObject>(Prefab, GUIManager.CustomGUIFront.transform);
				Window.AddComponent<DragWindowCntrl>();
				Image component = Window.GetComponent<Image>();
				component.sprite = GUIManager.Instance.GetSprite("woodpanel_settings");
				component.type = (Type)1;
				((Graphic)component).material = Cache.GetPrefab<Material>("litpanel");
				Text[] componentsInChildren = Window.GetComponentsInChildren<Text>(true);
				foreach (Text val in componentsInChildren)
				{
					val.font = GUIManager.Instance.AveriaSerif;
				}
				InputField[] componentsInChildren2 = Window.GetComponentsInChildren<InputField>(true);
				foreach (InputField val2 in componentsInChildren2)
				{
					GUIManager.Instance.ApplyInputFieldStyle(val2, 16);
				}
				Button[] componentsInChildren3 = Window.GetComponentsInChildren<Button>(true);
				foreach (Button val3 in componentsInChildren3)
				{
					GUIManager.Instance.ApplyButtonStyle(val3, 16);
				}
				Pieces = ((Component)Window.transform.Find("Details/Pieces")).GetComponent<Text>();
				CenterMarkers = ((Component)Window.transform.Find("Details/CenterMarkers")).GetComponent<Text>();
				SnapPoints = ((Component)Window.transform.Find("Details/SnapPoints")).GetComponent<Text>();
				TerrainMods = ((Component)Window.transform.Find("Details/TerrainMods")).GetComponent<Text>();
				Name = ((Component)Window.transform.Find("Name/InputField")).GetComponent<InputField>();
				Name.textComponent.alignment = (TextAnchor)3;
				Category = ((Component)Window.transform.Find("Category/InputField")).GetComponent<InputField>();
				Category.textComponent.alignment = (TextAnchor)3;
				Description = ((Component)Window.transform.Find("Description/InputField")).GetComponent<InputField>();
				OkButton = ((Component)Window.transform.Find("Buttons/OkButton")).GetComponent<Button>();
				CancelButton = ((Component)Window.transform.Find("Buttons/CancelButton")).GetComponent<Button>();
				((UnityEvent)OkButton.onClick).AddListener((UnityAction)delegate
				{
					OnOk();
				});
				((UnityEvent)CancelButton.onClick).AddListener((UnityAction)delegate
				{
					OnCancel();
				});
				Localization.instance.Localize(Instance.Window.transform);
				Instance.Window.AddComponent<SelectionSaveGUIBehaviour>();
				Window.SetActive(false);
			}
		}

		private void OnOk()
		{
			OkAction(Name.text.Trim(), Category.text.Trim(), Description.text.Trim());
			Window.SetActive(false);
			GUIManager.BlockInput(false);
		}

		private void OnCancel()
		{
			CancelAction();
			Window.SetActive(false);
			GUIManager.BlockInput(false);
		}
	}
	internal class SelectionCommands
	{
		private class SelectionGUICommand : ConsoleCommand
		{
			public override string Name => "selection.gui";

			public override string Help => "Show the selection GUI";

			public override void Run(string[] args)
			{
				if (CheckSelection())
				{
					if (Console.IsVisible())
					{
						((Component)((Terminal)Console.instance).m_chatWindow).gameObject.SetActive(false);
					}
					SelectionGUI.Instance.Show();
				}
			}
		}

		private class ClearSelectionCommand : ConsoleCommand
		{
			public override string Name => "selection.clear";

			public override string Help => "Clear the current selection";

			public override void Run(string[] args)
			{
				if (CheckSelection())
				{
					Selection.Instance.Clear();
				}
			}
		}

		private class CopySelectionCommand : ConsoleCommand
		{
			public override string Name => "selection.copy";

			public override string Help => "Copy the current selection as a temporary blueprint";

			public override void Run(string[] args)
			{
				if (CheckSelection())
				{
					SelectionTools.Copy(Selection.Instance, args.Contains("saveCurrentSnapPoints"), args.Contains("keepMarkers"));
					Selection.Instance.Clear();
				}
			}

			public override List<string> CommandOptionList()
			{
				return new List<string> { "saveCurrentSnapPoints", "keepMarkers" };
			}
		}

		private class CutSelectionCommand : ConsoleCommand
		{
			public override string Name => "selection.cut";

			public override string Help => "Cut out the current selection as a temporary blueprint";

			public override void Run(string[] args)
			{
				if (CheckSelection())
				{
					if (!SynchronizationManager.Instance.PlayerIsAdmin)
					{
						Console.instance.Print(Localization.instance.Localize("$msg_select_cut_disabled"));
						return;
					}
					SelectionTools.Cut(Selection.Instance, args.Contains("saveCurrentSnapPoints"), args.Contains("keepMarkers"));
					Selection.Instance.Clear();
				}
			}

			public override List<string> CommandOptionList()
			{
				return new List<string> { "saveCurrentSnapPoints", "keepMarkers" };
			}
		}

		private class SaveSelectionCommand : ConsoleCommand
		{
			public override string Name => "selection.save";

			public override string Help => "Save the current selection as a blueprint";

			public override void Run(string[] args)
			{
				if (CheckSelection())
				{
					SelectionTools.SaveWithGUI(Selection.Instance, args.Contains("saveCurrentSnapPoints"), args.Contains("keepMarkers"));
				}
			}

			public override List<string> CommandOptionList()
			{
				return new List<string> { "saveCurrentSnapPoints", "keepMarkers" };
			}
		}

		private class DeleteSelectionCommand : ConsoleCommand
		{
			public override string Name => "selection.delete";

			public override string Help => "Delete all prefabs in the current selection";

			public override void Run(string[] args)
			{
				if (CheckSelection())
				{
					if (!SynchronizationManager.Instance.PlayerIsAdmin)
					{
						Console.instance.Print(Localization.instance.Localize("$msg_select_delete_disabled"));
						return;
					}
					SelectionTools.Delete(Selection.Instance);
					Selection.Instance.Clear();
				}
			}
		}

		private const string SnapPointsParam = "saveCurrentSnapPoints";

		private const string MarkersParam = "keepMarkers";

		public static void Init()
		{
			if (!GUIManager.IsHeadless())
			{
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new SelectionGUICommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ClearSelectionCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new CopySelectionCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new CutSelectionCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new SaveSelectionCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new DeleteSelectionCommand());
			}
		}

		public static bool CheckSelection()
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || !((Character)Player.m_localPlayer).InPlaceMode())
			{
				Console.instance.Print(Localization.instance.Localize("$msg_blueprint_select_inactive"));
				return false;
			}
			if (!Selection.Instance.Any())
			{
				Console.instance.Print(Localization.instance.Localize("$msg_blueprint_select_empty"));
				return false;
			}
			return true;
		}
	}
	internal class BlueprintCommands
	{
		private class GetLocalListCommand : ConsoleCommand
		{
			public override string Name => "bp.local";

			public override string Help => "Get the list of your local blueprints";

			public override void Run(string[] args)
			{
				BlueprintSync.GetLocalBlueprints();
				Console.instance.Print(BlueprintManager.LocalBlueprints.ToString());
			}
		}

		private class DeleteBlueprintCommand : ConsoleCommand
		{
			public override string Name => "bp.remove";

			public override string Help => "[blueprint_id] Remove a local blueprint";

			public override void Run(string[] args)
			{
				if (args.Length != 1)
				{
					Console.instance.Print("Usage: " + ((ConsoleCommand)this).Name + " [blueprint_id]\nblueprint_id: ID of the blueprint according to bp.local");
					return;
				}
				string text = args[0];
				if (BlueprintSync.RemoveLocalBlueprint(text))
				{
					Console.instance.Print("Removed blueprint " + text);
				}
			}
		}

		private class PushBlueprintCommand : ConsoleCommand
		{
			public override string Name => "bp.push";

			public override string Help => "[blueprint_id] Upload a local blueprint to the current connected server";

			public override void Run(string[] args)
			{
				if (args.Length != 1)
				{
					Console.instance.Print("Usage: " + ((ConsoleCommand)this).Name + " [blueprint_id]\nblueprint_id: ID of the blueprint according to bp.local");
					return;
				}
				string id = args[0];
				BlueprintSync.PushLocalBlueprint(id, delegate(bool success, string message)
				{
					Console.instance.Print((!success) ? ("Could not upload blueprint: " + message) : ("Blueprint " + id + " uploaded"));
				});
			}
		}

		private class GetServerListCommand : ConsoleCommand
		{
			public override string Name => "bp.server";

			public override string Help => "Get the list of the current connected servers blueprints";

			public override void Run(string[] args)
			{
				BlueprintSync.GetServerBlueprints(delegate(bool success, string message)
				{
					Console.instance.Print((!success) ? ("Could not get server list: " + message) : BlueprintManager.ServerBlueprints.ToString());
				}, args.Length == 0);
			}
		}

		private class PullBlueprintCommand : ConsoleCommand
		{
			public override string Name => "bp.pull";

			public override string Help => "[blueprint_id] Load a blueprint from the current connected server and add it to your local blueprints";

			public override void Run(string[] args)
			{
				if (args.Length != 1)
				{
					Console.instance.Print("Usage: " + ((ConsoleCommand)this).Name + " [blueprint_id]\nblueprint_id: ID of the blueprint according to bp.server");
					return;
				}
				string id = args[0];
				BlueprintSync.GetServerBlueprints(delegate(bool success, string message)
				{
					if (!success)
					{
						Console.instance.Print("Could not load blueprint: " + message);
					}
					else if (BlueprintSync.SaveServerBlueprint(id))
					{
						Console.instance.Print("Loaded blueprint " + id + " from server");
					}
				});
			}
		}

		private class ThumbnailBlueprintCommand : ConsoleCommand
		{
			public override string Name => "bp.thumbnail";

			public override string Help => "[blueprint_id] ([rotation]) Create a new thumbnail for a blueprint from the actual blueprint data";

			public override void Run(string[] args)
			{
				if (args.Length < 1 || string.IsNullOrWhiteSpace(args[0]))
				{
					Console.instance.Print("Usage: " + ((ConsoleCommand)this).Name + " [blueprint_id] ([rotation])\nblueprint_id: ID of the blueprint according to bp.local\nrotation: Rotation on the Y-Axis in degrees (default: 0)");
					return;
				}
				string text = args[0];
				if (!BlueprintManager.LocalBlueprints.TryGetValue(text, out var value))
				{
					Console.instance.Print("Blueprint " + text + " not found");
					return;
				}
				int additionalRotation = 0;
				if (args.Length > 1 && int.TryParse(args[1], out var result))
				{
					additionalRotation = result;
				}
				bool flag = value.CreateThumbnail(additionalRotation);
				Console.instance.Print(flag ? ("Created thumbnail for " + text) : ("Could not create thumbnail for " + text));
			}

			public override List<string> CommandOptionList()
			{
				return BlueprintManager.LocalBlueprints.Keys.ToList();
			}
		}

		private class ThumbnailAllCommand : ConsoleCommand
		{
			public override string Name => "bp.regenthumbnails";

			public override string Help => "Create a new thumbnail for all local blueprints";

			public override void Run(string[] args)
			{
				((MonoBehaviour)PlanBuildPlugin.Instance).StartCoroutine(RegenAll());
				static IEnumerator RegenAll()
				{
					foreach (Blueprint bp in BlueprintManager.LocalBlueprints.Values)
					{
						yield return null;
						bp.CreateThumbnail();
					}
					Console.instance.Print("Thumbnails regenerated");
				}
			}
		}

		private class UndoBlueprintCommand : ConsoleCommand
		{
			public override string Name => "bp.undo";

			public override string Help => "Undo your last rune action (build, delete or terrain)";

			public override void Run(string[] args)
			{
				UndoManager.Instance.Undo(Config.BlueprintUndoQueueNameConfig.Value);
			}
		}

		private class RedoBlueprintCommand : ConsoleCommand
		{
			public override string Name => "bp.redo";

			public override string Help => "Redo your last undone rune action (build, delete or terrain)";

			public override void Run(string[] args)
			{
				UndoManager.Instance.Redo(Config.BlueprintUndoQueueNameConfig.Value);
			}
		}

		private class ClearClipboardCommand : ConsoleCommand
		{
			public override string Name => "bp.clearclipboard";

			public override string Help => "Clear the clipboard category of all saved blueprints";

			public override void Run(string[] args)
			{
				bool flag = BlueprintManager.ClearClipboard();
				Console.instance.Print(flag ? "Clipboard cleared" : "Clipboard is empty");
			}
		}

		public static void Init()
		{
			if (!GUIManager.IsHeadless())
			{
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new GetLocalListCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new DeleteBlueprintCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new PushBlueprintCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new GetServerListCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new PullBlueprintCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ThumbnailBlueprintCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ThumbnailAllCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new UndoBlueprintCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new RedoBlueprintCommand());
				CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ClearClipboardCommand());
			}
		}
	}
	internal class BlueprintDictionary : Dictionary<string, Blueprint>
	{
		public static BlueprintDictionary FromZPackage(ZPackage zpkg)
		{
			Logger.LogDebug((object)"Deserializing blueprint list from ZPackage");
			BlueprintDictionary blueprintDictionary = new BlueprintDictionary();
			int num = zpkg.ReadInt();
			while (num > 0)
			{
				Blueprint blueprint = Blueprint.FromZPackage(zpkg.ReadPackage());
				blueprintDictionary.Add(blueprint.ID, blueprint);
				num--;
				Logger.LogDebug((object)blueprint.ID);
			}
			return blueprintDictionary;
		}

		public ZPackage ToZPackage()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			Logger.LogDebug((object)"Serializing blueprint list to ZPackage");
			ZPackage val = new ZPackage();
			val.Write(base.Count);
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<string, Blueprint> current = enumerator.Current;
				Logger.LogDebug((object)(current.Key ?? ""));
				val.Write(current.Value.ToZPackage());
			}
			return val;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(string.Format("{0} blueprint{1}", base.Count, (base.Count == 1) ? "" : "s"));
			foreach (KeyValuePair<string, Blueprint> item in this.OrderBy((KeyValuePair<string, Blueprint> x) => x.Key))
			{
				stringBuilder.AppendLine(item.Value.ToString());
			}
			return stringBuilder.ToString();
		}
	}
	internal static class BlueprintManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_Shutdown <>9__9_0;

			public static Func<Blueprint, bool> <>9__9_2;

			public static Func<Blueprint, string> <>9__18_0;

			public static Func<Piece, string> <>9__18_1;

			public static Func<Piece, bool> <>9__18_2;

			internal void <Init>b__9_0(orig_Shutdown orig, ZNetScene self)
			{
				orig.Invoke(self);
				TemporaryBlueprints.Clear();
				Selection.Instance.Clear();
			}

			internal bool <Init>b__9_2(Blueprint x)
			{
				return x.GhostActiveTime > 0f;
			}

			internal string <PieceTable_UpdateAvailable>b__18_0(Blueprint x)
			{
				return x.Category;
			}

			internal string <PieceTable_UpdateAvailable>b__18_1(Piece x)
			{
				return x.m_name;
			}

			internal bool <PieceTable_UpdateAvailable>b__18_2(Piece x)
			{
				return !((Object)x).name.Equals("piece_bpplaceholder");
			}
		}

		public static BlueprintDictionary LocalBlueprints;

		public static BlueprintDictionary TemporaryBlueprints;

		public static BlueprintDictionary ServerBlueprints;

		public const float HighlightTimeout = 0.5f;

		public const float GhostTimeout = 10f;

		public static Piece LastHoveredPiece;

		private static float LastHighlightTime;

		private static float OriginalPlaceDistance;

		private static GameObject OriginalTooltip;

		public static void Init()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			Logger.LogInfo((object)"Initializing BlueprintManager");
			try
			{
				LocalBlueprints = new BlueprintDictionary();
				TemporaryBlueprints = new BlueprintDictionary();
				ServerBlueprints = new BlueprintDictionary();
				Selection.Init();
				SelectionCommands.Init();
				BlueprintSync.Init();
				BlueprintCommands.Init();
				UndoManager.Instance.CreateQueue(Config.BlueprintUndoQueueNameConfig.Value, 50);
				object obj = <>c.<>9__9_0;
				if (obj == null)
				{
					hook_Shutdown val = delegate(orig_Shutdown orig, ZNetScene self)
					{
						orig.Invoke(self);
						TemporaryBlueprints.Clear();
						Selection.Instance.Clear();
					};
					<>c.<>9__9_0 = val;
					obj = (object)val;
				}
				ZNetScene.Shutdown += (hook_Shutdown)obj;
				Player.OnSpawned += new hook_OnSpawned(Player_OnSpawned);
				PieceTable.UpdateAvailable += new hook_UpdateAvailable(PieceTable_UpdateAvailable);
				Player.SetupPlacementGhost += new hook_SetupPlacementGhost(Player_SetupPlacementGhost);
				Player.UpdatePlacementGhost += new hook_UpdatePlacementGhost(Player_UpdatePlacementGhost);
				Player.PieceRayTest += new hook_PieceRayTest(Player_PieceRayTest);
				Humanoid.EquipItem += new hook_EquipItem(Humanoid_EquipItem);
				Humanoid.UnequipItem += new hook_UnequipItem(Humanoid_UnequipItem);
				Hud.TogglePieceSelection += new hook_TogglePieceSelection(Hud_TogglePieceSelection);
				Piece.Awake += new hook_Awake(Piece_Awake);
				Piece.OnDestroy += new hook_OnDestroy(Piece_OnDestroy);
				GUIManager.OnCustomGUIAvailable += GUIManager_OnCustomGUIAvailable;
				UITooltip.OnHoverStart += new hook_OnHoverStart(UITooltip_OnHoverStart);
				((MonoBehaviour)PlanBuildPlugin.Instance).StartCoroutine(watchdog());
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"Error caught while initializing: {arg}");
			}
			static IEnumerator watchdog()
			{
				while (true)
				{
					foreach (Blueprint item in LocalBlueprints.Values.Where((Blueprint x) => x.GhostActiveTime > 0f))
					{
						if (Time.time - item.GhostActiveTime > 10f)
						{
							item.DestroyGhost();
						}
					}
					yield return (object)new WaitForSeconds(10f);
				}
			}
		}

		public static bool CanCapture(Piece piece, bool onlyPlanned = false)
		{
			if (((Object)piece).name.StartsWith("piece_bpsnappoint") || ((Object)piece).name.StartsWith("piece_bpcenterpoint"))
			{
				return true;
			}
			if (((Object)piece).name.StartsWith("piece_blueprint"))
			{
				return false;
			}
			if (!SynchronizationManager.Instance.PlayerIsAdmin && PlanBlacklist.Contains(piece))
			{
				return false;
			}
			if (!((Object)(object)((Component)piece).GetComponent<PlanPiece>() != (Object)null))
			{
				if (!onlyPlanned)
				{
					return PlanDB.Instance.CanCreatePlan(piece);
				}
				return false;
			}
			return true;
		}

		public static List<Piece> GetPiecesInRadius(Vector3 position, float radius, bool onlyPlanned = false)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			List<Piece> list = new List<Piece>();
			foreach (Piece s_allPiece in Piece.s_allPieces)
			{
				Vector3 position2 = ((Component)s_allPiece).transform.position;
				if (Vector2.Distance(new Vector2(position.x, position.z), new Vector2(position2.x, position2.z)) <= radius && CanCapture(s_allPiece, onlyPlanned))
				{
					list.Add(s_allPiece);
				}
			}
			return list;
		}

		public static void HighlightPiecesInRadius(Vector3 startPosition, float radius, Color color, bool onlyPlanned = false)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time < LastHighlightTime + 0.5f)
			{
				return;
			}
			WearNTear self = default(WearNTear);
			foreach (Piece item in GetPiecesInRadius(startPosition, radius, onlyPlanned))
			{
				if (((Component)item).TryGetComponent<WearNTear>(ref self))
				{
					self.Highlight(color, 0.6f);
				}
			}
			LastHighlightTime = Time.time;
		}

		public static void HighlightHoveredPiece(Color color, bool onlyPlanned = false)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time < LastHighlightTime + 0.5f)
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)LastHoveredPiece))
			{
				if (onlyPlanned && !Object.op_Implicit((Object)(object)((Component)LastHoveredPiece).GetComponent<PlanPiece>()))
				{
					return;
				}
				WearNTear self = default(WearNTear);
				if (((Component)LastHoveredPiece).TryGetComponent<WearNTear>(ref self))
				{
					self.Highlight(color, 0.6f);
				}
			}
			LastHighlightTime = Time.time;
		}

		public static GameObject GetGameObject(ZDOID zdoid, bool required = false)
		{
			//IL_0005: 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)
			GameObject val = ZNetScene.instance.FindInstance(zdoid);
			if (Object.op_Implicit((Object)(object)val))
			{
				return val;
			}
			if (!required)
			{
				return null;
			}
			return ZNetScene.instance.CreateObject(ZDOMan.instance.GetZDO(zdoid));
		}

		public static bool ClearClipboard()
		{
			if (TemporaryBlueprints.Count == 0)
			{
				return false;
			}
			foreach (KeyValuePair<string, Blueprint> temporaryBlueprint in TemporaryBlueprints)
			{
				temporaryBlueprint.Value.DestroyBlueprint();
			}
			TemporaryBlueprints.Clear();
			Player.m_localPlayer.UpdateKnownRecipesList();
			Player.m_localPlayer.UpdateAvailablePiecesList();
			BlueprintGUI.RefreshBlueprints(BlueprintLocation.Temporary);
			return true;
		}

		public static void RegisterKnownBlueprints()
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			Logger.LogInfo((object)"Registering known blueprints");
			foreach (Blueprint value in LocalBlueprints.Values)
			{
				value.CreatePiece();
			}
			Player.m_localPlayer.UpdateKnownRecipesList();
			Player.m_localPlayer.UpdateAvailablePiecesList();
		}

		private static void Player_OnSpawned(orig_OnSpawned orig, Player self, bool spawnValkrie)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, spawnValkrie);
			if ((Object)(object)self == (Object)(object)Player.m_localPlayer)
			{
				RegisterKnownBlueprints();
				if (!Config.AllowBlueprintRune.Value && !SynchronizationManager.Instance.PlayerIsAdmin)
				{
					Player.m_localPlayer.SetBuildCategory(0);
					Player.m_localPlayer.SetSelectedPiece(new Vector2Int(9, 9));
				}
			}
		}

		private static void PieceTable_UpdateAvailable(orig_UpdateAvailable orig, PieceTable self, HashSet<string> knownRecipies, Player player, bool hideUnavailable, bool noPlacementCost)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected I4, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected I4, but got Unknown
			orig.Invoke(self, knownRecipies, player, hideUnavailable, noPlacementCost);
			if (!((Object)self).name.Equals("_BlueprintPieceTable"))
			{
				return;
			}
			foreach (IGrouping<string, Blueprint> item in from x in LocalBlueprints.Values
				group x by x.Category)
			{
				PieceCategory? pieceCategory = PieceManager.Instance.GetPieceCategory(item.Key);
				if (pieceCategory.HasValue)
				{
					List<Piece> list = new List<Piece>();
					list.Add(BlueprintAssets.PlaceholderObject.GetComponent<Piece>());
					list.AddRange((from x in self.m_availablePiecesByCategory[(int)pieceCategory.Value]
						orderby x.m_name
						where !((Object)x).name.Equals("piece_bpplaceholder")
						select x).ToList());
					self.m_availablePiecesByCategory[(int)pieceCategory.Value] = list;
				}
			}
		}

		private static void Player_SetupPlacementGhost(orig_SetupPlacementGhost orig, Player self)
		{
			if ((Object)(object)self.m_buildPieces == (Object)null)
			{
				orig.Invoke(self);
				return;
			}
			GameObject selectedPrefab = self.m_buildPieces.GetSelectedPrefab();
			if (!Object.op_Implicit((Object)(object)selectedPrefab) || !((Object)selectedPrefab).name.StartsWith("piece_blueprint"))
			{
				orig.Invoke(self);
				return;
			}
			string key = ((Object)selectedPrefab).name.Substring("piece_blueprint".Length + 1);
			if (LocalBlueprints.TryGetValue(key, out var value))
			{
				value.InstantiateGhost();
			}
			orig.Invoke(self);
		}

		private static void Player_UpdatePlacementGhost(orig_UpdatePlacementGhost orig, Player self, bool flashGuardStone)
		{
			if ((Object)(object)self.m_buildPieces == (Object)null)
			{
				orig.Invoke(self, flashGuardStone);
				return;
			}
			GameObject selectedPrefab = self.m_buildPieces.GetSelectedPrefab();
			if (!Object.op_Implicit((Object)(object)selectedPrefab) || !((Object)selectedPrefab).name.StartsWith("piece_blueprint"))
			{
				orig.Invoke(self, flashGuardStone);
				return;
			}
			string key = ((Object)selectedPrefab).name.Substring("piece_blueprint".Length + 1);
			if (LocalBlueprints.TryGetValue(key, out var value))
			{
				value.GhostActiveTime = Time.time;
			}
			orig.Invoke(self, flashGuardStone);
		}

		private static bool Player_PieceRayTest(orig_PieceRayTest orig, Player self, out Vector3 point, out Vector3 normal, out Piece piece, out Heightmap heightmap, out Collider waterSurface, bool water)
		{
			bool result = orig.Invoke(self, ref point, ref normal, ref piece, ref heightmap, ref waterSurface, water);
			LastHoveredPiece = piece;
			return result;
		}

		private static bool Humanoid_EquipItem(orig_EquipItem orig, Humanoid self, ItemData item, bool triggerEquipEffects)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			bool flag = orig.Invoke(self, item, triggerEquipEffects);
			if (flag && ((Humanoid)(Player.m_localPlayer?)).m_rightItem?.m_shared.m_name == "$item_blueprintrune")
			{
				OriginalPlaceDistance = Math.Max(Player.m_localPlayer.m_maxPlaceDistance, 8f);
				Player.m_localPlayer.m_maxPlaceDistance = Config.RayDistanceConfig.Value;
				Transform val = Hud.instance.m_buildHud.transform.Find("SelectedInfo/selected_piece/piece_description");
				RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
				if (val2 != null)
				{
					val2.pivot = new Vector2(0.5f, 1f);
					val2.anchoredPosition = new Vector2(val2.anchoredPosition.x, -30f);
					val2.sizeDelta = new Vector2(val2.sizeDelta.x, 110f);
				}
				if (!Config.AllowBlueprintRune.Value && !SynchronizationManager.Instance.PlayerIsAdmin)
				{
					if (Hud.IsPieceSelectionVisible())
					{
						Hud.HidePieceSelection();
					}
					Player.m_localPlayer.SetBuildCategory(0);
					Player.m_localPlayer.SetSelectedPiece(new Vector2Int(9, 9));
				}
			}
			return flag;
		}

		private static void Humanoid_UnequipItem(orig_UnequipItem orig, Humanoid self, ItemData item, bool triggerEquipEffects)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, item, triggerEquipEffects);
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && item != null && item.m_shared.m_name == "$item_blueprintrune")
			{
				Player.m_localPlayer.m_maxPlaceDistance = OriginalPlaceDistance;
				Transform val = Hud.instance.m_buildHud.transform.Find("SelectedInfo/selected_piece/piece_description");
				RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
				if (val2 != null)
				{
					val2.sizeDelta = new Vector2(val2.sizeDelta.x, 36.5f);
				}
			}
		}

		private static void Hud_TogglePieceSelection(orig_TogglePieceSelection orig, Hud self)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (((Humanoid)Player.m_localPlayer).m_rightItem?.m_shared.m_name == "$item_blueprintrune" && !Hud.IsPieceSelectionVisible() && !Config.AllowBlueprintRune.Value && !SynchronizationManager.Instance.PlayerIsAdmin)
			{
				MessageHud.instance.ShowMessage((MessageType)2, "$msg_blueprintrune_disabled", 0, (Sprite)null, false, true);
				Player.m_localPlayer.SetBuildCategory(0);
				Player.m_localPlayer.SetSelectedPiece(new Vector2Int(9, 9));
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private static void Piece_Awake(orig_Awake orig, Piece self)
		{
			orig.Invoke(self);
			Selection.Instance.OnPieceAwake(self);
		}

		private static void Piece_OnDestroy(orig_OnDestroy orig, Piece self)
		{
			orig.Invoke(self);
			Selection.Instance.OnPieceUnload(self);
		}

		private static void GUIManager_OnCustomGUIAvailable()
		{
			OriginalTooltip = PrefabManager.Instance.GetPrefab("Tooltip");
		}

		private static void UITooltip_OnHoverStart(orig_OnHoverStart orig, UITooltip self, GameObject go)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)BlueprintAssets.BlueprintTooltip) && Hud.IsPieceSelectionVisible())
			{
				Piece val = Hud.instance.m_hoveredPiece;
				if (ZInput.IsGamepadActive() && !ZInput.IsMouseActive())
				{
					val = Player.m_localPlayer.GetSelectedPiece();
				}
				if (Config.TooltipEnabledConfig.Value && Object.op_Implicit((Object)(object)val) && ((Object)val).name.StartsWith("piece_blueprint") && LocalBlueprints.TryGetValue(((Object)val).name.Substring("piece_blueprint".Length + 1), out var value) && (Object)(object)value.Thumbnail != (Object)null)
				{
					self.m_tooltipPrefab = BlueprintAssets.BlueprintTooltip;
					orig.Invoke(self, go);
					((Graphic)((Component)UITooltip.m_tooltip.transform.Find("Background")).GetComponent<Image>()).color = Config.TooltipBackgroundConfig.Value;
					((Component)UITooltip.m_tooltip.transform.Find("Background/BPImage")).GetComponent<Image>().sprite = Sprite.Create(value.Thumbnail, new Rect(0f, 0f, (float)((Texture)value.Thumbnail).width, (float)((Texture)value.Thumbnail).height), Vector2.zero);
					((Component)UITooltip.m_tooltip.transform.Find("Background/BPText")).GetComponent<Text>().text = value.Name;
				}
				else
				{
					self.m_tooltipPrefab = OriginalTooltip;
					orig.Invoke(self, go);
				}
			}
			else
			{
				orig.Invoke(self, go);
			}
		}
	}
	internal class BlueprintAssets
	{
		public const string BlueprintTooltipName = "BlueprintTooltip";

		public static GameObject BlueprintTooltip;

		public const string BlueprintGUIName = "BlueprintGUI";

		public const string SelectionGUIName = "SelectionGUI";

		public const string SelectionSaveGUIName = "SelectionSaveGUI";

		public const string TerrainModGUIName = "TerrainModGUI";

		public const string StandingBlueprintRuneName = "piece_world_standing_blueprint_rune";

		public const string BlueprintRuneStackName = "piece_world_blueprint_rune_stack";

		public const string BlueprintRuneName = "BlueprintRune";

		public const string BlueprintRuneItemName = "$item_blueprintrune";

		public const string PieceTableName = "_BlueprintPieceTable";

		public const string CategoryTools = "Tools";

		public const string CategoryClipboard = "Clipboard";

		public const string CategoryBlueprints = "Blueprints";

		public const string PiecePlaceholderName = "piece_bpplaceholder";

		public static GameObject PlaceholderObject;

		public const string PieceSnapPointName = "piece_bpsnappoint";

		public const string PieceSnapPointInstanceName = "piece_bpsnappointinstance";

		public const string PieceCenterPointName = "piece_bpcenterpoint";

		public const string PieceCenterPointInstanceName = "piece_bpcenterpointinstance";

		public const string PieceTerrainModName = "piece_bpterrainmod";

		public const string PieceTerrainModInstanceName = "piece_bpterrainmodinstance";

		public const string PieceCaptureName = "piece_bpcapture";

		public const string PieceSelectAddName = "piece_bpselectadd";

		public const string PieceSelectRemoveName = "piece_bpselectremove";

		public const string PieceSelectEditName = "piece_bpselectedit";

		public const string PieceDeletePlansName = "piece_bpdelete";

		public const string PieceDeleteObjectsName = "piece_bpobjects";

		public const string PieceTerrainName = "piece_bpterrain";

		public const string PiecePaintName = "piece_bppaint";

		public static void Load(AssetBundle assetBundle)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Expected O, but got Unknown
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Expected O, but got Unknown
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Expected O, but got Unknown
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Expected O, but got Unknown
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ac: Expected O, but got Unknown
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Expected O, but got Unknown
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05eb: Expected O, but got Unknown
			GameObject[] array = assetBundle.LoadAllAssets<GameObject>();
			Dictionary<string, GameObject> dictionary = new Dictionary<string, GameObject>(array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				dictionary.Add(((Object)array[i]).name, array[i]);
			}
			BlueprintGUI.Init(dictionary["BlueprintGUI"]);
			SelectionGUI.Init(dictionary["SelectionGUI"]);
			SelectionSaveGUI.Init(dictionary["SelectionSaveGUI"]);
			TerrainModGUI.Init(dictionary["TerrainModGUI"]);
			BlueprintTooltip = dictionary["BlueprintTooltip"];
			GUIManager.OnCustomGUIAvailable += InitTooltipGUI;
			GUIManager.OnCustomGUIAvailable += CreateCustomKeyHints;
			string[] array2 = new string[2] { "piece_world_standing_blueprint_rune", "piece_world_blueprint_rune_stack" };
			foreach (string key in array2)
			{
				GameObject obj = dictionary[key];
				PieceConfig val = new PieceConfig();
				val.PieceTable = "Hammer";
				val.Requirements = (RequirementConfig[])(object)new RequirementConfig[1]
				{
					new RequirementConfig
					{
						Item = "Stone",
						Amount = 5,
						Recover = true
					}
				};
				CustomPiece val2 = new CustomPiece(obj, false, val);
				val2.PiecePrefab.AddComponent<WorldBlueprintRune>();
				val2.FixReference = true;
				PieceManager.Instance.AddPiece(val2);
			}
			PieceTableConfig val3 = new PieceTableConfig();
			val3.CanRemovePieces = false;
			val3.UseCategories = false;
			val3.UseCustomCategories = true;
			val3.CustomCategories = new string[3] { "Tools", "Clipboard", "Blueprints" };
			CustomPieceTable val4 = new CustomPieceTable("_BlueprintPieceTable", val3);
			PieceManager.Instance.AddPieceTable(val4);
			GameObject obj2 = dictionary["BlueprintRune"];
			ItemConfig val5 = new ItemConfig();
			val5.Amount = 1;
			val5.Requirements = (RequirementConfig[])(object)new RequirementConfig[1]
			{
				new RequirementConfig
				{
					Item = "Stone",
					Amount = 1
				}
			};
			CustomItem val6 = new CustomItem(obj2, false, val5);
			val6.ItemDrop.m_itemData.m_shared.m_buildPieces = val4.PieceTable;
			ItemManager.Instance.AddItem(val6);
			GameObject val7 = dictionary["piece_blueprint"];
			PrefabManager.Instance.AddPrefab(val7);
			ZNetView.m_forceDisableInit = true;
			PlaceholderObject = Object.Instantiate<GameObject>(val7);
			ZNetView.m_forceDisableInit = false;
			((Object)PlaceholderObject).name = "piece_bpplaceholder";
			PrefabManager.Instance.AddPrefab(PlaceholderObject);
			Piece component = PlaceholderObject.GetComponent<Piece>();
			component.m_name = "$piece_bpplaceholder";
			component.m_enabled = true;
			component.m_description = "$piece_bpplaceholder_desc";
			component.m_icon = Sprite.Create(new Texture2D(1, 1), Rect.zero, Vector2.zero);
			string[] array3 = new string[11]
			{
				"piece_bpcapture", "piece_bpselectadd", "piece_bpselectremove", "piece_bpselectedit", "piece_bpsnappoint", "piece_bpcenterpoint", "piece_bpterrainmod", "piece_bpdelete", "piece_bpterrain", "piece_bpobjects",
				"piece_bppaint"
			};
			foreach (string text in array3)
			{
				CustomPiece val8 = new CustomPiece(dictionary[text], false, new PieceConfig
				{
					PieceTable = "_BlueprintPieceTable",
					Category = "Tools"
				});
				PieceManager.Instance.AddPiece(val8);
				switch (text)
				{
				case "piece_bpcapture":
					dictionary[text].AddComponent<CaptureComponent>();
					break;
				case "piece_bpselectadd":
					dictionary[text].AddComponent<SelectAddComponent>();
					break;
				case "piece_bpselectremove":
					dictionary[text].AddComponent<SelectRemoveComponent>();
					break;
				case "piece_bpselectedit":
					dictionary[text].AddComponent<SelectEditComponent>();
					break;
				case "piece_bpsnappoint":
				{
					MarkerComponent markerComponent3 = dictionary[text].AddComponent<MarkerComponent>();
					markerComponent3.PieceInstanceName = "piece_bpsnappointinstance";
					CustomPrefab val11 = new CustomPrefab(dictionary["piece_bpsnappointinstance"], false);
					PrefabManager.Instance.AddPrefab(val11);
					break;
				}
				case "piece_bpcenterpoint":
				{
					MarkerComponent markerComponent2 = dictionary[text].AddComponent<MarkerComponent>();
					markerComponent2.PieceInstanceName = "piece_bpcenterpointinstance";
					CustomPrefab val10 = new CustomPrefab(dictionary["piece_bpcenterpointinstance"], false);
					PrefabManager.Instance.AddPrefab(val10);
					break;
				}
				case "piece_bpterrainmod":
				{
					MarkerComponent markerComponent = dictionary[text].AddComponent<MarkerComponent>();
					markerComponent.PieceInstanceName = "piece_bpterrainmodinstance";
					CustomPrefab val9 = new CustomPrefab(dictionary["piece_bpterrainmodinstance"], false);
					PrefabManager.Instance.AddPrefab(val9);
					dictionary["piece_bpterrainmodinstance"].AddComponent<TerrainModMarker>();
					dictionary["piece_bpterrainmodinstance"].AddComponent<ShapedProjector>();
					break;
				}
				case "piece_bpdelete":
					dictionary[text].AddComponent<DeletePlansComponent>();
					break;
				case "piece_bpobjects":
					dictionary[text].AddComponent<DeleteObjectsComponent>();
					break;
				case "piece_bpterrain":
					dictionary[text].AddComponent<TerrainComponent>();
					break;
				case "piece_bppaint":
					dictionary[text].AddComponent<PaintComponent>();
					break;
				}
			}
			static void InitTooltipGUI()
			{
				((Component)BlueprintTooltip.transform.Find("Background").Find("BPText")).GetComponent<Text>().font = GUIManager.Instance.AveriaSerif;
				GUIManager.OnCustomGUIAvailable -= InitTooltipGUI;
			}
		}

		private static void CreateCustomKeyHints()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Expected O, but got Unknown
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Expected O, but got Unknown
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Expected O, but got Unknown
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: 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_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected O, but got Unknown
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Expected O, but got Unknown
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Expected O, but got Unknown
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Expected O, but got Unknown
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Expected O, but got Unknown
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Expected O, but got Unknown
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Expected O, but got Unknown
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Expected O, but got Unknown
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Expected O, but got Unknown
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0466: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Expected O, but got Unknown
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a0: Expected O, but got Unknown
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Expected O, but got Unknown
			//IL_04da: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Expected O, but got Unknown
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Expected O, but got Unknown
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_052d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0539: Expected O, but got Unknown
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Unknown result type (might be due to invalid IL or missing references)
			//IL_055b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0567: Expected O, but got Unknown
			//IL_0569: Unknown result type (might be due to invalid IL or missing references)
			//IL_056e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0579: Unknown result type (might be due to invalid IL or missing references)
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Expected O, but got Unknown
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a7: Expected O, but got Unknown
			//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e2: Expected O, but got Unknown
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0600: Expected O, but got Unknown
			//IL_0602: Unknown result type (might be due to invalid IL or missing references)
			//IL_0607: Unknown result type (might be due to invalid IL or missing references)
			//IL_0617: Unknown result type (might be due to invalid IL or missing references)
			//IL_0622: Unknown result type (might be due to invalid IL or missing references)
			//IL_062e: Expected O, but got Unknown
			//IL_0630: Unknown result type (might be due to invalid IL or missing references)
			//IL_0635: Unknown result type (might be due to invalid IL or missing references)
			//IL_0640: Unknown result type (might be due to invalid IL or missing references)
			//IL_064b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Expected O, but got Unknown
			//IL_0668: Unknown result type (might be due to invalid IL or missing references)
			//IL_066e: Expected O, but got Unknown
			//IL_068d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0692: Unknown result type (might be due to invalid IL or missing references)
			//IL_069d: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a9: Expected O, but got Unknown
			//IL_06ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d7: Expected O, but got Unknown
			//IL_06d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06de: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0705: Expected O, but got Unknown
			//IL_0716: Unknown result type (might be due to invalid IL or missing references)
			//IL_071c: Expected O, but got Unknown
			//IL_073b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0740: Unknown result type (might be due to invalid IL or missing references)
			//IL_074b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0757: Expected O, but got Unknown
			//IL_0759: Unknown result type (might be due to invalid IL or missing references)
			//IL_075e: Unknown result type (might be due to invalid IL or missing references)
			//IL_076e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0779: Unknown result type (might be due to invalid IL or missing references)
			//IL_0785: Expected O, but got Unknown
			//IL_0787: Unknown result type (might be due to invalid IL or missing references)
			//IL_078c: Unknown result type (might be due to invalid IL or missing references)
			//IL_079c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b3: Expected O, but got Unknown
			//IL_07b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e1: Expected O, but got Unknown
			//IL_07e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0803: Unknown result type (might be due to invalid IL or missing references)
			//IL_080f: Expected O, but got Unknown
			//IL_0811: Unknown result type (might be due to invalid IL or missing references)
			//IL_0816: Unknown result type (might be due to invalid IL or missing references)
			//IL_0821: Unknown result type (might be due to invalid IL or missing references)
			//IL_082c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0838: Expected O, but got Unknown
			//IL_0849: Unknown result type (might be due to invalid IL or missing references)
			//IL_084f: Expected O, but got Unknown
			//IL_086e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0873: Unknown result type (might be due to invalid IL or missing references)
			//IL_087e: Unknown result type (might be due to invalid IL or missing references)
			//IL_088a: Expected O, but got Unknown
			//IL_088c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0891: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b8: Expected O, but got Unknown
			//IL_08ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_08bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_08da: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e6: Expected O, but got Unknown
			//IL_08e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0908: Unknown result type (might be due to invalid IL or missing references)
			//IL_0914: Expected O, but got Unknown
			//IL_0916: Unknown result type (might be due to invalid IL or missing references)
			//IL_091b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0926: Unknown result type (might be due to invalid IL or missing references)
			//IL_0931: Unknown result type (might be due to invalid IL or missing references)
			//IL_093d: Expected O, but got Unknown
			//IL_094e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0954: Expected O, but got Unknown
			//IL_0973: Unknown result type (might be due to invalid IL or missing references)
			//IL_0978: Unknown result type (might be due to invalid IL or missing references)
			//IL_0983: Unknown result type (might be due to invalid IL or missing references)
			//IL_098f: Expected O, but got Unknown
			//IL_0991: Unknown result type (might be due to invalid IL or missing references)
			//IL_0996: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09bd: Expected O, but got Unknown
			//IL_09bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09df: Unknown result type (might be due to invalid IL or missing references)
			//IL_09eb: Expected O, but got Unknown
			//IL_09ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a02: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a19: Expected O, but got Unknown
			//IL_0a1b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a30: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a47: Expected O, but got Unknown
			//IL_0a49: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a59: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a64: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a70: Expected O, but got Unknown
			KeyHintManager instance = KeyHintManager.Instance;
			KeyHintConfig val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[1]
			{
				new ButtonConfig
				{
					Name = "BuildMenu",
					HintToken = "$hud_buildmenu"
				}
			};
			instance.AddKeyHint(val);
			KeyHintManager instance2 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bpcapture";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[5]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_bpcapture"
				},
				new ButtonConfig
				{
					Name = Config.AltModifierButton.Name,
					Config = Config.AltModifierConfig,
					HintToken = "$hud_bpcapture_vanilla"
				},
				new ButtonConfig
				{
					Name = Config.CtrlModifierButton.Name,
					Config = Config.CtrlModifierConfig,
					HintToken = "$hud_bpcapture_highlight"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				},
				new ButtonConfig
				{
					Name = "Scroll",
					Axis = "Mouse ScrollWheel",
					HintToken = "$hud_bpradius"
				}
			};
			instance2.AddKeyHint(val);
			KeyHintManager instance3 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bpselectadd";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[6]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_blueprint_select_add"
				},
				new ButtonConfig
				{
					Name = Config.ToggleButton.Name,
					Config = Config.ToggleConfig,
					HintToken = "$hud_blueprint_select_add_switch"
				},
				new ButtonConfig
				{
					Name = Config.AltModifierButton.Name,
					Config = Config.AltModifierConfig,
					HintToken = "$hud_blueprint_select_add_connected"
				},
				new ButtonConfig
				{
					Name = Config.CtrlModifierButton.Name,
					Config = Config.CtrlModifierConfig,
					HintToken = "$hud_blueprint_select_add_radius"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_blueprint_select_add_between"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				}
			};
			instance3.AddKeyHint(val);
			KeyHintManager instance4 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bpselectremove";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[6]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_blueprint_select_remove"
				},
				new ButtonConfig
				{
					Name = Config.ToggleButton.Name,
					Config = Config.ToggleConfig,
					HintToken = "$hud_blueprint_select_remove_switch"
				},
				new ButtonConfig
				{
					Name = Config.AltModifierButton.Name,
					Config = Config.AltModifierConfig,
					HintToken = "$hud_blueprint_select_remove_connected"
				},
				new ButtonConfig
				{
					Name = Config.CtrlModifierButton.Name,
					Config = Config.CtrlModifierConfig,
					HintToken = "$hud_blueprint_select_remove_radius"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_blueprint_select_clear"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				}
			};
			instance4.AddKeyHint(val);
			KeyHintManager instance5 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bpselectedit";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[1]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_blueprint_select_edit"
				}
			};
			instance5.AddKeyHint(val);
			KeyHintManager instance6 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bpsnappoint";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[4]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_bpsnappoint"
				},
				new ButtonConfig
				{
					Name = "Remove",
					HintToken = "$hud_bpremovemarker"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				},
				new ButtonConfig
				{
					Name = "Scroll",
					Axis = "Mouse ScrollWheel",
					HintToken = "$hud_bprotate"
				}
			};
			instance6.AddKeyHint(val);
			KeyHintManager instance7 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bpcenterpoint";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[4]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_bpcenterpoint"
				},
				new ButtonConfig
				{
					Name = "Remove",
					HintToken = "$hud_bpremovemarker"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				},
				new ButtonConfig
				{
					Name = "Scroll",
					Axis = "Mouse ScrollWheel",
					HintToken = "$hud_bprotate"
				}
			};
			instance7.AddKeyHint(val);
			KeyHintManager instance8 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bpterrainmod";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[4]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_bpterrainmod"
				},
				new ButtonConfig
				{
					Name = "Remove",
					HintToken = "$hud_bpremovemarker"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				},
				new ButtonConfig
				{
					Name = "Scroll",
					Axis = "Mouse ScrollWheel",
					HintToken = "$hud_bprotate"
				}
			};
			instance8.AddKeyHint(val);
			KeyHintManager instance9 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bpdelete";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[3]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_bpdelete"
				},
				new ButtonConfig
				{
					Name = Config.CtrlModifierButton.Name,
					Config = Config.CtrlModifierConfig,
					HintToken = "$hud_bpdelete_radius"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				}
			};
			instance9.AddKeyHint(val);
			KeyHintManager instance10 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bpterrain";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[6]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_bpterrain_flatten"
				},
				new ButtonConfig
				{
					Name = Config.ToggleButton.Name,
					Config = Config.ToggleConfig,
					HintToken = "$hud_bpterrain_marker"
				},
				new ButtonConfig
				{
					Name = Config.AltModifierButton.Name,
					Config = Config.AltModifierConfig,
					HintToken = "$hud_bpterrain_alt"
				},
				new ButtonConfig
				{
					Name = Config.CtrlModifierButton.Name,
					Config = Config.CtrlModifierConfig,
					HintToken = "$hud_bpterrain_ctrl"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				},
				new ButtonConfig
				{
					Name = "Scroll",
					Axis = "Mouse ScrollWheel",
					HintToken = "$hud_bpradius"
				}
			};
			instance10.AddKeyHint(val);
			KeyHintManager instance11 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bpobjects";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[5]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_bpobjects_deleteveg"
				},
				new ButtonConfig
				{
					Name = Config.CtrlModifierButton.Name,
					Config = Config.CtrlModifierConfig,
					HintToken = "$hud_bpobjects_deletepieces"
				},
				new ButtonConfig
				{
					Name = Config.AltModifierButton.Name,
					Config = Config.AltModifierConfig,
					HintToken = "$hud_bpobjects_deleteall"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				},
				new ButtonConfig
				{
					Name = "Scroll",
					Axis = "Mouse ScrollWheel",
					HintToken = "$hud_bpradius"
				}
			};
			instance11.AddKeyHint(val);
			KeyHintManager instance12 = KeyHintManager.Instance;
			val = new KeyHintConfig();
			val.Item = "BlueprintRune";
			val.Piece = "piece_bppaint";
			val.ButtonConfigs = (ButtonConfig[])(object)new ButtonConfig[6]
			{
				new ButtonConfig
				{
					Name = "Attack",
					HintToken = "$hud_bppaint_reset"
				},
				new ButtonConfig
				{
					Name = Config.ToggleButton.Name,
					Config = Config.ToggleConfig,
					HintToken = "$hud_bppaint_marker"
				},
				new ButtonConfig
				{
					Name = Config.AltModifierButton.Name,
					Config = Config.AltModifierConfig,
					HintToken = "$hud_bppaint_alt"
				},
				new ButtonConfig
				{
					Name = Config.CtrlModifierButton.Name,
					Config = Config.CtrlModifierConfig,
					HintToken = "$hud_bppaint_ctrl"
				},
				new ButtonConfig
				{
					Name = Config.ShiftModifierButton.Name,
					Config = Config.ShiftModifierConfig,
					HintToken = "$hud_bpcamera"
				},
				new ButtonConfig
				{
					Name = "Scroll",
					Axis = "Mouse ScrollWheel",
					HintToken = "$hud_bpradius"
				}
			};
			instance12.AddKeyHint(val);
			GUIManager.OnCustomGUIAvailable -= CreateCustomKeyHints;
		}
	}
	internal static class BlueprintSync
	{
		private static Action<bool, string> OnAnswerReceived;

		private static CustomRPC GetListRPC;

		private static CustomRPC PushBlueprintRPC;

		private static CustomRPC RemoveServerBlueprintRPC;

		public static void Init()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_002c: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0058: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_0084: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			GetLocalBlueprints();
			GetListRPC = NetworkManager.Instance.AddRPC("GetListRPC", new CoroutineHandler(GetListRPC_OnServerReceive), new CoroutineHandler(GetListRPC_OnClientReceive));
			PushBlueprintRPC = NetworkManager.Instance.AddRPC("PushBlueprintRPC", new CoroutineHandler(PushBlueprintRPC_OnServerReceive), new CoroutineHandler(PushBlueprintRPC_OnClientReceive));
			RemoveServerBlueprintRPC = NetworkManager.Instance.AddRPC("RemoveServerBlueprintRPC", new CoroutineHandler(RemoveServerBlueprintRPC_OnServerReceive), new CoroutineHandler(RemoveServerBlueprintRPC_OnClientReceive));
			ZNet.OnDestroy += new hook_OnDestroy(ResetServerBlueprints);
		}

		internal static void GetLocalBlueprints()
		{
			Logger.LogInfo((object)"Loading known blueprints");
			if (!Directory.Exists(Config.BlueprintSaveDirectoryConfig.Value))
			{
				Directory.CreateDirectory(Config.BlueprintSaveDirectoryConfig.Value);
			}
			List<string> list = new List<string>();
			list.AddRange(Directory.EnumerateFiles(Config.BlueprintSearchDirectoryConfig.Value, "*.blueprint", SearchOption.AllDirectories));
			list.AddRange(Directory.EnumerateFiles(Config.BlueprintSearchDirectoryConfig.Value, "*.vbuild", SearchOption.AllDirectories));
			list = list.Select((string absolute) => absolute.Replace(Paths.BepInExRootPath, null)).ToList();
			foreach (string item in list)
			{
				try
				{
					Blueprint blueprint = Blueprint.FromFile(item);
					if (BlueprintManager.LocalBlueprints.ContainsKey(blueprint.ID))
					{
						throw new Exception("Blueprint ID " + blueprint.ID + " already exists");
					}
					BlueprintManager.LocalBlueprints.Add(blueprint.ID, blueprint);
				}
				catch (Exception arg)
				{
					Logger.LogWarning((object)$"Could not load blueprint {item}: {arg}");
				}
			}
			BlueprintManager.RegisterKnownBlueprints();
			BlueprintGUI.RefreshBlueprints(BlueprintLocation.Local);
		}

		internal static void GetServerBlueprints(Action<bool, string> callback, bool useCache = true)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			if (!Config.AllowServerBlueprints.Value)
			{
				callback?.Invoke(arg1: false, LocalizationManager.Instance.TryTranslate("$msg_bpmarket_server_disabled"));
			}
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer() && (int)ZNet.m_connectionStatus == 2)
			{
				if (useCache && BlueprintManager.ServerBlueprints.Any())
				{
					Logger.LogMessage((object)"Getting server blueprint list from cache");
					callback?.Invoke(arg1: true, string.Empty);
				}
				else
				{
					Logger.LogMessage((object)"Requesting server blueprint list");
					OnAnswerReceived = (Action<bool, string>)Delegate.Combine(OnAnswerReceived, callback);
					GetListRPC.Initiate();
				}
			}
			else
			{
				callback?.Invoke(arg1: false, LocalizationManager.Instance.TryTranslate("$msg_bpmarket_notconnected"));
			}
		}

		private static IEnumerator GetListRPC_OnServerReceive(long sender, ZPackage pkg)
		{
			if (Config.AllowServerBlueprints.Value)
			{
				Logger.LogDebug((object)$"Sending blueprint data to peer #{sender}");
				GetLocalBlueprints();
				GetListRPC.SendPackage(sender, BlueprintManager.LocalBlueprints.ToZPackage());
			}
			yield break;
		}

		private static IEnumerator GetListRPC_OnClientReceive(long sender, ZPackage pkg)
		{
			if (sender != ZNet.instance.GetServerPeer().m_uid || !Config.AllowServerBlueprints.Value)
			{
				yield break;
			}
			Logger.LogDebug((object)"Received blueprints from server");
			bool arg = true;
			string arg2 = string.Empty;
			try
			{
				BlueprintManager.ServerBlueprints.Clear();
				BlueprintManager.ServerBlueprints = BlueprintDictionary.FromZPackage(pkg);
				BlueprintGUI.RefreshBlueprints(BlueprintLocation.Server);
			}
			catch (Exception ex)
			{
				arg = false;
				arg2 = ex.Message;
			}
			finally
			{
				OnAnswerReceived?.Invoke(arg, arg2);
				OnAnswerReceived = null;
			}
		}

		internal static bool SaveLocalBlueprint(string id)
		{
			if (BlueprintManager.LocalBlueprints == null)
			{
				return false;
			}
			if (!BlueprintManager.LocalBlueprints.TryGetValue(id, out var value))
			{
				return false;
			}
			Logger.LogMessage((object)("Saving local blueprint " + id));
			value.DestroyBlueprint();
			value.ToFile();
			BlueprintManager.RegisterKnownBlueprints();
			BlueprintGUI.RefreshBlueprints(BlueprintLocation.Local);
			return true;
		}

		internal static bool SaveTempBlueprint(string id, string name, string category, string description)
		{
			if (BlueprintManager.TemporaryBlueprints == null)
			{
				return false;
			}
			if (!BlueprintManager.TemporaryBlueprints.TryGetValue(id, out var value))
			{
				return false;
			}
			Logger.LogMessage((object)("Saving temporary blueprint " + id));
			string text = Blueprint.CreateIDString(name);
			Blueprint blueprint = Blueprint.FromBlob(text, value.ToBlob(includeThumbnail: true));
			blueprint.Name = name;
			blueprint.Creator = Player.m_localPlayer.GetPlayerName();
			blueprint.Category = (string.IsNullOrEmpty(category) ? "Blueprints" : category);
			blueprint.Description = description;
			blueprint.FileLocation = Path.Combine(Config.BlueprintSaveDirectoryConfig.Value, blueprint.ID + ".blueprint");
			blueprint.ThumbnailLocation = blueprint.FileLocation.Replace(".blueprint", ".png");
			if (BlueprintManager.LocalBlueprints.ContainsKey(text))
			{
				BlueprintManager.LocalBlueprints[text].DestroyBlueprint();
				BlueprintManager.LocalBlueprints.Remove(text);
			}
			blueprint.ToFile();
			blueprint.CreatePiece();
			BlueprintManager.LocalBlueprints.Add(blueprint.ID, blueprint);
			BlueprintManager.RegisterKnownBlueprints();
			BlueprintGUI.RefreshBlueprints(BlueprintLocation.Local);
			BlueprintGUI.RefreshBlueprints(BlueprintLocation.Temporary);
			return true;
		}

		internal static bool SaveServerBlueprint(string id)
		{
			if (!Config.AllowServerBlueprints.Value)
			{
				return false;
			}
			if (BlueprintManager.ServerBlueprints == null)
			{
				return false;
			}
			if (!BlueprintManager.ServerBlueprints.TryGetValue(id, out var value))
			{
				return false;
			}
			Logger.LogDebug((object)("Saving server blueprint " + id));
			if (BlueprintManager.LocalBlueprints.ContainsKey(id))
			{
				BlueprintManager.LocalBlueprints[id].DestroyBlueprint();
				BlueprintManager.LocalBlueprints.Remove(id);
			}
			value.ToFile();
			BlueprintManager.LocalBlueprints.Add(value.ID, value);
			BlueprintManager.RegisterKnownBlueprints();
			BlueprintGUI.RefreshBlueprints(BlueprintLocation.Local);
			return true;
		}

		internal static void PushLocalBlueprint(string id, Action<bool, string> callback)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			if (!Config.AllowServerBlueprints.Value)
			{
				callback?.Invoke(arg1: false, LocalizationManager.Instance.TryTranslate("$msg_bpmarket_server_disabled"));
			}
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer() && (int)ZNet.m_connectionStatus == 2)
			{
				if (BlueprintManager.LocalBlueprints.TryGetValue(id, out var value))
				{
					Logger.LogMessage((object)("Sending blueprint " + id + " to server"));
					OnAnswerReceived = (Action<bool, string>)Delegate.Combine(OnAnswerReceived, callback);
					PushBlueprintRPC.SendPackage(ZRoutedRpc.instance.GetServerPeerID(), value.ToZPackage());
				}
			}
			else
			{
				callback?.Invoke(arg1: false, LocalizationManager.Instance.TryTranslate("$msg_bpmarket_notconnected"));
			}
		}

		internal static void PushServerBlueprint(string id, Action<bool, string> callback)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			if (!Config.AllowServerBlueprints.Value)
			{
				callback?.Invoke(arg1: false, LocalizationManager.Instance.TryTranslate("$msg_bpmarket_server_disabled"));
			}
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer() && (int)ZNet.m_connectionStatus == 2)
			{
				if (BlueprintManager.ServerBlueprints.TryGetValue(id, out var value))
				{
					Logger.LogMessage((object)("Sending blueprint " + id + " to server"));
					OnAnswerReceived = (Action<bool, string>)Delegate.Combine(OnAnswerReceived, callback);
					PushBlueprintRPC.SendPackage(ZRoutedRpc.instance.GetServerPeerID(), value.ToZPackage());
				}
			}
			else
			{
				callback?.Invoke(arg1: false, LocalizationManager.Instance.TryTranslate("$msg_bpmarket_notconnected"));
			}
		}

		private static IEnumerator PushBlueprintRPC_OnServerReceive(long sender, ZPackage pkg)
		{
			if (!Config.AllowServerBlueprints.Value)
			{
				yield break;
			}
			ZNetPeer val = ((IEnumerable<ZNetPeer>)ZNet.instance.m_peers).FirstOrDefault((Func<ZNetPeer, bool>)((ZNetPeer x) => x.m_uid == sender));
			if (val == null)
			{
				yield break;
			}
			Logger.LogDebug((object)$"Received blueprint from peer #{sender}");
			bool flag = true;
			_ = string.Empty;
			string text;
			try
			{
				Blueprint blueprint = Blueprint.FromZPackage(pkg);
				if (BlueprintManager.LocalBlueprints.ContainsKey(blueprint.ID) && !ZNetExtension.IsAdmin(ZNet.instance, sender))
				{
					throw new Exception(Localization.instance.Localize("$msg_bpmarket_admin_restricted"));
				}
				if (!blueprint.ToFile())
				{
					throw new Exception(Localization.instance.Localize("$msg_bpmarket_save_failed"));
				}
				if (BlueprintManager.LocalBlueprints.ContainsKey(blueprint.ID))
				{
					BlueprintManager.LocalBlueprints.Remove(blueprint.ID);
				}
				BlueprintManager.LocalBlueprints.Add(blueprint.ID, blueprint);
				text = blueprint.ID;
			}
			catch (Exception ex)
			{
				flag = false;
				text = ex.Message;
			}
			ZPackage val2 = new ZPackage();
			val2.Write(flag);
			val2.Write(text);
			PushBlueprintRPC.SendPackage(sender, val2);
		}

		private static IEnumerator PushBlueprintRPC_OnClientReceive(long sender, ZPackage pkg)
		{
			if (!Config.AllowServerBlueprints.Value || sender != ZRoutedRpc.instance.GetServerPeerID())
			{
				yield break;
			}
			Logger.LogDebug((object)"Received push answer from server");
			bool flag = pkg.ReadBool();
			string text = pkg.ReadString();
			try
			{
				if (flag && BlueprintManager.LocalBlueprints.TryGetValue(text, out var value))
				{
					if (BlueprintManager.ServerBlueprints.ContainsKey(text))
					{
						BlueprintManager.ServerBlueprints.Remove(text);
					}
					BlueprintManager.ServerBlueprints.Add(value.ID, value);
					BlueprintGUI.RefreshBlueprints(BlueprintLocation.Server);
				}
			}
			finally
			{
				OnAnswerReceived?.Invoke(flag, text);
				OnAnswerReceived = null;
			}
		}

		internal static bool RemoveLocalBlueprint(string id)
		{
			if (BlueprintManager.LocalBlueprints == null)
			{
				return false;
			}
			if (!BlueprintManager.LocalBlueprints.TryGetValue(id, out var value))
			{
				return false;
			}
			Logger.LogDebug((object)("Removing local blueprint " + id));
			value.DestroyBlueprint();
			BlueprintManager.LocalBlueprints.Remove(id);
			BlueprintManager.RegisterKnownBlueprints();
			BlueprintGUI.RefreshBlueprints(BlueprintLocation.Local);
			return true;
		}

		internal static bool RemoveTempBlueprint(string id)
		{
			if (BlueprintManager.TemporaryBlueprints == null)
			{
				return false;
			}
			if (!BlueprintManager.TemporaryBlueprints.TryGetValue(id, out var value))
			{
				return false;
			}
			Logger.LogDebug((object)("Removing temporary blueprint " + id));
			value.DestroyBlueprint();
			BlueprintManager.TemporaryBlueprints.Remove(id);
			BlueprintManager.RegisterKnownBlueprints();
			BlueprintGUI.RefreshBlueprints(BlueprintLocation.Temporary);
			return true;
		}

		internal static void RemoveServerBlueprint(string id, Action<bool, string> callback)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			if (!Config.AllowServerBlueprints.Value)
			{
				callback?.Invoke(arg1: false, LocalizationManager.Instance.TryTranslate("$msg_bpmarket_server_disabled"));
			}
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer() && (int)ZNet.m_connectionStatus == 2)
			{
				if (BlueprintManager.ServerBlueprints.TryGetValue(id, out var _))
				{
					Logger.LogMessage((object)("Removing blueprint " + id + " from server"));
					OnAnswerReceived = (Action<bool, string>)Delegate.Combine(OnAnswerReceived, callback);
					ZPackage val = new ZPackage();
					val.Write(id);
					RemoveServerBlueprintRPC.SendPackage(ZRoutedRpc.instance.GetServerPeerID(), val);
				}
			}
			else
			{
				callback?.Invoke(arg1: false, LocalizationManager.Instance.TryTranslate("$msg_bpmarket_notconnected"));
			}
		}

		private static IEnumerator RemoveServerBlueprintRPC_OnServerReceive(long sender, ZPackage pkg)
		{
			if (!Config.AllowServerBlueprints.Value)
			{
				yield break;
			}
			ZNetPeer val = ((IEnumerable<ZNetPeer>)ZNet.instance.m_peers).FirstOrDefault((Func<ZNetPeer, bool>)((ZNetPeer x) => x.m_uid == sender));
			if (val == null)
			{
				yield break;
			}
			Logger.LogDebug((object)$"Received blueprint removal request from peer #{sender}");
			bool flag = true;
			_ = string.Empty;
			string text2;
			try
			{
				string text = pkg.ReadString();
				if (BlueprintManager.LocalBlueprints.ContainsKey(text) && !ZNetExtension.IsAdmin(ZNet.instance, sender))
				{
					throw new Exception(Localization.instance.Localize("$msg_bpmarket_admin_restricted"));
				}
				if (BlueprintManager.LocalBlueprints.TryGetValue(text, out var value))
				{
					Logger.LogMessage((object)("Removing blueprint " + text + " from server"));
					value.DestroyBlueprint();
					BlueprintManager.LocalBlueprints.Remove(text);
				}
				text2 = text;
			}
			catch (Exception ex)
			{
				flag = false;
				text2 = ex.Message;
			}
			ZPackage val2 = new ZPackage();
			val2.Write(flag);
			val2.Write(text2);
			RemoveServerBlueprintRPC.SendPackage(sender, val2);
		}

		private static IEnumerator RemoveServerBlueprintRPC_OnClientReceive(long sender, ZPackage pkg)
		{
			if (!Config.AllowServerBlueprints.Value || sender != ZRoutedRpc.instance.GetServerPeerID())
			{
				yield break;
			}
			Logger.LogDebug((object)"Received remove answer from server");
			bool flag = pkg.ReadBool();
			string text = pkg.ReadString();
			try
			{
				if (flag && BlueprintManager.ServerBlueprints.ContainsKey(text))
				{
					BlueprintManager.ServerBlueprints.Remove(text);
					BlueprintGUI.RefreshBlueprints(BlueprintLocation.Server);
				}
			}
			finally
			{
				OnAnswerReceived?.Invoke(flag, text);
				OnAnswerReceived = null;
			}
		}

		private static void ResetServerBlueprints(orig_OnDestroy orig, ZNet self)
		{
			BlueprintManager.ServerBlueprints?.Clear();
			orig.Invoke(self);
		}
	}
	internal class SelectionGUI
	{
		private class SelectionGUIBehaviour : MonoBehaviour
		{
			private void Update()
			{
				if (IsVisible() && Input.GetKeyUp((KeyCode)27))
				{
					Instance.Cancel();
				}
			}
		}

		public static SelectionGUI Instance;

		private GameObject Prefab;

		private GameObject Window;

		private Button CopyButton;

		private Button CutButton;

		private Button SaveButton;

		private Toggle SnapPointsToggle;

		private Toggle MarkersToggle;

		private Button DeleteButton;

		private Button ClearButton;

		private Button CancelButton;

		public static void Init(GameObject prefab)
		{
			if (!GUIManager.IsHeadless())
			{
				Instance = new SelectionGUI();
				Instance.Prefab = prefab;
				GUIManager.OnCustomGUIAvailable += Instance.Register;
			}
		}

		public static bool IsAvailable()
		{
			return Instance != null;
		}

		public static bool IsVisible()
		{
			if (IsAvailable() && (Object)(object)Instance.Window != (Object)null)
			{
				return Instance.Window.activeSelf;
			}
			return false;
		}

		public void Show()
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				SnapPointsToggle.SetIsOnWithoutNotify(false);
				MarkersToggle.SetIsOnWithoutNotify(false);
				Window.SetActive(true);
				GUIManager.BlockInput(true);
			}
		}

		private void Register()
		{
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected O, but got Unknown
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Expected O, but got Unknown
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Expected O, but got Unknown
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)Window))
			{
				Logger.LogDebug((object)"Recreating SaveGUI");
				Window = Object.Instantiate<GameObject>(Prefab, GUIManager.CustomGUIFront.transform);
				Window.AddComponent<DragWindowCntrl>();
				Image component = Window.GetComponent<Image>();
				component.sprite = GUIManager.Instance.GetSprite("woodpanel_settings");
				component.type = (Type)1;
				((Graphic)component).material = Cache.GetPrefab<Material>("litpanel");
				Text[] componentsInChildren = Window.GetComponentsInChildren<Text>(true);
				foreach (Text val in componentsInChildren)
				{
					val.font = GUIManager.Instance.AveriaSerif;
				}
				Button[] componentsInChildren2 = Window.GetComponentsInChildren<Button>(true);
				foreach (Button val2 in componentsInChildren2)
				{
					GUIManager.Instance.ApplyButtonStyle(val2, 16);
				}
				Toggle[] componentsInChildren3 = Window.GetComponentsInChildren<Toggle>(true);
				foreach (Toggle val3 in componentsInChildren3)
				{
					GUIManager.Instance.ApplyToogleStyle(val3);
				}
				CopyButton = ((Component)Window.transform.Find("CopyButton")).GetComponent<Button>();
				((UnityEvent)CopyButton.onClick).AddListener((UnityAction)delegate
				{
					OnClick(Copy);
				});
				CutButton = ((Component)Window.transform.Find("CutButton")).GetComponent<Button>();
				((UnityEvent)CutButton.onClick).AddListener((UnityAction)delegate
				{
					OnClick(Cut);
				});
				SaveButton = ((Component)Window.transform.Find("SaveButton")).GetComponent<Button>();
				((UnityEvent)SaveButton.onClick).AddListener((UnityAction)delegate
				{
					OnClick(SaveGUI);
				});
				SnapPointsToggle = ((Component)Window.transform.Find("SnapPointsToggle")).GetComponent<Toggle>();
				MarkersToggle = ((Component)Window.transform.Find("MarkersToggle")).GetComponent<Toggle>();
				DeleteButton = ((Component)Window.transform.Find("DeleteButton")).GetComponent<Button>();
				((UnityEvent)DeleteButton.onClick).AddListener((UnityAction)delegate
				{
					OnClick(Delete);
				});
				ClearButton = ((Component)Window.transform.Find("ClearButton")).GetComponent<Button>();
				((UnityEvent)ClearButton.onClick).AddListener((UnityAction)delegate
				{
					OnClick(Clear);
				});
				CancelButton = ((Component)Window.transform.Find("CancelButton")).GetComponent<Button>();
				((UnityEvent)CancelButton.onClick).AddListener((UnityAction)delegate
				{
					OnClick(Cancel);
				});
				Localization.instance.Localize(Instance.Window.transform);
				Instance.Window.AddComponent<SelectionGUIBehaviour>();
				Window.SetActive(false);
			}
			void OnClick(Action action)
			{
				action?.Invoke();
				Window.SetActive(false);
				GUIManager.BlockInput(false);
			}
		}

		private void Cancel()
		{
			Window.SetActive(false);
			GUIManager.BlockInput(false);
		}

		private void Copy()
		{
			SelectionTools.Copy(Selection.Instance, SnapPointsToggle.isOn, MarkersToggle.isOn);
			Selection.Instance.Clear();
		}

		private void Cut()
		{
			if (!SynchronizationManager.Instance.PlayerIsAdmin)
			{
				MessageHud.instance.ShowMessage((MessageType)2, "$msg_select_cut_disabled", 0, (Sprite)null, false, true);
				return;
			}
			SelectionTools.Cut(Selection.Instance, SnapPointsToggle.isOn, MarkersToggle.isOn);
			Selection.Instance.Clear();
		}

		private void SaveGUI()
		{
			SelectionTools.SaveWithGUI(Selection.Instance, SnapPointsToggle.isOn, MarkersToggle.isOn);
		}

		private void Delete()
		{
			if (!SynchronizationManager.Instance.PlayerIsAdmin)
			{
				MessageHud.instance.ShowMessage((MessageType)2, "$msg_select_delete_disabled", 0, (Sprite)null, false, true);
				return;
			}
			SelectionTools.Delete(Selection.Instance);
			Selection.Instance.Clear();
		}

		private void Clear()
		{
			Selection.Instance.Clear();
		}
	}
	internal class SelectionTools
	{
		public static void Copy(Selection selection, bool captureCurrentSnapPoints, bool keepMarkers)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected I4, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			Blueprint blueprint = new Blueprint();
			blueprint.ID = $"__{BlueprintManager.TemporaryBlueprints.Count + 1:000}";
			blueprint.Creator = Player.m_localPlayer.GetPlayerName();
			blueprint.Name = blueprint.ID;
			blueprint.Category = "Clipboard";
			if (!blueprint.Capture(selection, captureCurrentSnapPoints, keepMarkers))
			{
				Logger.LogWarning((object)("Could not capture blueprint " + blueprint.ID));
				selection.Clear();
				return;
			}
			blueprint.CreatePiece();
			blueprint.CreateThumbnail(0, flush: false);
			BlueprintManager.TemporaryBlueprints.Add(blueprint.ID, blueprint);
			Player.m_localPlayer.UpdateKnownRecipesList();
			Player.m_localPlayer.UpdateAvailablePiecesList();
			int num = (int)PieceManager.Instance.GetPieceCategory("Clipboard").Value;
			List<Piece> value = Player.m_localPlayer.m_buildPieces.m_availablePiecesByCategory[num].OrderByDescending((Piece x) => ((Object)x).name).ToList();
			Player.m_localPlayer.m_buildPieces.m_availablePiecesByCategory[num] = value;
			Player.m_localPlayer.m_buildPieces.m_selectedCategory = (PieceCategory)num;
			Player.m_localPlayer.m_buildPieces.SetSelected(new Vector2Int(0, 0));
			Player.m_localPlayer.SetupPlacementGhost();
			BlueprintGUI.RefreshBlueprints(BlueprintLocation.Temporary);
		}

		public static void Cut(Selection selection, bool captureCurrentSnapPoints, bool keepMarkers)
		{
			Copy(selection, captureCurrentSnapPoints, keepMarkers);
			Delete(selection);
		}

		public static void Delete(Selection selection)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			List<ZDO> list = new List<ZDO>();
			List<ZDOID> list2 = selection.ToList();
			ZNetView val2 = default(ZNetView);
			foreach (ZDOID item in list2)
			{
				GameObject val = ZNetScene.instance.FindInstance(item);
				if (Object.op_Implicit((Object)(object)val) && val.TryGetComponent<ZNetView>(ref val2))
				{
					list.Add(val2.m_zdo);
					val2.ClaimOwnership();
					ZNetScene.instance.Destroy(val);
				}
			}
			UndoRemove undoRemove = new UndoRemove(list);
			UndoManager.Instance.Add(Config.BlueprintUndoQueueNameConfig.Value, (IUndoAction)(object)undoRemove);
		}

		public static void Save(Selection selection, string name, string category, string description, bool captureCurrentSnapPoints, bool keepMarkers)
		{
			if (string.IsNullOrEmpty(name))
			{
				return;
			}
			Blueprint blueprint = new Blueprint();
			if (blueprint.Capture(selection, captureCurrentSnapPoints, keepMarkers))
			{
				blueprint.ID = Blueprint.CreateIDString(name);
				blueprint.Name = name;
				blueprint.Creator = Player.m_localPlayer.GetPlayerName();
				blueprint.Category = (string.IsNullOrEmpty(category) ? "Blueprints" : category);
				blueprint.Description = description;
				blueprint.FileLocation = Path.Combine(Config.BlueprintSaveDirectoryConfig.Value, blueprint.ID + ".blueprint");
				blueprint.ThumbnailLocation = blueprint.FileLocation.Replace(".blueprint", ".png");
				if (BlueprintManager.LocalBlueprints.TryGetValue(blueprint.ID, out var value))
				{
					value.DestroyBlueprint();
					BlueprintManager.LocalBlueprints.Remove(blueprint.ID);
				}
				if (blueprint.ToFile() && blueprint.CreatePiece())
				{
					BlueprintManager.LocalBlueprints.Add(blueprint.ID, blueprint);
					blueprint.CreateThumbnail();
					BlueprintManager.RegisterKnownBlueprints();
					BlueprintGUI.RefreshBlueprints(BlueprintLocation.Local);
				}
			}
		}

		public static void SaveWithGUI(Selection selection, bool captureCurrentSnapPoints, bool keepMarkers)
		{
			string bpname = $"blueprint{BlueprintManager.LocalBlueprints.Count + 1:000}";
			SelectionSaveGUI.Instance.Show(selection, bpname, delegate(string name, string category, string description)
			{
				Save(selection, name, category, description, captureCurrentSnapPoints, keepMarkers);
				selection.Clear();
			}, delegate
			{
				selection.Clear();
			});
		}
	}
	internal class TerrainModMarker : MonoBehaviour, Interactable, Hoverable
	{
		private const string ShapeProperty = "shape";

		private const string RadiusProperty = "radius";

		private const string RotationProperty = "rotation";

		private const string SmoothProperty = "smooth";

		private const string PaintProperty = "paint";

		private ZNetView ZNetView;

		private ShapedProjector Projector;

		public void Awake()
		{
			if (ZNetView.m_forceDisableInit)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			ZNetView = ((Component)this).GetComponent<ZNetView>();
			ZNetView.Register<string, string>("SetProperty", (Action<long, string, string>)RPC_SetProperty);
			Projector = ((Component)this).GetComponent<ShapedProjector>();
			Projector.Enable();
			if (string.IsNullOrEmpty(GetProperty("shape")))
			{
				SetProperty("shape", "circle");
			}
			if (string.IsNullOrEmpty(GetProperty("radius")))
			{
				SetProperty("radius", "3");
			}
			if (string.IsNullOrEmpty(GetProperty("rotation")))
			{
				SetProperty("rotation", "0");
			}
			if (string.IsNullOrEmpty(GetProperty("smooth")))
			{
				SetProperty("smooth", "0.3");
			}
		}

		public string GetProperty(string property)
		{
			if (!ZNetView.IsValid())
			{
				return null;
			}
			return ZNetView.GetZDO().GetString(property, "");
		}

		public void SetProperty(string property, string value)
		{
			ZNetView.InvokeRPC("SetProperty", new object[2] { property, value });
		}

		public void RPC_SetProperty(long sender, string property, string value)
		{
			if (!ZNetView.IsOwner())
			{
				return;
			}
			ZNetView.GetZDO().Set(property, value);
			if (property.Equals("shape", StringComparison.Ordinal))
			{
				if (value.Equals("circle", StringComparison.OrdinalIgnoreCase))
				{
					Projector.SetShape(ShapedProjector.ProjectorShape.Circle);
				}
				if (value.Equals("square", StringComparison.OrdinalIgnoreCase))
				{
					Projector.SetShape(ShapedProjector.ProjectorShape.Square);
				}
			}
			if (property.Equals("radius", StringComparison.Ordinal))
			{
				Projector.SetRadius(float.Parse(value, CultureInfo.InvariantCulture));
			}
			if (property.Equals("rotation", StringComparison.Ordinal))
			{
				Projector.SetRotation(int.Parse(value));
			}
		}

		public string GetHoverName()
		{
			return "Terrain modification marker";
		}

		public string GetHoverText()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("[<color=yellow>$KEY_Use</color>] $hud_terrainmod_interact\n");
			stringBuilder.Append("$gui_terrainmod_shape: " + GetProperty("shape") + " \n");
			stringBuilder.Append("$gui_terrainmod_radius: " + GetProperty("radius") + "\n");
			stringBuilder.Append("$gui_terrainmod_rotation: " + GetProperty("rotation") + "\n");
			stringBuilder.Append("$gui_terrainmod_smooth: " + GetProperty("smooth") + "\n");
			stringBuilder.Append("$gui_terrainmod_paint: " + GetProperty("paint") + "\n");
			return Localization.instance.Localize(stringBuilder.ToString());
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			Player val = (Player)(object)((user is Player) ? user : null);
			if (val == null)
			{
				return false;
			}
			TerrainModGUI.Instance.Show(GetProperty("shape"), GetProperty("radius"), GetProperty("rotation"), GetProperty("smooth"), GetProperty("paint"), delegate(string shape, string radius, string rotation, string smooth, string paint)
			{
				if (!string.IsNullOrEmpty(shape))
				{
					SetProperty("shape", shape.ToLowerInvariant());
				}
				if (!string.IsNullOrEmpty(radius))
				{
					SetProperty("radius", radius);
				}
				if (!string.IsNullOrEmpty(rotation))
				{
					SetProperty("rotation", rotation);
				}
				if (!string.IsNullOrEmpty(smooth))
				{
					SetProperty("smooth", smooth);
				}
				if (!string.IsNullOrEmpty(paint))
				{
					if (paint.Equals("none", StringComparison.OrdinalIgnoreCase))
					{
						SetProperty("paint", string.Empty);
					}
					else
					{
						SetProperty("paint", paint);
					}
				}
			}, delegate
			{
			});
			return true;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}

		public float GetHoverOffset()
		{
			return 0f;
		}
	}
	public class TerrainModEntry
	{
		public string line;

		public string shape;

		public float posX;

		public float posY;

		public float posZ;

		public float radius;

		public int rotation;

		public float smooth;

		public string paint;

		public TerrainModEntry(string line)
		{
			this.line = line;
			string[] array = line.Split(new char[1] { ';' });
			shape = array[0];
			posX = InvariantFloat(array[1]);
			posY = InvariantFloat(array[2]);
			posZ = InvariantFloat(array[3]);
			radius = InvariantFloat(array[4]);
			rotation = int.Parse(array[5]);
			smooth = InvariantFloat(array[6]);
			paint = array[7];
		}

		public TerrainModEntry(string shape, Vector3 pos, float radius, int rotation, float smooth, string paint)
		{
			//IL_001d: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			line = string.Join(";", shape.ToLowerInvariant(), InvariantString(pos.x), InvariantString(pos.y), InvariantString(pos.z), InvariantString(radius), rotation.ToString(), InvariantString(smooth), paint);
			posX = pos.x;
			posY = pos.y;
			posZ = pos.z;
			this.shape = shape;
			this.radius = radius;
			this.rotation = rotation;
			this.smooth = smooth;
			this.paint = paint;
		}

		public Vector3 GetPosition()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(posX, posY, posZ);
		}

		public Quaternion GetRotation()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return Quaternion.Euler(0f, (float)rotation, 0f);
		}

		internal static string InvariantString(float f)
		{
			return f.ToString(NumberFormatInfo.InvariantInfo);
		}

		internal static float InvariantFloat(string s)
		{
			if (s.StartsWith("-,"))
			{
				s = s.Replace("-,", "-0,");
			}
			else if (s.StartsWith(","))
			{
				s = "0" + s;
			}
			return float.Parse(s, NumberStyles.Float, NumberFormatInfo.InvariantInfo);
		}
	}
	public class HeightIndex
	{
		public int Index;

		public Vector3 Position;

		public float DistanceWidth;

		public float DistanceDepth;

		public float Distance;
	}
	public class PaintIndex
	{
		public int Index;

		public Vector3 Position;
	}
	public class Indices
	{
		public HeightIndex[] HeightIndices = new HeightIndex[0];

		public PaintIndex[] PaintIndices = new PaintIndex[0];
	}
	public enum BlockCheck
	{
		Off,
		On,
		Inverse
	}
	public static class TerrainTools
	{
		public static void Save(TerrainComp compiler)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			ZNetView component = ((Component)compiler).GetComponent<ZNetView>();
			if (component != null)
			{
				component.ClaimOwnership();
			}
			compiler.m_operations++;
			compiler.m_lastOpPoint = Vector3.zero;
			compiler.m_lastOpRadius = 0f;
			compiler.Save(false);
			compiler.m_hmap.Poke(0, false);
		}

		private static Indices FilterByBlockCheck(Indices indices, BlockCheck blockCheck)
		{
			indices.HeightIndices = indices.HeightIndices.Where((HeightIndex index) => CheckBlocking(index.Position, blockCheck)).ToArray();
			indices.PaintIndices = indices.PaintIndices.Where((PaintIndex index) => CheckBlocking(index.Position, blockCheck)).ToArray();
			return indices;
		}

		private static IEnumerable<TerrainComp> GetTerrainCompilersWithCircle(Vector3 position, float radius)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			List<Heightmap> list = new List<Heightmap>();
			Heightmap.FindHeightmap(position, radius + 1f, list);
			Vector3 pos = position;
			return from hmap in list
				where ZNetScene.InActiveArea(pos, ZoneSystem.GetZone(((Component)hmap).transform.position))
				select hmap.GetAndCreateTerrainCompiler();
		}

		private static IEnumerable<TerrainComp> GetTerrainCompilersWithRect(Vector3 position, float width, float depth, float angle)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			List<Heightmap> list = new List<Heightmap>();
			float num = Mathf.Max(width, depth);
			float num2 = Mathf.Abs(Mathf.Sin(angle)) + Mathf.Abs(Mathf.Cos(angle));
			float num3 = num * num2 / 2f;
			Heightmap.FindHeightmap(position, num3 + 1f, list);
			Vector3 pos = position;
			return from hmap in list
				where ZNetScene.InActiveArea(pos, ZoneSystem.GetZone(((Component)hmap).transform.position))
				select hmap.GetAndCreateTerrainCompiler();
		}

		public static Dictionary<TerrainComp, Indices> GetCompilerIndicesWithCircle(Vector3 centerPos, float diameter, BlockCheck blockCheck)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			return (from kvp in GetTerrainCompilersWithCircle(centerPos, diameter / 2f).ToDictionary((TerrainComp comp) => comp, (TerrainComp comp) => new Indices
				{
					HeightIndices = (from index in GetHeightIndicesWithCircle(comp, centerPos, diameter)
						where CheckBlocking(index.Position, blockCheck)
						select index).ToArray(),
					PaintIndices = (from index in GetPaintIndicesWithCircle(comp, centerPos, diameter)
						where CheckBlocking(index.Position, blockCheck)
						select index).ToArray()
				})
				where kvp.Value.HeightIndices.Count() + kvp.Value.PaintIndices.Count() > 0
				select kvp).ToDictionary((KeyValuePair<TerrainComp, Indices> kvp) => kvp.Key, (KeyValuePair<TerrainComp, Indices> kvp) => kvp.Value);
		}

		public static Dictionary<TerrainComp, Indices> GetCompilerIndicesWithRect(Vector3 centerPos, float width, float depth, float angle, BlockCheck blockCheck)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			return (from kvp in GetTerrainCompilersWithRect(centerPos, width, depth, angle).ToDictionary((TerrainComp comp) => comp, (TerrainComp comp) => new Indices
				{
					HeightIndices = (from index in GetHeightIndicesWithRect(comp, centerPos, width, depth, angle)
						where CheckBlocking(index.Position, blockCheck)
						select index).ToArray(),
					PaintIndices = (from index in GetPaintIndicesWithRect(comp, centerPos, width, depth, angle)
						where CheckBlocking(index.Position, blockCheck)
						select index).ToArray()
				})
				where kvp.Value.HeightIndices.Count() + kvp.Value.PaintIndices.Count() > 0
				select kvp).ToDictionary((KeyValuePair<TerrainComp, Indices> kvp) => kvp.Key, (KeyValuePair<TerrainComp, Indices> kvp) => kvp.Value);
		}

		public static void SetTerrain(Dictionary<TerrainComp, Indices> compilerIndices, Vector3 pos, float radius, float smooth, float delta)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Action<TerrainComp, HeightIndex> action = delegate(TerrainComp compiler, HeightIndex heightIndex)
			{
				float num = CalculateSmooth(smooth, heightIndex.Distance);
				int index = heightIndex.Index;
				compiler.m_levelDelta[index] = delta * num;
				compiler.m_smoothDelta[index] = 0f;
				compiler.m_modifiedHeight[index] = compiler.m_levelDelta[index] != 0f;
			};
			DoHeightOperation(compilerIndices, pos, radius, action);
		}

		private static float CalculateSmooth(float smooth, float distance)
		{
			if (!(1f - distance >= smooth))
			{
				return (1f - distance) / smooth;
			}
			return 1f;
		}

		private static float CalculateSlope(float angle, float distanceWidth, float distanceDepth)
		{
			return Mathf.Sin(angle) * distanceWidth + Mathf.Cos(angle) * distanceDepth;
		}

		public static void RaiseTerrain(Dictionary<TerrainComp, Indices> compilerIndices, Vector3 pos, float radius, float smooth, float amount)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Action<TerrainComp, HeightIndex> action = delegate(TerrainComp compiler, HeightIndex heightIndex)
			{
				float num = CalculateSmooth(smooth, heightIndex.Distance);
				int index = heightIndex.Index;
				compiler.m_levelDelta[index] += num * amount + compiler.m_smoothDelta[index];
				compiler.m_smoothDelta[index] = 0f;
				compiler.m_modifiedHeight[index] = compiler.m_levelDelta[index] != 0f;
			};
			DoHeightOperation(compilerIndices, pos, radius, action);
		}

		public static void LevelTerrain(Dictionary<TerrainComp, Indices> compilerIndices, Vector3 pos, float radius, float smooth, float altitude)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Action<TerrainComp, HeightIndex> action = delegate(TerrainComp compiler, HeightIndex heightIndex)
			{
				float num = CalculateSmooth(smooth, heightIndex.Distance);
				int index = heightIndex.Index;
				compiler.m_levelDelta[index] += num * (altitude - compiler.m_hmap.m_heights[index]);
				compiler.m_smoothDelta[index] = 0f;
				compiler.m_modifiedHeight[index] = compiler.m_levelDelta[index] != 0f;
			};
			DoHeightOperation(compilerIndices, pos, radius, action);
		}

		public static void SlopeTerrain(Dictionary<TerrainComp, Indices> compilerIndices, Vector3 pos, float radius, float angle, float smooth, float altitude, float amount)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			Action<TerrainComp, HeightIndex> action = delegate(TerrainComp compiler, HeightIndex heightIndex)
			{
				float num = CalculateSlope(angle, heightIndex.DistanceWidth, heightIndex.DistanceDepth) * CalculateSmooth(smooth, heightIndex.Distance);
				int index = heightIndex.Index;
				compiler.m_levelDelta[index] += altitude - compiler.m_hmap.m_heights[index] + num * amount / 2f;
				compiler.m_smoothDelta[index] = 0f;
				compiler.m_modifiedHeight[index] = compiler.m_levelDelta[index] != 0f;
			};
			DoHeightOperation(compilerIndices, pos, radius, action);
		}

		public static void ResetTerrain(Dictionary<TerrainComp, Indices> compilerIndices, Vector3 pos, float radius)
		{
			//IL_0006: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			List<TerrainModifier> list = new List<TerrainModifier>();
			TerrainModifier.GetModifiers(pos, radius + 1f, list, (TerrainModifier)null);
			foreach (TerrainModifier item in list)
			{
				if (!((Object)(object)item.m_nview == (Object)null))
				{
					item.m_nview.ClaimOwnership();
					ZNetScene.instance.Destroy(((Component)item).gameObject);
				}
			}
			Action<TerrainComp, HeightIndex> action = delegate(TerrainComp compiler, HeightIndex heightIndex)
			{
				int index = heightIndex.Index;
				compiler.m_levelDelta[index] = 0f;
				compiler.m_smoothDelta[index] = 0f;
				compiler.m_modifiedHeight[index] = false;
			};
			DoHeightOperation(compilerIndices, pos, radius, action);
			PaintTerrain(compilerIndices, pos, radius, Heightmap.m_paintMaskNothing);
		}

		public static void PaintTerrain(Dictionary<TerrainComp, Indices> compilerIndices, Vector3 pos, float radius, PaintType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected I4, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			PaintTerrain(compilerIndices, pos, radius, (Color)((int)type switch
			{
				0 => Heightmap.m_paintMaskDirt, 
				1 => Heightmap.m_paintMaskCultivated, 
				2 => Heightmap.m_paintMaskPaved, 
				3 => Heightmap.m_paintMaskNothing, 
				_ => throw new ArgumentOutOfRangeException("type", type, "PaintType not supported"), 
			}));
		}

		public static void PaintTerrain(Dictionary<TerrainComp, Indices> compilerIndices, Vector3 pos, float radius, Color color)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Action<TerrainComp, int> action = delegate(TerrainComp compiler, int index)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				Color val = color;
				val.a = compiler.m_paintMask[index].a;
				compiler.m_paintMask[index] = val;
				compiler.m_modifiedPaint[index] = true;
			};
			DoPaintOperation(compilerIndices, pos, radius, action);
		}

		public static Dictionary<Vector3, TerrainUndoData> GetData(Dictionary<TerrainComp, Indices> compilerIndices)
		{
			return ((IEnumerable<KeyValuePair<TerrainComp, Indices>>)compilerIndices).ToDictionary((Func<KeyValuePair<TerrainComp, Indices>, Vector3>)((KeyValuePair<TerrainComp, Indices> kvp) => ((Component)kvp.Key).transform.position), (Func<KeyValuePair<TerrainComp, Indices>, TerrainUndoData>)((KeyValuePair<TerrainComp, Indices> kvp) => new TerrainUndoData
			{
				Heights = ((IEnumerable<HeightIndex>)kvp.Value.HeightIndices).Select((Func<HeightIndex, HeightUndoData>)((HeightIndex heightIndex) => new HeightUndoData
				{
					Index = heightIndex.Index,
					HeightModified = kvp.Key.m_modifiedHeight[heightIndex.Index],
					Level = kvp.Key.m_levelDelta[heightIndex.Index],
					Smooth = kvp.Key.m_smoothDelta[heightIndex.Index]
				})).ToArray(),
				Paints = ((IEnumerable<PaintIndex>)kvp.Value.PaintIndices).Select((Func<PaintIndex, PaintUndoData>)((PaintIndex paintIndex) => new PaintUndoData
				{
					Index = paintIndex.Index,
					PaintModified = kvp.Key.m_modifiedPaint[paintIndex.Index],
					Paint = kvp.Key.m_paintMask[paintIndex.Index]
				})).ToArray()
			}));
		}

		private static Vector3 VertexToWorld(Heightmap hmap, int x, int y)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)hmap).transform.position;
			position.x += ((float)(x - hmap.m_width / 2) + 0.5f) * hmap.m_scale;
			position.z += ((float)(y - hmap.m_width / 2) + 0.5f) * hmap.m_scale;
			return position;
		}

		private static void DoHeightOperation(Dictionary<TerrainComp, Indices> compilerIndices, Vector3 pos, float radius, Action<TerrainComp, HeightIndex> action)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			Dictionary<Vector3, TerrainUndoData> data = GetData(compilerIndices);
			foreach (KeyValuePair<TerrainComp, Indices> compilerIndex in compilerIndices)
			{
				TerrainComp key = compilerIndex.Key;
				HeightIndex[] heightIndices = compilerIndex.Value.HeightIndices;
				HeightIndex[] array = heightIndices;
				foreach (HeightIndex arg in array)
				{
					action(key, arg);
				}
				Save(key);
			}
			ClutterSystem instance = ClutterSystem.instance;
			if (instance != null)
			{
				instance.ResetGrass(pos, radius);
			}
			Dictionary<Vector3, TerrainUndoData> data2 = GetData(compilerIndices);
			UndoTerrain val = new UndoTerrain(data, data2, pos, radius);
			UndoManager.Instance.Add(Config.BlueprintUndoQueueNameConfig.Value, (IUndoAction)(object)val);
		}

		private static void DoPaintOperation(Dictionary<TerrainComp, Indices> compilerIndices, Vector3 pos, float radius, Action<TerrainComp, int> action)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			Dictionary<Vector3, TerrainUndoData> data = GetData(compilerIndices);
			foreach (KeyValuePair<TerrainComp, Indices> compilerIndex in compilerIndices)
			{
				TerrainComp key = compilerIndex.Key;
				PaintIndex[] paintIndices = compilerIndex.Value.PaintIndices;
				PaintIndex[] array = paintIndices;
				foreach (PaintIndex paintIndex in array)
				{
					action(key, paintIndex.Index);
				}
				Save(key);
			}
			ClutterSystem instance = ClutterSystem.instance;
			if (instance != null)
			{
				instance.ResetGrass(pos, radius);
			}
			Dictionary<Vector3, TerrainUndoData> data2 = GetData(compilerIndices);
			UndoTerrain val = new UndoTerrain(data, data2, pos, radius);
			UndoManager.Instance.Add(Config.BlueprintUndoQueueNameConfig.Value, (IUndoAction)(object)val);
		}

		private static bool CheckBlocking(Vector3 position, BlockCheck blockCheck)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (blockCheck == BlockCheck.Off)
			{
				return true;
			}
			bool flag = ZoneSystem.instance.IsBlocked(position);
			if (flag && blockCheck == BlockCheck.On)
			{
				return false;
			}
			if (!flag && blockCheck == BlockCheck.Inverse)
			{
				return false;
			}
			return true;
		}

		private static IEnumerable<HeightIndex> GetHeightIndicesWithCircle(TerrainComp compiler, Vector3 centerPos, float diameter)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			List<HeightIndex> list = new List<HeightIndex>();
			int num = default(int);
			int num2 = default(int);
			compiler.m_hmap.WorldToVertex(centerPos, ref num, ref num2);
			float num3 = diameter / 2f / compiler.m_hmap.m_scale;
			int num4 = compiler.m_width + 1;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor((float)num, (float)num2);
			for (int i = 0; i < num4; i++)
			{
				for (int j = 0; j < num4; j++)
				{
					float num5 = Vector2.Distance(val, new Vector2((float)j, (float)i));
					if (!(num5 > num3))
					{
						int num6 = j - num;
						int num7 = i - num2;
						list.Add(new HeightIndex
						{
							Index = i * num4 + j,
							Position = VertexToWorld(compiler.m_hmap, j, i),
							DistanceWidth = (float)num6 / num3,
							DistanceDepth = (float)num7 / num3,
							Distance = num5 / num3
						});
					}
				}
			}
			return list;
		}

		private static float GetX(int x, int y, float angle)
		{
			return Mathf.Cos(angle) * (float)x - Mathf.Sin(angle) * (float)y;
		}

		private static float GetY(int x, int y, float angle)
		{
			return Mathf.Sin(angle) * (float)x + Mathf.Cos(angle) * (float)y;
		}

		private static IEnumerable<HeightIndex> GetHeightIndicesWithRect(TerrainComp compiler, Vector3 centerPos, float width, float depth, float angle)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			List<HeightIndex> list = new List<HeightIndex>();
			int num = default(int);
			int num2 = default(int);
			compiler.m_hmap.WorldToVertex(centerPos, ref num, ref num2);
			float num3 = width / 2f / compiler.m_hmap.m_scale;
			float num4 = depth / 2f / compiler.m_hmap.m_scale;
			int num5 = compiler.m_width + 1;
			for (int i = 0; i < num5; i++)
			{
				for (int j = 0; j < num5; j++)
				{
					int x = i - num;
					int y = j - num2;
					float x2 = GetX(x, y, angle);
					float y2 = GetY(x, y, angle);
					if (!(Mathf.Abs(x2) > num3) && !(Mathf.Abs(y2) > num4))
					{
						float num6 = x2 / num3;
						float num7 = y2 / num4;
						list.Add(new HeightIndex
						{
							Index = j * num5 + i,
							Position = VertexToWorld(compiler.m_hmap, i, j),
							DistanceWidth = num6,
							DistanceDepth = num7,
							Distance = Mathf.Max(Mathf.Abs(num6), Mathf.Abs(num7))
						});
					}
				}
			}
			return list;
		}

		private static IEnumerable<PaintIndex> GetPaintIndicesWithRect(TerrainComp compiler, Vector3 centerPos, float width, float depth, float angle)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			List<PaintIndex> list = new List<PaintIndex>();
			int num = default(int);
			int num2 = default(int);
			compiler.m_hmap.WorldToVertexMask(centerPos, ref num, ref num2);
			float num3 = width / 2f / compiler.m_hmap.m_scale;
			float num4 = depth / 2f / compiler.m_hmap.m_scale;
			int num5 = compiler.m_width + 1;
			for (int i = 0; i < num5; i++)
			{
				for (int j = 0; j < num5; j++)
				{
					int x = i - num;
					int y = j - num2;
					float x2 = GetX(x, y, angle);
					float y2 = GetY(x, y, angle);
					if (!(Mathf.Abs(x2) > num3) && !(Mathf.Abs(y2) > num4))
					{
						list.Add(new PaintIndex
						{
							Index = j * num5 + i,
							Position = VertexToWorld(compiler.m_hmap, i, j)
						});
					}
				}
			}
			return list;
		}

		private static IEnumerable<PaintIndex> GetPaintIndicesWithCircle(TerrainComp compiler, Vector3 centerPos, float diameter)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			List<PaintIndex> list = new List<PaintIndex>();
			int num = default(int);
			int num2 = default(int);
			compiler.m_hmap.WorldToVertexMask(centerPos, ref num, ref num2);
			float num3 = diameter / 2f / compiler.m_hmap.m_scale;
			int num4 = compiler.m_width + 1;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor((float)num, (float)num2);
			for (int i = 0; i < num4; i++)
			{
				for (int j = 0; j < num4; j++)
				{
					float num5 = Vector2.Distance(val, new Vector2((float)j, (float)i));
					if (!(num5 > num3))
					{
						list.Add(new PaintIndex
						{
							Index = i * num4 + j,
							Position = VertexToWorld(compiler.m_hmap, j, i)
						});
					}
				}
			}
			return list;
		}
	}
	internal class UndoCreate : UndoCreate
	{
		public UndoCreate(IEnumerable<ZDO> data)
			: base(data)
		{
		}

		public override void Undo()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			ZDO[] data = base.Data;
			foreach (ZDO val in data)
			{
				Selection.Instance.Remove(val.m_uid);
			}
			((UndoCreate)this).Undo();
		}
	}
	internal class UndoRemove : UndoRemove
	{
		public UndoRemove(IEnumerable<ZDO> data)
			: base(data)
		{
		}

		public override void Redo()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			ZDO[] data = base.Data;
			foreach (ZDO val in data)
			{
				Selection.Instance.Remove(val.m_uid);
			}
			((UndoRemove)this).Redo();
		}
	}
	internal class Selection : IEnumerable<ZDOID>, IEnumerable
	{
		public const int MAX_HIGHLIGHT_PER_FRAME = 50;

		public const int MAX_GROW_PER_FRAME = 50;

		public static int GrowMask;

		private static Selection _instance;

		private readonly ZDOIDSet SelectedZDOIDs = new ZDOIDSet();

		private readonly ZDOIDSet HighlightedZDOIDs = new ZDOIDSet();

		private Coroutine UnhighlightCoroutine;

		public static Selection Instance => _instance ?? (_instance = new Selection());

		public int SnapPoints { get; internal set; }

		public int CenterMarkers { get; internal set; }

		public int TerrainMods { get; internal set; }

		public static void Init()
		{
			GrowMask = LayerMask.GetMask(new string[3] { "Default", "piece", "piece_nonsolid" });
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public IEnumerator<ZDOID> GetEnumerator()
		{
			foreach (ZDOID item in new List<ZDOID>(SelectedZDOIDs))
			{
				yield return item;
			}
		}

		public bool Add(ZDOID zdoid)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = BlueprintManager.GetGameObject(zdoid);
			Piece piece = default(Piece);
			if (Object.op_Implicit((Object)(object)gameObject) && gameObject.TryGetComponent<Piece>(ref piece))
			{
				return AddPiece(piece);
			}
			if (SelectedZDOIDs.Add(zdoid))
			{
				return true;
			}
			return false;
		}

		public bool AddPiece(Piece piece)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			ZNetView nview = piece.m_nview;
			ZDOID? val = ((nview == null) ? ((ZDOID?)null) : nview.GetZDO()?.m_uid);
			if (val.HasValue && SelectedZDOIDs.Add(val.Value))
			{
				AttachListener(piece);
				Highlight(val.Value, ((Component)piece).gameObject);
				if (((Object)piece).name.StartsWith("piece_bpsnappoint", StringComparison.Ordinal))
				{
					SnapPoints++;
				}
				else if (((Object)piece).name.StartsWith("piece_bpcenterpoint", StringComparison.Ordinal))
				{
					CenterMarkers++;
				}
				else if (((Object)piece).name.StartsWith("piece_bpterrainmod", StringComparison.Ordinal))
				{
					TerrainMods++;
				}
				return true;
			}
			return false;
		}

		public void AddPiecesInRadius(Vector3 worldPos, float radius, bool onlyPlanned = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(worldPos.x, worldPos.z);
			foreach (Piece s_allPiece in Piece.s_allPieces)
			{
				Vector3 position = ((Component)s_allPiece).transform.position;
				if (Vector2.Distance(val, new Vector2(position.x, position.z)) <= radius && BlueprintManager.CanCapture(s_allPiece, onlyPlanned))
				{
					AddPiece(s_allPiece);
				}
			}
		}

		public void AddPiecesBetween(Piece startPiece, Piece endPiece)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Bounds bounds = default(Bounds);
			((Bounds)(ref bounds)).SetMinMax(Vector3.Min(((StaticTarget)startPiece).GetCenter(), ((StaticTarget)endPiece).GetCenter()), Vector3.Max(((StaticTarget)startPiece).GetCenter(), ((StaticTarget)endPiece).GetCenter()));
			foreach (Piece item in Piece.s_allPieces.Where(delegate(Piece x)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				Collider componentInChildren = ((Component)x).GetComponentInChildren<Collider>();
				return componentInChildren != null && ((Bounds)(ref bounds)).Intersects(componentInChildren.bounds);
			}))
			{
				AddPiece(item);
			}
		}

		public bool Contains(Piece piece)
		{
			return Contains(piece?.GetZDOID());
		}

		public bool Contains(ZDOID? zdoid)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (zdoid.HasValue)
			{
				return SelectedZDOIDs.Contains(zdoid.Value);
			}
			return false;
		}

		public bool Remove(ZDOID zdoid)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = BlueprintManager.GetGameObject(zdoid);
			Piece piece = default(Piece);
			if (Object.op_Implicit((Object)(object)gameObject) && gameObject.TryGetComponent<Piece>(ref piece))
			{
				return RemovePiece(piece);
			}
			if (SelectedZDOIDs.Remove(zdoid))
			{
				return true;
			}
			return false;
		}

		public bool RemovePiece(Piece piece)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			ZNetView nview = piece.m_nview;
			ZDOID? val = ((nview == null) ? ((ZDOID?)null) : nview.GetZDO()?.m_uid);
			if (val.HasValue && SelectedZDOIDs.Remove(val.Value))
			{
				Unhighlight(val.Value, ((Component)piece).gameObject);
				if (((Object)piece).name.StartsWith("piece_bpsnappoint", StringComparison.Ordinal))
				{
					SnapPoints--;
				}
				else if (((Object)piece).name.StartsWith("piece_bpcenterpoint", StringComparison.Ordinal))
				{
					CenterMarkers--;
				}
				else if (((Object)piece).name.StartsWith("piece_bpterrainmod", StringComparison.Ordinal))
				{
					TerrainMods--;
				}
				return true;
			}
			return false;
		}

		public void RemovePiecesInRadius(Vector3 worldPos, float radius, bool onlyPlanned = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(worldPos.x, worldPos.z);
			foreach (Piece s_allPiece in Piece.s_allPieces)
			{
				Vector3 position = ((Component)s_allPiece).transform.position;
				if (Vector2.Distance(val, new Vector2(position.x, position.z)) <= radius && BlueprintManager.CanCapture(s_allPiece, onlyPlanned))
				{
					RemovePiece(s_allPiece);
				}
			}
		}

		public void Clear()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			using (IEnumerator<ZDOID> enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					ZDOID current = enumerator.Current;
					GameObject gameObject = BlueprintManager.GetGameObject(current);
					Unhighlight(current, gameObject);
				}
			}
			SnapPoints = 0;
			CenterMarkers = 0;
			TerrainMods = 0;
			SelectedZDOIDs.Clear();
		}

		public void AddGrowFromPiece(Piece piece)
		{
			((MonoBehaviour)PlanBuildPlugin.Instance).StartCoroutine(Start(piece));
			IEnumerator Start(Piece originalPiece)
			{
				yield return null;
				Queue<Piece> workingSet = new Queue<Piece>();
				workingSet.Enqueue(originalPiece);
				int n = 0;
				while (workingSet.Any())
				{
					Piece piece2 = workingSet.Dequeue();
					AddPiece(piece2);
					n++;
					foreach (Piece supportingPiece in GetSupportingPieces(piece2))
					{
						if (!Contains(supportingPiece) && !workingSet.Contains(supportingPiece))
						{
							workingSet.Enqueue(supportingPiece);
						}
					}
					if (n >= 50)
					{
						n = 0;
						yield return null;
					}
				}
			}
		}

		public void RemoveGrowFromPiece(Piece piece)
		{
			((MonoBehaviour)PlanBuildPlugin.Instance).StartCoroutine((IEnumerator)RemoveGrowIterator(piece));
			IEnumerator<YieldInstruction> RemoveGrowIterator(Piece originalPiece)
			{
				yield return null;
				Queue<Piece> workingSet = new Queue<Piece>();
				workingSet.Enqueue(originalPiece);
				int n = 0;
				while (workingSet.Any())
				{
					Piece piece2 = workingSet.Dequeue();
					RemovePiece(piece2);
					n++;
					foreach (Piece supportingPiece in GetSupportingPieces(piece2))
					{
						if (Contains(supportingPiece) && !workingSet.Contains(supportingPiece))
						{
							workingSet.Enqueue(supportingPiece);
						}
					}
					if (n >= 50)
					{
						n = 0;
						yield return null;
					}
				}
			}
		}

		private HashSet<Piece> GetSupportingPieces(Piece piece)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			HashSet<Piece> hashSet = new HashSet<Piece>();
			Vector3 val = Vector3.one * Config.SelectionConnectedMarginConfig.Value;
			WearNTear val2 = default(WearNTear);
			if (((Component)piece).TryGetComponent<WearNTear>(ref val2))
			{
				if (val2.m_bounds == null)
				{
					val2.SetupColliders();
				}
				foreach (BoundData bound in val2.m_bounds)
				{
					int num = Physics.OverlapBoxNonAlloc(bound.m_pos, bound.m_size + val, WearNTear.s_tempColliders, bound.m_rot, GrowMask);
					for (int i = 0; i < num; i++)
					{
						Collider val3 = WearNTear.s_tempColliders[i];
						if (!val2.m_colliders.Contains(val3) && !((Object)(object)val3.attachedRigidbody != (Object)null) && !val3.isTrigger)
						{
							Piece componentInParent = ((Component)val3).GetComponentInParent<Piece>();
							if (!((Object)(object)componentInParent == (Object)null))
							{
								hashSet.Add(componentInParent);
							}
						}
					}
				}
			}
			return hashSet;
		}

		public void StartHighlightSelection()
		{
			((MonoBehaviour)PlanBuildPlugin.Instance).StartCoroutine(Start());
			IEnumerator Start()
			{
				yield return null;
				if (UnhighlightCoroutine != null)
				{
					((MonoBehaviour)PlanBuildPlugin.Instance).StopCoroutine(UnhighlightCoroutine);
					UnhighlightCoroutine = null;
				}
				int n = 0;
				foreach (ZDOID item in new List<ZDOID>(this))
				{
					if (SelectedZDOIDs.Contains(item))
					{
						GameObject gameObject = BlueprintManager.GetGameObject(item);
						Highlight(item, gameObject);
						if (n++ >= 50)
						{
							n = 0;
							yield return null;
						}
					}
				}
			}
		}

		public void StopHighlightSelection()
		{
			if (UnhighlightCoroutine == null)
			{
				UnhighlightCoroutine = ((MonoBehaviour)PlanBuildPlugin.Instance).StartCoroutine(Stop());
			}
			IEnumerator Stop()
			{
				yield return null;
				yield return null;
				int n = 0;
				foreach (ZDOID item in new List<ZDOID>(HighlightedZDOIDs))
				{
					GameObject gameObject = BlueprintManager.GetGameObject(item);
					Unhighlight(item, gameObject);
					if (n++ >= 50)
					{
						n = 0;
						yield return null;
					}
				}
				UnhighlightCoroutine = null;
			}
		}

		public void Highlight(ZDOID zdoid, GameObject selected)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			WearNTear self = default(WearNTear);
			if (!HighlightedZDOIDs.Contains(zdoid) && Object.op_Implicit((Object)(object)selected) && selected.TryGetComponent<WearNTear>(ref self))
			{
				self.Highlight(Color.green);
				HighlightedZDOIDs.Add(zdoid);
			}
		}

		public void Unhighlight(ZDOID zdoid, GameObject gameObject)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (HighlightedZDOIDs.Contains(zdoid))
			{
				WearNTear val = default(WearNTear);
				if (Object.op_Implicit((Object)(object)gameObject) && gameObject.TryGetComponent<WearNTear>(ref val))
				{
					val.ResetHighlight();
				}
				HighlightedZDOIDs.Remove(zdoid);
			}
		}

		public bool IsHighlighted(Piece piece)
		{
			return IsHighlighted(piece?.GetZDOID());
		}

		public bool IsHighlighted(ZDOID? zdoid)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (zdoid.HasValue)
			{
				return HighlightedZDOIDs.Contains(zdoid.Value);
			}
			return false;
		}

		internal void OnPieceAwake(Piece piece)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			ZDOID? zDOID = piece.GetZDOID();
			if (zDOID.HasValue)
			{
				bool flag = SelectedZDOIDs.Contains(zDOID.Value);
				if (flag && !IsHighlighted(piece))
				{
					Highlight(zDOID.Value, ((Component)piece).gameObject);
				}
				if (flag)
				{
					AttachListener(piece);
				}
			}
		}

		private void AttachListener(Piece piece)
		{
			WearNTear wearNTear = default(WearNTear);
			if (((Component)piece).TryGetComponent<WearNTear>(ref wearNTear))
			{
				WearNTear obj = wearNTear;
				obj.m_onDestroyed = (Action)Delegate.Combine(obj.m_onDestroyed, (Action)delegate
				{
					OnWearNTearDestroyed(wearNTear);
				});
			}
		}

		internal void OnPieceUnload(Piece piece)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (Contains(piece))
			{
				ZDOID uid = piece.m_nview.GetZDO().m_uid;
				HighlightedZDOIDs.Remove(uid);
			}
		}

		private void OnWearNTearDestroyed(WearNTear wearNTear)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			ZDOID? zDOID = wearNTear.GetZDOID();
			if (zDOID.HasValue)
			{
				SelectedZDOIDs.Remove(zDOID.Value);
				HighlightedZDOIDs.Remove(zDOID.Value);
				if (((Object)wearNTear).name.StartsWith("piece_bpsnappoint", StringComparison.Ordinal))
				{
					SnapPoints--;
				}
				else if (((Object)wearNTear).name.StartsWith("piece_bpcenterpoint", StringComparison.Ordinal))
				{
					CenterMarkers--;
				}
				else if (((Object)wearNTear).name.StartsWith("piece_bpterrainmod", StringComparison.Ordinal))
				{
					TerrainMods--;
				}
			}
		}

		public int GetPieceCount()
		{
			return Instance.Count() - SnapPoints - CenterMarkers - TerrainMods;
		}

		public override string ToString()
		{
			string empty = string.Empty;
			empty += Localization.instance.Localize("$piece_blueprint_select_desc", new string[1] { GetPieceCount().ToString() });
			empty += Localization.instance.Localize("\n$piece_blueprint_select_snappoints_desc", new string[1] { SnapPoints.ToString() });
			empty += Localization.instance.Localize("\n$piece_blueprint_select_center_desc", new string[1] { CenterMarkers.ToString() });
			return empty + Localization.instance.Localize("\n$piece_blueprint_select_terrainmod_desc", new string[1] { TerrainMods.ToString() });
		}
	}
	internal enum BlueprintLocation
	{
		Local,
		Temporary,
		Server,
		All
	}
	public class PieceEntry
	{
		public string line;

		public string name;

		public string category;

		public float posX;

		public float posY;

		public float posZ;

		public float rotX;

		public float rotY;

		public float rotZ;

		public float rotW;

		public string additionalInfo;

		public float scaleX;

		public float scaleY;

		public float scaleZ;

		public static PieceEntry FromBlueprint(string line)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			if (line.IndexOf(',') > -1)
			{
				line = line.Replace(',', '.');
			}
			string[] array = line.Split(new char[1] { ';' });
			string text = array[0];
			string text2 = array[1];
			float num = InvariantFloat(array[2]);
			float num2 = InvariantFloat(array[3]);
			float num3 = InvariantFloat(array[4]);
			float num4 = InvariantFloat(array[5]);
			float num5 = InvariantFloat(array[6]);
			float num6 = InvariantFloat(array[7]);
			float num7 = InvariantFloat(array[8]);
			Vector3 pos = default(Vector3);
			((Vector3)(ref pos))..ctor(num, num2, num3);
			Quaternion val = new Quaternion(num4, num5, num6, num7);
			Quaternion normalized = ((Quaternion)(ref val)).normalized;
			string text3 = array[9];
			if (string.IsNullOrEmpty(text3) || text3.Equals("\"\""))
			{
				text3 = null;
			}
			else
			{
				try
				{
					text3 = SimpleJson.DeserializeObject<string>(text3);
				}
				catch
				{
					text3 = array[9];
				}
			}
			Vector3 one = Vector3.one;
			if (array.Length > 10)
			{
				float num8 = InvariantFloat(array[10]);
				float num9 = InvariantFloat(array[11]);
				float num10 = InvariantFloat(array[12]);
				((Vector3)(ref one))..ctor(num8, num9, num10);
			}
			return new PieceEntry(text, text2, pos, normalized, text3, one);
		}

		public static PieceEntry FromVBuild(string line)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (line.IndexOf(',') > -1)
			{
				line = line.Replace(',', '.');
			}
			string[] array = line.Split(new char[1] { ' ' });
			string text = array[0];
			float num = InvariantFloat(array[1]);
			float num2 = InvariantFloat(array[2]);
			float num3 = InvariantFloat(array[3]);
			float num4 = InvariantFloat(array[4]);
			float num5 = InvariantFloat(array[5]);
			float num6 = InvariantFloat(array[6]);
			float num7 = InvariantFloat(array[7]);
			string text2 = "Building";
			Quaternion val = new Quaternion(num, num2, num3, num4);
			Quaternion normalized = ((Quaternion)(ref val)).normalized;
			Vector3 pos = default(Vector3);
			((Vector3)(ref pos))..ctor(num5, num6, num7);
			string empty = string.Empty;
			return new PieceEntry(text, text2, pos, normalized, empty, Vector3.one);
		}

		public PieceEntry(string name, string category, Vector3 pos, Quaternion rot, string additionalInfo, Vector3 scale)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			this.name = name.Split(new char[1] { '(' })[0];
			this.category = category;
			posX = pos.x;
			posY = pos.y;
			posZ = pos.z;
			rotX = rot.x;
			rotY = rot.y;
			rotZ = rot.z;
			rotW = rot.w;
			this.additionalInfo = additionalInfo;
			if (!string.IsNullOrEmpty(this.additionalInfo))
			{
				this.additionalInfo = string.Concat(this.additionalInfo.Split(new char[1] { ';' }));
			}
			scaleX = scale.x;
			scaleY = scale.y;
			scaleZ = scale.z;
			line = string.Join(";", this.name, this.category, InvariantString(posX), InvariantString(posY), InvariantString(posZ), InvariantString(rotX), InvariantString(rotY), InvariantString(rotZ), InvariantString(rotW), SimpleJson.SerializeObject((object)additionalInfo), InvariantString(scaleX), InvariantString(scaleY), InvariantString(scaleZ));
		}

		public Vector3 GetPosition()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(posX, posY, posZ);
		}

		public Quaternion GetRotation()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion(rotX, rotY, rotZ, rotW);
		}

		public Vector3 GetScale()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(scaleX, scaleY, scaleZ);
		}

		internal static float InvariantFloat(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return 0f;
			}
			return float.Parse(s, NumberStyles.Any, NumberFormatInfo.InvariantInfo);
		}

		internal static string InvariantString(float f)
		{
			return f.ToString(NumberFormatInfo.InvariantInfo);
		}
	}
	public class SnapPointEntry
	{
		public string line;

		public float posX;

		public float posY;

		public float posZ;

		public SnapPointEntry(string line)
		{
			this.line = line;
			string[] array = line.Split(new char[1] { ';' });
			posX = InvariantFloat(array[0]);
			posY = InvariantFloat(array[1]);
			posZ = InvariantFloat(array[2]);
		}

		public SnapPointEntry(Vector3 pos)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			line = string.Join(";", InvariantString(pos.x), InvariantString(pos.y), InvariantString(pos.z));
			posX = pos.x;
			posY = pos.y;
			posZ = pos.z;
		}

		public Vector3 GetPosition()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(posX, posY, posZ);
		}

		internal static string InvariantString(float f)
		{
			return f.ToString(NumberFormatInfo.InvariantInfo);
		}

		internal static float InvariantFloat(string s)
		{
			if (s.StartsWith("-,"))
			{
				s = s.Replace("-,", "-0,");
			}
			else if (s.StartsWith(","))
			{
				s = "0" + s;
			}
			return float.Parse(s, NumberStyles.Float, NumberFormatInfo.InvariantInfo);
		}
	}
	public class UIDragDrop : MonoBehaviour, IDragHandler, IEventSystemHandler
	{
		private Canvas canvas;

		private RectTransform rectTransform;

		private void Awake()
		{
			ref RectTransform reference = ref rectTransform;
			Transform transform = ((Component)this).transform;
			reference = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			Transform parent = ((Component)this).transform.parent;
			do
			{
				canvas = ((Component)parent).GetComponent<Canvas>();
				parent = parent.parent;
			}
			while ((Object)(object)canvas == (Object)null);
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			RectTransform obj = rectTransform;
			obj.anchoredPosition += eventData.delta / canvas.scaleFactor;
		}
	}
	internal class BlueprintGUI
	{
		private class CloseGUIBehaviour : MonoBehaviour
		{
			private void Update()
			{
				if (IsVisible() && Input.GetKeyUp((KeyCode)27))
				{
					Instance.Window.SetActive(false);
					GUIManager.BlockInput(false);
				}
			}
		}

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

			public static Func<KeyValuePair<string, Blueprint>, string> <>9__32_0;

			public static Func<IGrouping<string, KeyValuePair<string, Blueprint>>, string> <>9__32_1;

			public static Func<KeyValuePair<string, Blueprint>, string> <>9__32_2;

			public static Func<KeyValuePair<string, Blueprint>, string> <>9__32_3;

			public static Func<KeyValuePair<string, Blueprint>, string> <>9__32_4;

			public static Func<IGrouping<string, KeyValuePair<string, Blueprint>>, string> <>9__32_5;

			public static Func<KeyValuePair<string, Blueprint>, string> <>9__32_6;

			public static Action<bool, string> <>9__34_0;

			public static Action<bool, string> <>9__36_0;

			public static Action<bool, string> <>9__37_0;

			public static Action<bool, string> <>9__38_0;

			public static UnityAction <>9__40_0;

			public static UnityAction <>9__40_1;

			public static UnityAction <>9__40_2;

			internal string <RefreshBlueprints>b__32_0(KeyValuePair<string, Blueprint> x)
			{
				return x.Value.Category;
			}

			internal string <RefreshBlueprints>b__32_1(IGrouping<string, KeyValuePair<string, Blueprint>> x)
			{
				return x.Key;
			}

			internal string <RefreshBlueprints>b__32_2(KeyValuePair<string, Blueprint> x)
			{
				return x.Value.Name;
			}

			internal string <RefreshBlueprints>b__32_3(KeyValuePair<string, Blueprint> x)
			{
				return x.Value.Name;
			}

			internal string <RefreshBlueprints>b__32_4(KeyValuePair<string, Blueprint> x)
			{
				return x.Value.Category;
			}

			internal string <RefreshBlueprints>b__32_5(IGrouping<string, KeyValuePair<string, Blueprint>> x)
			{
				return x.Key;
			}

			internal string <RefreshBlueprints>b__32_6(KeyValuePair<string, Blueprint> x)
			{
				return x.Value.Name;
			}

			internal void <ReloadBlueprints>b__34_0(bool success, string message)
			{
				Instance.ActionAppliedOverlay.SetResult(success, message);
			}

			internal void <SaveBlueprint>b__36_0(bool success, string message)
			{
				Instance.ActionAppliedOverlay.SetResult(success, message);
			}

			internal void <TransferBlueprint>b__37_0(bool success, string message)
			{
				Instance.ActionAppliedOverlay.SetResult(success, message);
			}

			internal void <DeleteBlueprint>b__38_0(bool success, string message)
			{
				Instance.ActionAppliedOverlay.SetResult(success, message);
			}

			internal void <Register>b__40_0()
			{
				ShowTab(BlueprintLocation.Local);
			}

			internal void <Register>b__40_1()
			{
				ShowTab(BlueprintLocation.Temporary);
			}

			internal void <Register>b__40_2()
			{
				ShowTab(BlueprintLocation.Server);
			}
		}

		public static BlueprintGUI Instance;

		private GameObject Prefab;

		public GameObject Window { get; set; }

		public ActionAppliedOverlay ActionAppliedOverlay { get; set; }

		public BlueprintTab CurrentTab { get; set; }

		public BlueprintTab LocalTab { get; set; } = new BlueprintTab();

		public BlueprintTab ClipboardTab { get; set; } = new BlueprintTab();

		public BlueprintTab ServerTab { get; set; } = new BlueprintTab();

		public static void Init(GameObject prefab)
		{
			if (!GUIManager.IsHeadless())
			{
				Instance = new BlueprintGUI();
				Instance.Prefab = prefab;
				GUIManager.OnCustomGUIAvailable += Instance.Register;
			}
		}

		public static bool IsAvailable()
		{
			if (Instance != null)
			{
				return (Object)(object)Instance.Window != (Object)null;
			}
			return false;
		}

		public static bool IsVisible()
		{
			if (IsAvailable())
			{
				return Instance.Window.activeSelf;
			}
			return false;
		}

		public static bool TextFieldHasFocus()
		{
			if (Instance.CurrentTab == null)
			{
				return false;
			}
			if (!Instance.CurrentTab.DetailDisplay.Name.isFocused && !Instance.CurrentTab.DetailDisplay.Category.isFocused)
			{
				return Instance.CurrentTab.DetailDisplay.Description.isFocused;
			}
			return true;
		}

		public static void ShowTab(BlueprintLocation location)
		{
			if (IsAvailable())
			{
				Instance.LocalTab.TabElements.TabContent.SetActive(location == BlueprintLocation.Local);
				Instance.ClipboardTab.TabElements.TabContent.SetActive(location == BlueprintLocation.Temporary);
				Instance.ServerTab.TabElements.TabContent.SetActive(location == BlueprintLocation.Server);
				switch (location)
				{
				case BlueprintLocation.Local:
					Instance.CurrentTab = Instance.LocalTab;
					break;
				case BlueprintLocation.Temporary:
					Instance.CurrentTab = Instance.ClipboardTab;
					break;
				case BlueprintLocation.Server:
					Instance.CurrentTab = Instance.ServerTab;
					break;
				}
			}
		}

		public static void ClearBlueprints(BlueprintLocation location)
		{
			if (!IsAvailable())
			{
				return;
			}
			if (location == BlueprintLocation.Local || location == BlueprintLocation.All)
			{
				foreach (GameObject category in Instance.LocalTab.ListDisplay.Categories)
				{
					Object.DestroyImmediate((Object)(object)category);
				}
				foreach (BlueprintDetailContent blueprint in Instance.LocalTab.ListDisplay.Blueprints)
				{
					Object.DestroyImmediate((Object)(object)blueprint.ContentHolder);
				}
				Instance.LocalTab.ListDisplay.Categories.Clear();
				Instance.LocalTab.ListDisplay.Blueprints.Clear();
				Instance.LocalTab.DetailDisplay.Clear();
			}
			if (location == BlueprintLocation.Temporary || location == BlueprintLocation.All)
			{
				foreach (GameObject category2 in Instance.ClipboardTab.ListDisplay.Categories)
				{
					Object.DestroyImmediate((Object)(object)category2);
				}
				foreach (BlueprintDetailContent blueprint2 in Instance.ClipboardTab.ListDisplay.Blueprints)
				{
					Object.DestroyImmediate((Object)(object)blueprint2.ContentHolder);
				}
				Instance.ClipboardTab.ListDisplay.Categories.Clear();
				Instance.ClipboardTab.ListDisplay.Blueprints.Clear();
				Instance.ClipboardTab.DetailDisplay.Clear();
			}
			if (location != BlueprintLocation.Server && location != BlueprintLocation.All)
			{
				return;
			}
			foreach (GameObject category3 in Instance.ServerTab.ListDisplay.Categories)
			{
				Object.DestroyImmediate((Object)(object)category3);
			}
			foreach (BlueprintDetailContent blueprint3 in Instance.ServerTab.ListDisplay.Blueprints)
			{
				Object.DestroyImmediate((Object)(object)blueprint3.ContentHolder);
			}
			Instance.ServerTab.ListDisplay.Categories.Clear();
			Instance.ServerTab.ListDisplay.Blueprints.Clear();
			Instance.ServerTab.DetailDisplay.Clear();
		}

		public static void RefreshBlueprints(BlueprintLocation location)
		{
			if (!IsAvailable())
			{
				return;
			}
			ClearBlueprints(location);
			if (location == BlueprintLocation.Local || location == BlueprintLocation.All)
			{
				foreach (IGrouping<string, KeyValuePair<string, Blueprint>> item in from x in BlueprintManager.LocalBlueprints
					group x by x.Value.Category into x
					orderby x.Key
					select x)
				{
					Instance.LocalTab.ListDisplay.AddCategory(item.Key);
					foreach (KeyValuePair<string, Blueprint> item2 in item.OrderBy((KeyValuePair<string, Blueprint> x) => x.Value.Name))
					{
						Instance.LocalTab.ListDisplay.AddBlueprint(item2.Key, item2.Value);
					}
				}
			}
			if (location == BlueprintLocation.Temporary || location == BlueprintLocation.All)
			{
				foreach (KeyValuePair<string, Blueprint> item3 in BlueprintManager.TemporaryBlueprints.OrderBy((KeyValuePair<string, Blueprint> x) => x.Value.Name))
				{
					Instance.ClipboardTab.ListDisplay.AddBlueprint(item3.Key, item3.Value);
				}
			}
			if (location != BlueprintLocation.Server && location != BlueprintLocation.All)
			{
				return;
			}
			foreach (IGrouping<string, KeyValuePair<string, Blueprint>> item4 in from x in BlueprintManager.ServerBlueprints
				group x by x.Value.Category into x
				orderby x.Key
				select x)
			{
				Instance.ServerTab.ListDisplay.AddCategory(item4.Key);
				foreach (KeyValuePair<string, Blueprint> item5 in item4.OrderBy((KeyValuePair<string, Blueprint> x) => x.Value.Name))
				{
					Instance.ServerTab.ListDisplay.AddBlueprint(item5.Key, item5.Value);
				}
			}
		}

		public void Toggle(bool shutWindow = false, bool openWindow = false)
		{
			bool flag = !shutWindow && (openWindow || !Window.activeSelf);
			Window.SetActive(flag);
			GUIManager.BlockInput(flag);
		}

		public void ReloadBlueprints(BlueprintLocation originTab)
		{
			switch (originTab)
			{
			case BlueprintLocation.Local:
				BlueprintSync.GetLocalBlueprints();
				break;
			case BlueprintLocation.Server:
				Instance.ActionAppliedOverlay.Show();
				BlueprintSync.GetServerBlueprints(delegate(bool success, string message)
				{
					Instance.ActionAppliedOverlay.SetResult(success, message);
				}, useCache: false);
				break;
			}
		}

		public void ShowBlueprint(BlueprintDetailContent blueprint, BlueprintLocation originTab)
		{
			BlueprintTab blueprintTab = null;
			switch (originTab)
			{
			case BlueprintLocation.Local:
				blueprintTab = Instance.LocalTab;
				break;
			case BlueprintLocation.Temporary:
				blueprintTab = Instance.ClipboardTab;
				break;
			case BlueprintLocation.Server:
				blueprintTab = Instance.ServerTab;
				break;
			}
			blueprintTab?.DetailDisplay.SetActive(blueprint);
		}

		public void SaveBlueprint(BlueprintDetailContent detail, BlueprintLocation originTab)
		{
			switch (originTab)
			{
			case BlueprintLocation.Local:
			{
				if (detail != null && BlueprintManager.LocalBlueprints.TryGetValue(detail.ID, out var value2))
				{
					value2.Name = (string.IsNullOrEmpty(detail.Name) ? value2.Name : detail.Name);
					value2.Category = (string.IsNullOrEmpty(detail.Category) ? "Blueprints" : detail.Category);
					value2.Description = detail.Description;
					BlueprintSync.SaveLocalBlueprint(value2.ID);
				}
				break;
			}
			case BlueprintLocation.Temporary:
			{
				if (detail != null && BlueprintManager.TemporaryBlueprints.TryGetValue(detail.ID, out var value3))
				{
					string name = (string.IsNullOrEmpty(detail.Name) ? value3.Name : detail.Name);
					string category = ((string.IsNullOrEmpty(detail.Category) || detail.Category.Equals("Clipboard")) ? "Blueprints" : detail.Category);
					string description = detail.Description;
					BlueprintSync.SaveTempBlueprint(value3.ID, name, category, description);
				}
				break;
			}
			case BlueprintLocation.Server:
			{
				if (detail != null && BlueprintManager.ServerBlueprints.TryGetValue(detail.ID, out var value))
				{
					value.Name = (string.IsNullOrEmpty(detail.Name) ? value.Name : detail.Name);
					value.Category = (string.IsNullOrEmpty(detail.Category) ? "Blueprints" : detail.Category);
					value.Description = detail.Description;
					Instance.ActionAppliedOverlay.Show();
					BlueprintSync.PushServerBlueprint(value.ID, delegate(bool success, string message)
					{
						Instance.ActionAppliedOverlay.SetResult(success, message);
					});
				}
				break;
			}
			}
		}

		public void TransferBlueprint(BlueprintDetailContent detail, BlueprintLocation originTab)
		{
			switch (originTab)
			{
			case BlueprintLocation.Local:
				if (detail != null && BlueprintManager.LocalBlueprints.ContainsKey(detail.ID))
				{
					Instance.ActionAppliedOverlay.Show();
					BlueprintSync.PushLocalBlueprint(detail.ID, delegate(bool success, string message)
					{
						Instance.ActionAppliedOverlay.SetResult(success, message);
					});
				}
				break;
			case BlueprintLocation.Server:
				if (detail != null && BlueprintManager.ServerBlueprints.ContainsKey(detail.ID))
				{
					BlueprintSync.SaveServerBlueprint(detail.ID);
				}
				break;
			}
		}

		public void DeleteBlueprint(BlueprintDetailContent detail, BlueprintLocation originTab)
		{
			switch (originTab)
			{
			case BlueprintLocation.Local:
				if (detail != null && BlueprintManager.LocalBlueprints.ContainsKey(detail.ID))
				{
					BlueprintSync.RemoveLocalBlueprint(detail.ID);
				}
				break;
			case BlueprintLocation.Temporary:
				if (detail != null && BlueprintManager.TemporaryBlueprints.ContainsKey(detail.ID))
				{
					BlueprintSync.RemoveTempBlueprint(detail.ID);
				}
				break;
			case BlueprintLocation.Server:
				if (detail != null && BlueprintManager.ServerBlueprints.ContainsKey(detail.ID))
				{
					Instance.ActionAppliedOverlay.Show();
					BlueprintSync.RemoveServerBlueprint(detail.ID, delegate(bool success, string message)
					{
						Instance.ActionAppliedOverlay.SetResult(success, message);
					});
				}
				break;
			}
		}

		public void CreateThumbnail(BlueprintDetailContent detail, BlueprintLocation originTab)
		{
			switch (originTab)
			{
			case BlueprintLocation.Local:
			{
				if (detail != null && BlueprintManager.LocalBlueprints.TryGetValue(detail.ID, out var value3))
				{
					((MonoBehaviour)PlanBuildPlugin.Instance).StartCoroutine(CreateRoutine(value3));
				}
				break;
			}
			case BlueprintLocation.Temporary:
			{
				if (detail != null && BlueprintManager.TemporaryBlueprints.TryGetValue(detail.ID, out var value2))
				{
					((MonoBehaviour)PlanBuildPlugin.Instance).StartCoroutine(CreateRoutine(value2));
				}
				break;
			}
			case BlueprintLocation.Server:
			{
				if (detail != null && BlueprintManager.ServerBlueprints.TryGetValue(detail.ID, out var value))
				{
					((MonoBehaviour)PlanBuildPlugin.Instance).StartCoroutine(CreateRoutine(value));
				}
				break;
			}
			}
			IEnumerator CreateRoutine(Blueprint bp)
			{
				yield return null;
				bp.CreatePiece();
				yield return null;
				bp.InstantiateGhost();
				yield return null;
				bp.CreateThumbnail(detail.AdditionalRotation, flush: false);
				detail.Icon = Sprite.Create(bp.Thumbnail, new Rect(0f, 0f, (float)((Texture)bp.Thumbnail).width, (float)((Texture)bp.Thumbnail).height), Vector2.zero);
				ShowBlueprint(detail, originTab);
			}
		}

		public void Register()
		{
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Expected O, but got Unknown
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Expected O, but got Unknown
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)Window))
			{
				return;
			}
			Logger.LogDebug((object)"Recreating BlueprintGUI");
			Window = Object.Instantiate<GameObject>(Prefab, GUIManager.CustomGUIFront.transform);
			Window.AddComponent<DragWindowCntrl>();
			Image component = Window.GetComponent<Image>();
			component.sprite = GUIManager.Instance.GetSprite("woodpanel_settings");
			component.type = (Type)1;
			((Graphic)component).material = Cache.GetPrefab<Material>("litpanel");
			Text[] componentsInChildren = Window.GetComponentsInChildren<Text>(true);
			foreach (Text val in componentsInChildren)
			{
				val.font = GUIManager.Instance.AveriaSerif;
			}
			InputField[] componentsInChildren2 = Window.GetComponentsInChildren<InputField>(true);
			foreach (InputField val2 in componentsInChildren2)
			{
				GUIManager.Instance.ApplyInputFieldStyle(val2, 16);
			}
			Button[] componentsInChildren3 = Window.GetComponentsInChildren<Button>(true);
			foreach (Button val3 in componentsInChildren3)
			{
				if (!((Object)val3).name.Equals("ListEntry", StringComparison.Ordinal))
				{
					GUIManager.Instance.ApplyButtonStyle(val3, 16);
					if (((Object)val3).name.Equals("CreateThumbnail", StringComparison.Ordinal))
					{
						((Component)val3).GetComponentInChildren<Text>(true).fontSize = 13;
					}
				}
			}
			ScrollRect[] componentsInChildren4 = Window.GetComponentsInChildren<ScrollRect>(true);
			foreach (ScrollRect val4 in componentsInChildren4)
			{
				GUIManager.Instance.ApplyScrollRectStyle(val4);
			}
			try
			{
				ActionAppliedOverlay = new ActionAppliedOverlay();
				ActionAppliedOverlay.Register(Window.transform.Find("ActionAppliedOverlay"));
			}
			catch (Exception arg)
			{
				Logger.LogDebug((object)$"Failed in the action overlay: {arg}");
			}
			try
			{
				LocalTab.TabElements.Register(Window.transform, "Local", "$gui_bpmarket_localblueprints");
				if ((Object)(object)LocalTab.TabElements.TabContent.transform == (Object)null)
				{
					Logger.LogFatal((object)"Tabcontent is null");
				}
				LocalTab.ListDisplay.Register(LocalTab.TabElements.TabContent.transform, BlueprintLocation.Local);
				LocalTab.DetailDisplay.Register(LocalTab.TabElements.TabContent.transform, BlueprintLocation.Local);
				ButtonClickedEvent onClick = LocalTab.TabElements.TabButton.onClick;
				object obj = <>c.<>9__40_0;
				if (obj == null)
				{
					UnityAction val5 = delegate
					{
						ShowTab(BlueprintLocation.Local);
					};
					<>c.<>9__40_0 = val5;
					obj = (object)val5;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
			}
			catch (Exception arg2)
			{
				Logger.LogDebug((object)$"Failed in LocalTab: {arg2}");
			}
			try
			{
				ClipboardTab.TabElements.Register(Window.transform, "Clipboard", "$gui_bpmarket_clipboardblueprints");
				ClipboardTab.ListDisplay.Register(ClipboardTab.TabElements.TabContent.transform, BlueprintLocation.Temporary);
				ClipboardTab.DetailDisplay.Register(ClipboardTab.TabElements.TabContent.transform, BlueprintLocation.Temporary);
				ButtonClickedEvent onClick2 = ClipboardTab.TabElements.TabButton.onClick;
				object obj2 = <>c.<>9__40_1;
				if (obj2 == null)
				{
					UnityAction val6 = delegate
					{
						ShowTab(BlueprintLocation.Temporary);
					};
					<>c.<>9__40_1 = val6;
					obj2 = (object)val6;
				}
				((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			}
			catch (Exception arg3)
			{
				Logger.LogDebug((object)$"Failed in ClipboardTab: {arg3}");
			}
			try
			{
				ServerTab.TabElements.Register(Window.transform, "Server", "$gui_bpmarket_serverblueprints");
				ServerTab.ListDisplay.Register(ServerTab.TabElements.TabContent.transform, BlueprintLocation.Server);
				ServerTab.DetailDisplay.Register(ServerTab.TabElements.TabContent.transform, BlueprintLocation.Server);
				ButtonClickedEvent onClick3 = ServerTab.TabElements.TabButton.onClick;
				object obj3 = <>c.<>9__40_2;
				if (obj3 == null)
				{
					UnityAction val7 = delegate
					{
						ShowTab(BlueprintLocation.Server);
					};
					<>c.<>9__40_2 = val7;
					obj3 = (object)val7;
				}
				((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			}
			catch (Exception arg4)
			{
				Logger.LogDebug((object)$"Failed in ServerTab: {arg4}");
			}
			Localization.instance.Localize(Instance.Window.transform);
			Instance.Window.AddComponent<CloseGUIBehaviour>();
			ShowTab(BlueprintLocation.Local);
			RefreshBlueprints(BlueprintLocation.All);
			Window.SetActive(false);
		}
	}
	internal class BlueprintTab
	{
		public BlueprintTabElements TabElements { get; set; } = new BlueprintTabElements();

		public BlueprintListDisplay ListDisplay { get; set; } = new BlueprintListDisplay();

		public BlueprintDetailDisplay DetailDisplay { get; set; } = new BlueprintDetailDisplay();
	}
	internal class BlueprintTabElements
	{
		public Transform TabTransform { get; set; }

		public Button TabButton { get; set; }

		public TMP_Text TabText { get; set; }

		public GameObject TabContent { get; set; }

		public void Register(Transform window, string tabName, string tabText)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = GUIManager.Instance.CreateButton(tabText, window.Find("Tabs"), Vector2.zero, Vector2.zero, Vector2.zero, 0f, 0f);
				((Object)val).name = tabName;
				TabTransform = val.transform;
				TabButton = val.GetComponent<Button>();
				TabText = ((Component)val.transform).GetComponentInChildren<TMP_Text>();
				TabContent = Object.Instantiate<GameObject>(((Component)window.Find("TabContent")).gameObject, window.Find("Content"));
				((Object)TabContent).name = tabName;
			}
			catch (Exception arg)
			{
				Logger.LogDebug((object)$"Failed in BlueprintTabElements: {arg}");
			}
		}
	}
	internal class BlueprintListDisplay
	{
		public BlueprintLocation TabType { get; set; }

		private GameObject BlueprintCategoryPrefab { get; set; }

		private GameObject BlueprintEntryPrefab { get; set; }

		public Transform ScrollContentParent { get; set; }

		public UIConfirmationOverlay ConfirmationOverlay { get; set; } = new UIConfirmationOverlay();

		public List<GameObject> Categories { get; set; } = new List<GameObject>();

		public List<BlueprintDetailContent> Blueprints { get; set; } = new List<BlueprintDetailContent>();

		public void AddCategory(string name)
		{
			try
			{
				GameObject val = Object.Instantiate<GameObject>(BlueprintCategoryPrefab, ScrollContentParent);
				val.SetActive(true);
				val.GetComponent<Text>().text = name;
				Categories.Add(val);
			}
			catch (Exception arg)
			{
				Logger.LogDebug((object)$"Failed to create new category: {arg}");
			}
		}

		public BlueprintDetailContent AddBlueprint(string id, Blueprint bp)
		{
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			if (Blueprints.Any((BlueprintDetailContent i) => i.ID == id))
			{
				Logger.LogDebug((object)$"Blueprint {id} already exists in {this}.");
				return null;
			}
			BlueprintDetailContent newBp = new BlueprintDetailContent();
			try
			{
				newBp.ContentHolder = Object.Instantiate<GameObject>(BlueprintEntryPrefab, ScrollContentParent);
				newBp.ContentHolder.SetActive(true);
				newBp.Button = newBp.ContentHolder.GetComponent<Button>();
				newBp.Text = ((Component)newBp.ContentHolder.transform.Find("Text")).GetComponent<Text>();
				newBp.ID = bp.ID;
				newBp.Name = bp.Name;
				newBp.Category = bp.Category;
				newBp.Creator = bp.Creator;
				newBp.Count = bp.GetPieceCount().ToString();
				newBp.SnapPoints = bp.GetSnapPointCount().ToString();
				newBp.TerrainMods = bp.GetTerrainModCount().ToString();
				newBp.Description = bp.Description;
				newBp.Text.text = bp.ToGUIString();
				if ((Object)(object)bp.Thumbnail != (Object)null)
				{
					newBp.Icon = Sprite.Create(bp.Thumbnail, new Rect(0f, 0f, (float)((Texture)bp.Thumbnail).width, (float)((Texture)bp.Thumbnail).height), Vector2.zero);
				}
				((UnityEvent)newBp.Button.onClick).AddListener((UnityAction)delegate
				{
					BlueprintGUI.Instance.ShowBlueprint(newBp, TabType);
				});
				newBp.AdditionalRotation = 0;
				Blueprints.Add(newBp);
			}
			catch (Exception arg)
			{
				Logger.LogDebug((object)$"Failed to load new blueprint: {arg}");
			}
			return newBp;
		}

		public BlueprintDetailContent RemoveBlueprint(string id)
		{
			BlueprintDetailContent blueprintDetailContent = Blueprints.FirstOrDefault((BlueprintDetailContent i) => i.ID == id);
			if (blueprintDetailContent != null)
			{
				Blueprints.Remove(blueprintDetailContent);
				Object.Destroy((Object)(object)blueprintDetailContent.ContentHolder);
				return blueprintDetailContent;
			}
			return null;
		}

		public void Register(Transform contentTransform, BlueprintLocation tabType)
		{
			TabType = tabType;
			try
			{
				BlueprintCategoryPrefab = ((Component)contentTransform.Find("List/ListCategory")).gameObject;
				BlueprintEntryPrefab = ((Component)contentTransform.Find("List/ListEntry")).gameObject;
				ScrollContentParent = contentTransform.Find("List/Viewport/Content");
				ConfirmationOverlay = new UIConfirmationOverlay();
				Transform overlayTransform = contentTransform.Find("ConfirmationOverlay");
				ConfirmationOverlay.Register(overlayTransform);
			}
			catch (Exception arg)
			{
				Logger.LogDebug((object)$"Failed in BlueprintListDisplay: {arg}");
			}
		}
	}
	internal class BlueprintDetailDisplay
	{
		public Button CreateThumbnailButton;

		public Button RotateLeftButton;

		public Button RotateRightButton;

		public BlueprintLocation TabType { get; set; }

		public BlueprintDetailContent SelectedBlueprintDetail { get; set; }

		public Text ID { get; set; }

		public Text Creator { get; set; }

		public Text Count { get; set; }

		public Text SnapPoints { get; set; }

		public Text TerrainMods { get; set; }

		public Image Icon { get; set; }

		public InputField Name { get; set; }

		public InputField Category { get; set; }

		public InputField Description { get; set; }

		public Button ReloadButton { get; set; }

		public Button SaveButton { get; set; }

		public Button TransferButton { get; set; }

		public Button DeleteButton { get; set; }

		public UIConfirmationOverlay ConfirmationOverlay { get; set; } = new UIConfirmationOverlay();

		public void SetActive(BlueprintDetailContent blueprint)
		{
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Expected O, but got Unknown
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Expected O, but got Unknown
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Expected O, but got Unknown
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Expected O, but got Unknown
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Expected O, but got Unknown
			if (ConfirmationOverlay.IsVisible())
			{
				return;
			}
			SelectedBlueprintDetail = blueprint;
			((UnityEventBase)Name.onEndEdit).RemoveAllListeners();
			((UnityEventBase)Category.onEndEdit).RemoveAllListeners();
			((UnityEventBase)Description.onEndEdit).RemoveAllListeners();
			ID.text = blueprint.ID;
			Creator.text = blueprint.Creator;
			Count.text = blueprint.Count;
			SnapPoints.text = blueprint.SnapPoints;
			TerrainMods.text = blueprint.TerrainMods;
			if ((Object)(object)blueprint.Icon == (Object)null)
			{
				((Component)Icon).gameObject.SetActive(false);
				Icon.sprite = null;
			}
			else
			{
				((Component)Icon).gameObject.SetActive(true);
				Icon.sprite = blueprint.Icon;
			}
			Name.text = blueprint.Name;
			Category.text = blueprint.Category;
			Description.text = blueprint.Description;
			((UnityEvent<string>)(object)Name.onEndEdit).AddListener((UnityAction<string>)delegate(string text)
			{
				blueprint.Name = text;
			});
			((UnityEvent<string>)(object)Category.onEndEdit).AddListener((UnityAction<string>)delegate(string text)
			{
				blueprint.Category = text;
			});
			((UnityEvent<string>)(object)Description.onEndEdit).AddListener((UnityAction<string>)delegate(string text)
			{
				blueprint.Description = text;
			});
			((UnityEventBase)CreateThumbnailButton.onClick).RemoveAllListeners();
			((UnityEventBase)RotateLeftButton.onClick).RemoveAllListeners();
			((UnityEventBase)RotateRightButton.onClick).RemoveAllListeners();
			if ((Object)(object)blueprint.Icon == (Object)null)
			{
				((Component)CreateThumbnailButton).gameObject.SetActive(true);
				((Component)RotateLeftButton).gameObject.SetActive(false);
				((Component)RotateRightButton).gameObject.SetActive(false);
				((UnityEvent)CreateThumbnailButton.onClick).AddListener((UnityAction)delegate
				{
					BlueprintGUI.Instance.CreateThumbnail(blueprint, TabType);
				});
			}
			else
			{
				((Component)CreateThumbnailButton).gameObject.SetActive(false);
				((Component)RotateLeftButton).gameObject.SetActive(true);
				((Component)RotateRightButton).gameObject.SetActive(true);
				((UnityEvent)RotateLeftButton.onClick).AddListener((UnityAction)delegate
				{
					blueprint.AdditionalRotation -= 45;
					BlueprintGUI.Instance.CreateThumbnail(blueprint, TabType);
				});
				((UnityEvent)RotateRightButton.onClick).AddListener((UnityAction)delegate
				{
					blueprint.AdditionalRotation += 45;
					BlueprintGUI.Instance.CreateThumbnail(blueprint, TabType);
				});
			}
			((UnityEventBase)SaveButton.onClick).RemoveAllListeners();
			((UnityEventBase)TransferButton.onClick).RemoveAllListeners();
			((UnityEventBase)DeleteButton.onClick).RemoveAllListeners();
			((UnityEvent)SaveButton.onClick).AddListener((UnityAction)delegate
			{
				ConfirmationOverlay.Show(Localization.instance.Localize("$gui_bpmarket_savebp", new string[2]
				{
					TabType.ToString(),
					Name.text
				}), delegate
				{
					BlueprintGUI.Instance.SaveBlueprint(blueprint, TabType);
				});
			});
			((UnityEvent)TransferButton.onClick).AddListener((UnityAction)delegate
			{
				ConfirmationOverlay.Show(Localization.instance.Localize("$gui_bpmarket_transferbp", new string[2]
				{
					TabType.ToString(),
					Name.text
				}), delegate
				{
					BlueprintGUI.Instance.TransferBlueprint(blueprint, TabType);
				});
			});
			((UnityEvent)DeleteButton.onClick).AddListener((UnityAction)delegate
			{
				ConfirmationOverlay.Show(Localization.instance.Localize("$gui_bpmarket_deletebp", new string[2]
				{
					TabType.ToString(),
					Name.text
				}), delegate
				{
					BlueprintGUI.Instance.DeleteBlueprint(blueprint, TabType);
				});
			});
		}

		public void Clear()
		{
			((UnityEventBase)Name.onEndEdit).RemoveAllListeners();
			((UnityEventBase)Category.onEndEdit).RemoveAllListeners();
			((UnityEventBase)Description.onEndEdit).RemoveAllListeners();
			((UnityEventBase)CreateThumbnailButton.onClick).RemoveAllListeners();
			((UnityEventBase)RotateLeftButton.onClick).RemoveAllListeners();
			((UnityEventBase)RotateRightButton.onClick).RemoveAllListeners();
			((UnityEventBase)SaveButton.onClick).RemoveAllListeners();
			((UnityEventBase)TransferButton.onClick).RemoveAllListeners();
			((UnityEventBase)DeleteButton.onClick).RemoveAllListeners();
			ID.text = "ID";
			Creator.text = null;
			Count.text = null;
			SnapPoints.text = null;
			TerrainMods.text = null;
			Icon.sprite = null;
			((Component)Icon).gameObject.SetActive(false);
			((Component)CreateThumbnailButton).gameObject.SetActive(false);
			((Component)RotateLeftButton).gameObject.SetActive(false);
			((Component)RotateRightButton).gameObject.SetActive(false);
			Name.text = null;
			Category.text = null;
			Description.text = null;
		}

		public void Register(Transform contentTransform, BlueprintLocation tabType)
		{
			//IL_023b: 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_0261: Expected O, but got Unknown
			TabType = tabType;
			try
			{
				ConfirmationOverlay = new UIConfirmationOverlay();
				Transform overlayTransform = contentTransform.Find("ConfirmationOverlay");
				ConfirmationOverlay.Register(overlayTransform);
				Transform val = contentTransform.Find("Detail");
				ID = ((Component)val.Find("ID")).GetComponent<Text>();
				Creator = ((Component)val.Find("Creator")).GetComponent<Text>();
				Count = ((Component)val.Find("Count")).GetComponent<Text>();
				SnapPoints = ((Component)val.Find("SnapPoints")).GetComponent<Text>();
				TerrainMods = ((Component)val.Find("TerrainMods")).GetComponent<Text>();
				Icon = ((Component)val.Find("Thumbnail")).GetComponent<Image>();
				((Component)Icon).gameObject.SetActive(false);
				Name = ((Component)val.Find("Name")).GetComponent<InputField>();
				Category = ((Component)val.Find("Category")).GetComponent<InputField>();
				Description = ((Component)val.Find("Description")).GetComponent<InputField>();
				CreateThumbnailButton = ((Component)val.Find("CreateThumbnail")).GetComponent<Button>();
				RotateLeftButton = ((Component)val.Find("RotateLeft")).GetComponent<Button>();
				RotateRightButton = ((Component)val.Find("RotateRight")).GetComponent<Button>();
				ReloadButton = ((Component)val.Find("RefreshButton")).GetComponent<Button>();
				SaveButton = ((Component)val.Find("SaveButton")).GetComponent<Button>();
				TransferButton = ((Component)val.Find("TransferButton")).GetComponent<Button>();
				DeleteButton = ((Component)val.Find("DeleteButton")).GetComponent<Button>();
				if (tabType == BlueprintLocation.Local)
				{
					((Component)TransferButton).GetComponentInChildren<Text>().text = "$gui_bpmarket_upload";
				}
				if (tabType == BlueprintLocation.Temporary)
				{
					((Component)ReloadButton).gameObject.SetActive(false);
					((Component)TransferButton).gameObject.SetActive(false);
				}
				if (tabType == BlueprintLocation.Server)
				{
					((Component)TransferButton).GetComponentInChildren<Text>().text = "$gui_bpmarket_download";
				}
				Image component = ((Component)((Component)ReloadButton).transform.Find("Image")).GetComponent<Image>();
				component.sprite = GUIManager.Instance.GetSprite("refresh_icon");
				Outline val2 = ((Component)component).gameObject.AddComponent<Outline>();
				((Shadow)val2).effectColor = Color.black;
				((UnityEvent)ReloadButton.onClick).AddListener((UnityAction)delegate
				{
					BlueprintGUI.Instance.ReloadBlueprints(TabType);
				});
			}
			catch (Exception arg)
			{
				Logger.LogDebug((object)$"Failed in BlueprintDetailDisplay: {arg}");
			}
		}
	}
	internal class BlueprintDetailContent
	{
		public GameObject ContentHolder { get; set; }

		public string ID { get; set; }

		public string Name { get; set; }

		public string Category { get; set; }

		public string Creator { get; set; }

		public string Count { get; set; }

		public string SnapPoints { get; set; }

		public string TerrainMods { get; set; }

		public string Description { get; set; }

		public Text Text { get; set; }

		public Sprite Icon { get; set; }

		public Button Button { get; set; }

		public int AdditionalRotation { get; set; }
	}
	internal class UIConfirmationOverlay
	{
		public Transform ContentHolder { get; set; }

		public Text ConfirmationDisplayText { get; set; }

		public Button CancelButton { get; set; }

		public Button ConfirmButton { get; set; }

		public void Show(string displayText, Action confirmAction)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			((Component)ContentHolder).gameObject.SetActive(true);
			ConfirmationDisplayText.text = displayText;
			((UnityEvent)ConfirmButton.onClick).AddListener((UnityAction)delegate
			{
				confirmAction?.Invoke();
				Close();
			});
		}

		public void Close()
		{
			((Component)ContentHolder).gameObject.SetActive(false);
			((UnityEventBase)ConfirmButton.onClick).RemoveAllListeners();
		}

		public bool IsVisible()
		{
			return ((Component)ContentHolder).gameObject.activeSelf;
		}

		public void Register(Transform overlayTransform)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			ContentHolder = overlayTransform;
			ConfirmationDisplayText = ((Component)overlayTransform.Find("ConfirmText")).GetComponent<Text>();
			ConfirmButton = ((Component)overlayTransform.Find("ConfirmationButton")).GetComponent<Button>();
			CancelButton = ((Component)overlayTransform.Find("CancelButton")).GetComponent<Button>();
			((UnityEvent)CancelButton.onClick).AddListener(new UnityAction(Close));
		}
	}
	internal class ActionAppliedOverlay
	{
		public Transform ContentHolder { get; set; }

		public Text DisplayText { get; set; }

		public Button OKButton { get; set; }

		public void Show()
		{
			((Component)ContentHolder).gameObject.SetActive(true);
			((Component)OKButton).gameObject.SetActive(false);
			DisplayText.text = Localization.instance.Localize("$gui_bpmarket_working");
		}

		public void SetResult(bool success, string message)
		{
			if (success)
			{
				Close();
				return;
			}
			((Component)OKButton).gameObject.SetActive(true);
			DisplayText.text = message;
		}

		public void Close()
		{
			((Component)ContentHolder).gameObject.SetActive(false);
		}

		public void Register(Transform overlayTransform)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			ContentHolder = overlayTransform;
			DisplayText = ((Component)overlayTransform.Find("DisplayText")).GetComponent<Text>();
			OKButton = ((Component)overlayTransform.Find("OKButton")).GetComponent<Button>();
			((UnityEvent)OKButton.onClick).AddListener(new UnityAction(Close));
		}
	}
	internal class WorldBlueprintRune : MonoBehaviour, Interactable, Hoverable
	{
		private Piece m_piece;

		public void Awake()
		{
			m_piece = ((Component)this).GetComponent<Piece>();
		}

		private Color GetEmissionColor()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] componentsInChildren = ((Component)this).GetComponentsInChildren<Renderer>();
			foreach (Renderer val in componentsInChildren)
			{
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if (val2.HasProperty("_EmissionColor"))
					{
						return val2.GetColor("_EmissionColor");
					}
				}
			}
			return Color.red;
		}

		public string GetHoverName()
		{
			return m_piece.m_name;
		}

		public string GetHoverText()
		{
			return Localization.instance.Localize(GetHoverName() + "\n[<color=yellow>$KEY_Use</color>] $piece_world_blueprint_rune_open");
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			if (hold)
			{
				return false;
			}
			BlueprintGUI.Instance.Toggle();
			return false;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}

		public float GetHoverOffset()
		{
			return 0f;
		}
	}
	internal class ZDOIDSet : HashSet<ZDOID>
	{
		public static ZDOIDSet From(ZPackage package)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			ZDOIDSet zDOIDSet = new ZDOIDSet();
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				zDOIDSet.Add(package.ReadZDOID());
			}
			return zDOIDSet;
		}

		public ZPackage ToZPackage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write(this.Count());
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				ZDOID current = enumerator.Current;
				val.Write(current);
			}
			return val;
		}
	}
}
namespace PlanBuild.Blueprints.Components
{
	internal class CaptureComponent : ToolComponentBase
	{
		public override void OnUpdatePlacement(Player self)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			EnableSelectionProjector(self);
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				if (ZInput.GetButton(Config.ShiftModifierButton.Name))
				{
					UpdateCameraOffset(axis);
				}
				else
				{
					UpdateSelectionRadius(axis);
				}
				UndoRotation(self, axis);
			}
			if (ZInput.GetButton(Config.CtrlModifierButton.Name))
			{
				BlueprintManager.HighlightPiecesInRadius(self.m_placementMarkerInstance.transform.position, ToolComponentBase.SelectionRadius, Color.green);
			}
		}

		public override void OnPlacePiece(Player self, Piece piece)
		{
			if (Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) && self.m_placementMarkerInstance.activeSelf)
			{
				MakeBlueprint(self);
			}
		}

		private void MakeBlueprint(Player self)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = self.m_placementMarkerInstance.transform.position;
			Selection selection = new Selection();
			selection.AddPiecesInRadius(position, ToolComponentBase.SelectionRadius);
			if (selection.Any())
			{
				bool button = ZInput.GetButton(Config.AltModifierButton.Name);
				SelectionTools.SaveWithGUI(selection, button, keepMarkers: false);
			}
		}
	}
	internal class DeletePlansComponent : ToolComponentBase
	{
		public override void OnUpdatePlacement(Player self)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			if (ZInput.GetButton(Config.CtrlModifierButton.Name))
			{
				EnableSelectionProjector(self);
			}
			else
			{
				DisableSelectionProjector();
			}
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				if (ZInput.GetButton(Config.ShiftModifierButton.Name))
				{
					UpdateCameraOffset(axis);
				}
				else if (ZInput.GetButton(Config.CtrlModifierButton.Name))
				{
					UpdateSelectionRadius(axis);
				}
				UndoRotation(self, axis);
			}
			if (ZInput.GetButton(Config.CtrlModifierButton.Name))
			{
				BlueprintManager.HighlightPiecesInRadius(self.m_placementMarkerInstance.transform.position, ToolComponentBase.SelectionRadius, Color.red, onlyPlanned: true);
			}
			else
			{
				BlueprintManager.HighlightHoveredPiece(Color.red, onlyPlanned: true);
			}
		}

		public override void OnPlacePiece(Player self, Piece piece)
		{
			if (Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) && self.m_placementMarkerInstance.activeSelf)
			{
				if (ZInput.GetButton(Config.CtrlModifierButton.Name))
				{
					DeletePlans(self);
				}
				else
				{
					UndoPiece();
				}
			}
		}

		private void UndoPiece()
		{
			PlanPiece planPiece = default(PlanPiece);
			if (Object.op_Implicit((Object)(object)BlueprintManager.LastHoveredPiece) && ((Component)BlueprintManager.LastHoveredPiece).TryGetComponent<PlanPiece>(ref planPiece))
			{
				planPiece.m_wearNTear.Remove(false);
			}
		}

		private void DeletePlans(Player self)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = self.m_placementMarkerInstance.transform.position;
			int num = 0;
			foreach (Piece item in BlueprintManager.GetPiecesInRadius(position, ToolComponentBase.SelectionRadius, onlyPlanned: true))
			{
				((Component)item).GetComponent<PlanPiece>().m_wearNTear.Remove(false);
				num++;
			}
			((Character)self).Message((MessageType)2, Localization.instance.Localize("$msg_removed_plans", new string[1] { num.ToString() }), 0, (Sprite)null, false);
		}
	}
	internal class MarkerComponent : SelectionToolComponentBase
	{
		public string PieceInstanceName;

		public override void OnStart()
		{
			base.OnStart();
			SuppressGizmo = false;
		}

		public override void OnUpdatePlacement(Player self)
		{
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			DisableSelectionProjector();
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				if (ZInput.GetButton(Config.ShiftModifierButton.Name))
				{
					UpdateCameraOffset(axis);
				}
				UndoRotation(self, axis);
			}
			if (ZInput.GetButtonDown("Remove") || ZInput.GetButtonDown("JoyRemove"))
			{
				Piece lastHoveredPiece = BlueprintManager.LastHoveredPiece;
				if (Object.op_Implicit((Object)(object)lastHoveredPiece) && (((Object)lastHoveredPiece).name.StartsWith("piece_bpsnappoint", StringComparison.Ordinal) || ((Object)lastHoveredPiece).name.StartsWith("piece_bpcenterpoint", StringComparison.Ordinal) || ((Object)lastHoveredPiece).name.StartsWith("piece_bpterrainmod", StringComparison.Ordinal)))
				{
					((Component)lastHoveredPiece).GetComponent<WearNTear>().Destroy((HitData)null, false);
				}
			}
		}

		public override void OnPlacePiece(Player self, Piece piece)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) && self.m_placementMarkerInstance.activeSelf && (int)self.m_placementStatus == 0)
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab(PieceInstanceName);
				Transform transform = self.m_placementGhost.transform;
				Vector3 position = transform.position;
				Quaternion rotation = transform.rotation;
				GameObject val = Object.Instantiate<GameObject>(prefab, position, rotation);
				Piece component = val.GetComponent<Piece>();
				if (Selection.Instance.Any())
				{
					Selection.Instance.AddPiece(component);
				}
				UndoCreate undoCreate = new UndoCreate((IEnumerable<ZDO>)(object)new ZDO[1] { component.m_nview.m_zdo });
				UndoManager.Instance.Add(Config.BlueprintUndoQueueNameConfig.Value, (IUndoAction)(object)undoCreate);
			}
		}

		public override void UpdateDescription()
		{
		}
	}
	internal class SelectEditComponent : SelectionToolComponentBase
	{
		public override void OnUpdatePlacement(Player self)
		{
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			DisableSelectionProjector();
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				if (ZInput.GetButton(Config.ShiftModifierButton.Name))
				{
					UpdateCameraOffset(axis);
				}
				UndoRotation(self, axis);
			}
		}

		public override void OnPlacePiece(Player self, Piece piece)
		{
			if (!Selection.Instance.Any())
			{
				MessageHud.instance.ShowMessage((MessageType)2, Localization.instance.Localize("$msg_blueprint_select_empty"), 0, (Sprite)null, false, true);
			}
			else
			{
				SelectionGUI.Instance.Show();
			}
		}
	}
	internal class PlacementComponent : ToolComponentBase
	{
		private static readonly int HashFields = StringExtensionMethods.GetStableHashCode("HasFields");

		private static readonly int HashFieldsDestructible = StringExtensionMethods.GetStableHashCode("HasFieldsDestructible");

		private static readonly int HashFieldsMineRock5 = StringExtensionMethods.GetStableHashCode("HasFieldsMineRock5");

		private static readonly int HashFieldsTreeBase = StringExtensionMethods.GetStableHashCode("HasFieldsTreeBase");

		private static readonly int HashFieldsTreeLog = StringExtensionMethods.GetStableHashCode("HasFieldsTreeLog");

		private static readonly int HashToolTierDestructible = StringExtensionMethods.GetStableHashCode("Destructible.m_minToolTier");

		private static readonly int HashToolTierMineRock5 = StringExtensionMethods.GetStableHashCode("MineRock5.m_minToolTier");

		private static readonly int HashToolTierTreeBase = StringExtensionMethods.GetStableHashCode("TreeBase.m_minToolTier");

		private static readonly int HashToolTierTreeLog = StringExtensionMethods.GetStableHashCode("TreeLog.m_minToolTier");

		private static readonly int HashFieldsWearNTear = StringExtensionMethods.GetStableHashCode("HasFieldsWearNTear");

		private static readonly int HashMaxHealth = StringExtensionMethods.GetStableHashCode("WearNTear.m_health");

		public override void OnStart()
		{
			SuppressGizmo = false;
			SuppressPieceHighlight = false;
			ResetPlacementOffset = false;
		}

		public override void OnUpdatePlacement(Player self)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			DisableSelectionProjector();
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				bool button = ZInput.GetButton(Config.CtrlModifierButton.Name);
				bool button2 = ZInput.GetButton(Config.AltModifierButton.Name);
				if (button && button2)
				{
					ToolComponentBase.PlacementOffset.y += GetPlacementOffset(axis);
					UndoRotation(self, axis);
				}
				else if (button2)
				{
					ToolComponentBase.PlacementOffset.x += GetPlacementOffset(axis);
					UndoRotation(self, axis);
				}
				else if (button)
				{
					ToolComponentBase.PlacementOffset.z += GetPlacementOffset(axis);
					UndoRotation(self, axis);
				}
				else if (ZInput.GetButton(Config.ShiftModifierButton.Name))
				{
					UpdateCameraOffset(axis);
					UndoRotation(self, axis);
				}
			}
			if (ZInput.GetButton(Config.ToggleButton.Name))
			{
				ToolComponentBase.PlacementOffset = Vector3.zero;
			}
		}

		public override void OnPlacePiece(Player self, Piece piece)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf || (int)self.m_placementStatus != 0)
			{
				return;
			}
			try
			{
				PlaceBlueprint(self, piece);
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)$"Exception caught while placing {((Object)((Component)piece).gameObject).name}: {ex}\n{ex.StackTrace}");
			}
		}

		private void PlaceBlueprint(Player player, Piece piece)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: 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_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_098f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0994: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_061a: Unknown result type (might be due to invalid IL or missing references)
			string text = ((Object)((Component)piece).gameObject).name.Substring("piece_blueprint".Length + 1);
			Blueprint blueprint = ((!text.StartsWith("__")) ? BlueprintManager.LocalBlueprints[text] : BlueprintManager.TemporaryBlueprints[text]);
			Transform transform = player.m_placementGhost.transform;
			Vector3 position = transform.position;
			Quaternion rotation = transform.rotation;
			bool directBuildDefault = Config.DirectBuildDefault;
			directBuildDefault ^= ZInput.GetButton(Config.CtrlModifierButton.Name);
			if (directBuildDefault && !Config.AllowDirectBuildConfig.Value && !SynchronizationManager.Instance.PlayerIsAdmin)
			{
				MessageHud.instance.ShowMessage((MessageType)2, "$msg_direct_build_disabled", 0, (Sprite)null, false, true);
				return;
			}
			for (int i = 0; i < blueprint.TerrainMods.Length; i++)
			{
				TerrainModEntry terrainModEntry = blueprint.TerrainMods[i];
				Vector3 val = transform.TransformPoint(terrainModEntry.GetPosition());
				Quaternion val2 = transform.rotation * terrainModEntry.GetRotation();
				Dictionary<TerrainComp, Indices> compilerIndices = null;
				if (terrainModEntry.shape.Equals("Circle", StringComparison.OrdinalIgnoreCase))
				{
					compilerIndices = TerrainTools.GetCompilerIndicesWithCircle(val, terrainModEntry.radius * 2f, BlockCheck.Off);
				}
				if (terrainModEntry.shape.Equals("Square", StringComparison.OrdinalIgnoreCase))
				{
					compilerIndices = TerrainTools.GetCompilerIndicesWithRect(val, terrainModEntry.radius * 2f, terrainModEntry.radius * 2f, ((Quaternion)(ref val2)).eulerAngles.y * (float)Math.PI / 180f, BlockCheck.Off);
				}
				TerrainTools.LevelTerrain(compilerIndices, val, terrainModEntry.radius, terrainModEntry.smooth, val.y);
				if (!string.IsNullOrEmpty(terrainModEntry.paint))
				{
					TerrainTools.PaintTerrain(compilerIndices, val, terrainModEntry.radius, (PaintType)Enum.Parse(typeof(PaintType), terrainModEntry.paint));
				}
			}
			uint num = 0u;
			uint num2 = 10u;
			List<ZDO> list = new List<ZDO>();
			for (int j = 0; j < blueprint.PieceEntries.Length; j++)
			{
				PieceEntry pieceEntry = blueprint.PieceEntries[j];
				if (pieceEntry.name == "piece_blueprint")
				{
					continue;
				}
				Vector3 val3 = transform.TransformPoint(pieceEntry.GetPosition());
				Quaternion val4 = transform.rotation * pieceEntry.GetRotation();
				if (!SynchronizationManager.Instance.PlayerIsAdmin && PlanBlacklist.Contains(pieceEntry.name))
				{
					Logger.LogWarning((object)$"{pieceEntry.name} is blacklisted, not placing @{val3}");
					continue;
				}
				string text2 = pieceEntry.name;
				if (!directBuildDefault)
				{
					text2 += "_planned";
				}
				GameObject prefab = PrefabManager.Instance.GetPrefab(text2);
				if (!Object.op_Implicit((Object)(object)prefab))
				{
					Logger.LogWarning((object)$"{text2} not found, you are probably missing a dependency, not placing @{val3}");
					continue;
				}
				GameObject val5 = Object.Instantiate<GameObject>(prefab, val3, val4);
				if (!Object.op_Implicit((Object)(object)val5))
				{
					Logger.LogWarning((object)("Invalid PieceEntry: " + pieceEntry.name));
					continue;
				}
				OnPiecePlaced(val5);
				ZNetView component = val5.GetComponent<ZNetView>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					Logger.LogWarning((object)$"No ZNetView for {val5}!!??");
				}
				else
				{
					list.Add(component.m_zdo);
					component.SetLocalScale(pieceEntry.GetScale());
				}
				Piece component2 = val5.GetComponent<Piece>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					component2.SetCreator(player.GetPlayerID(), PlatformUserID.None);
					if (directBuildDefault && num < num2)
					{
						component2.m_placeEffect.Create(val5.transform.position, rotation, val5.transform, 1f, -1, default(ZDOID));
						((Character)player).AddNoise(50f);
						num++;
					}
					if (directBuildDefault)
					{
						Game.instance.GetPlayerProfile().IncrementStat((PlayerStatType)2, 1f, false);
					}
				}
				CraftingStation componentInChildren = val5.GetComponentInChildren<CraftingStation>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					player.AddKnownStation(componentInChildren);
				}
				PrivateArea component3 = val5.GetComponent<PrivateArea>();
				if (Object.op_Implicit((Object)(object)component3))
				{
					component3.Setup(Game.instance.GetPlayerProfile().GetName());
					if (directBuildDefault && Object.op_Implicit((Object)(object)component) && !string.IsNullOrEmpty(pieceEntry.additionalInfo))
					{
						component.m_zdo.Set("enabled", bool.Parse(pieceEntry.additionalInfo));
					}
				}
				WearNTear component4 = val5.GetComponent<WearNTear>();
				if (Object.op_Implicit((Object)(object)component4))
				{
					component4.OnPlaced();
				}
				TextReceiver component5 = val5.GetComponent<TextReceiver>();
				if (component5 != null)
				{
					if (!directBuildDefault && Object.op_Implicit((Object)(object)component) && !string.IsNullOrEmpty(pieceEntry.additionalInfo))
					{
						component.m_zdo.Set("AdditionalText", pieceEntry.additionalInfo);
					}
					component5.SetText(string.IsNullOrEmpty(pieceEntry.additionalInfo) ? string.Empty : pieceEntry.additionalInfo);
				}
				ItemStand component6 = val5.GetComponent<ItemStand>();
				if ((Object)(object)component6 != (Object)null && directBuildDefault && Object.op_Implicit((Object)(object)component) && !string.IsNullOrEmpty(pieceEntry.additionalInfo))
				{
					string[] array = pieceEntry.additionalInfo.Split(new char[1] { ':' });
					if (array.Length < 2)
					{
						Logger.LogWarning((object)$"ItemStand items not found, not adding items @{val3}");
						continue;
					}
					string text3 = array[0];
					int num3 = int.Parse(array[1]);
					int num4 = 1;
					if (array.Length > 2)
					{
						num4 = int.Parse(array[2]);
					}
					int num5 = 0;
					if (array.Length > 3)
					{
						num5 = int.Parse(array[3]);
					}
					component.m_zdo.Set("item", text3);
					component.m_zdo.Set("variant", num3);
					component.m_zdo.Set("quality", num4);
					component.m_zdo.Set("type", num5);
					component6.SetVisualItem(StringExtensionMethods.GetStableHashCode(text3), num3, num4, num5);
				}
				ArmorStand component7 = val5.GetComponent<ArmorStand>();
				if ((Object)(object)component7 != (Object)null && directBuildDefault && Object.op_Implicit((Object)(object)component) && !string.IsNullOrEmpty(pieceEntry.additionalInfo))
				{
					string[] array2 = pieceEntry.additionalInfo.Split(new char[1] { ':' });
					if (array2.Length < 2)
					{
						Logger.LogWarning((object)$"ArmorStand items not found, not adding items @{val3}");
						continue;
					}
					int num6 = int.Parse(array2[0]);
					component.m_zdo.Set("pose", num6);
					component7.SetPose(num6, false);
					int num7 = int.Parse(array2[1]);
					for (int k = 0; k < num7; k++)
					{
						string text4 = array2[k * 2 + 2];
						int num8 = int.Parse(array2[k * 2 + 3]);
						component.m_zdo.Set($"{k}_item", text4);
						component.m_zdo.Set($"{k}_variant", num8);
						component7.SetVisualItem(k, StringExtensionMethods.GetStableHashCode(text4), num8);
					}
				}
				Door component8 = val5.GetComponent<Door>();
				if ((Object)(object)component8 != (Object)null && directBuildDefault && Object.op_Implicit((Object)(object)component) && !string.IsNullOrEmpty(pieceEntry.additionalInfo))
				{
					component.m_zdo.Set("state", int.Parse(pieceEntry.additionalInfo));
				}
				Container component9 = val5.GetComponent<Container>();
				if ((Object)(object)component9 != (Object)null && directBuildDefault && Object.op_Implicit((Object)(object)component) && !string.IsNullOrEmpty(pieceEntry.additionalInfo))
				{
					component.m_zdo.Set("items", pieceEntry.additionalInfo);
				}
				ItemDrop component10 = val5.GetComponent<ItemDrop>();
				if ((Object)(object)component10 != (Object)null)
				{
					component10.MakePiece(true);
				}
				if (directBuildDefault && Object.op_Implicit((Object)(object)component) && Config.UnlimitedHealthConfig.Value)
				{
					if (Object.op_Implicit((Object)(object)((Component)component).GetComponent<WearNTear>()))
					{
						component.m_zdo.Set(ZDOVars.s_health, -1f);
						component.m_zdo.Set(HashFields, true);
						component.m_zdo.Set(HashFieldsWearNTear, true);
						component.m_zdo.Set(HashMaxHealth, -1f);
						component.LoadFields();
					}
					if (Object.op_Implicit((Object)(object)((Component)component).GetComponent<MineRock5>()))
					{
						component.m_zdo.Set(HashFields, true);
						component.m_zdo.Set(HashFieldsMineRock5, true);
						component.m_zdo.Set(HashToolTierMineRock5, 1073741823, false);
						component.LoadFields();
					}
					if (Object.op_Implicit((Object)(object)((Component)component).GetComponent<TreeBase>()))
					{
						component.m_zdo.Set(HashFields, true);
						component.m_zdo.Set(HashFieldsTreeBase, true);
						component.m_zdo.Set(HashToolTierTreeBase, 1073741823, false);
						component.LoadFields();
					}
					if (Object.op_Implicit((Object)(object)((Component)component).GetComponent<TreeLog>()))
					{
						component.m_zdo.Set(HashFields, true);
						component.m_zdo.Set(HashFieldsTreeLog, true);
						component.m_zdo.Set(HashToolTierTreeLog, 1073741823, false);
						component.LoadFields();
					}
					if (Object.op_Implicit((Object)(object)((Component)component).GetComponent<Destructible>()))
					{
						component.m_zdo.Set(HashFields, true);
						component.m_zdo.Set(HashFieldsDestructible, true);
						component.m_zdo.Set(HashToolTierDestructible, 1073741823, false);
						component.LoadFields();
					}
				}
			}
			if (list.Any())
			{
				UndoCreate undoCreate = new UndoCreate(list);
				UndoManager.Instance.Add(Config.BlueprintUndoQueueNameConfig.Value, (IUndoAction)(object)undoCreate);
			}
			ToolComponentBase.PlacementOffset = Vector3.zero;
		}

		internal virtual void OnPiecePlaced(GameObject placedPiece)
		{
		}
	}
	internal class SelectRemoveComponent : SelectionToolComponentBase
	{
		public override void OnUpdatePlacement(Player self)
		{
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			bool button = ZInput.GetButton(Config.ShiftModifierButton.Name);
			bool button2 = ZInput.GetButton(Config.CtrlModifierButton.Name);
			bool button3 = ZInput.GetButton(Config.AltModifierButton.Name);
			if (button2 && !button3)
			{
				EnableSelectionProjector(self);
			}
			else
			{
				DisableSelectionProjector();
			}
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				if (button)
				{
					UpdateCameraOffset(axis);
				}
				else if (button2 && !button3)
				{
					UpdateSelectionRadius(axis);
				}
				UndoRotation(self, axis);
			}
			if (ZInput.GetButtonDown(Config.ToggleButton.Name))
			{
				Player.m_localPlayer.m_buildPieces.LeftPiece();
				Player.m_localPlayer.SetupPlacementGhost();
			}
		}

		public override void OnPlacePiece(Player self, Piece piece)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			bool button = ZInput.GetButton(Config.ShiftModifierButton.Name);
			bool button2 = ZInput.GetButton(Config.CtrlModifierButton.Name);
			bool button3 = ZInput.GetButton(Config.AltModifierButton.Name);
			if (button)
			{
				Selection.Instance.Clear();
			}
			else if (button2)
			{
				Selection.Instance.RemovePiecesInRadius(((Component)this).transform.position, ToolComponentBase.SelectionRadius);
			}
			else if (Object.op_Implicit((Object)(object)BlueprintManager.LastHoveredPiece) && BlueprintManager.CanCapture(BlueprintManager.LastHoveredPiece))
			{
				if (button3)
				{
					Selection.Instance.RemoveGrowFromPiece(BlueprintManager.LastHoveredPiece);
				}
				else
				{
					Selection.Instance.RemovePiece(BlueprintManager.LastHoveredPiece);
				}
			}
			UpdateDescription();
		}
	}
	internal class SelectAddComponent : SelectionToolComponentBase
	{
		private Piece StartPiece;

		public override void OnUpdatePlacement(Player self)
		{
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			bool button = ZInput.GetButton(Config.ShiftModifierButton.Name);
			bool button2 = ZInput.GetButton(Config.CtrlModifierButton.Name);
			bool button3 = ZInput.GetButton(Config.AltModifierButton.Name);
			if (button2 && !button3)
			{
				EnableSelectionProjector(self);
			}
			else
			{
				DisableSelectionProjector();
			}
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				if (button)
				{
					UpdateCameraOffset(axis);
				}
				else if (button2 && !button3)
				{
					UpdateSelectionRadius(axis);
				}
				UndoRotation(self, axis);
			}
			if (ZInput.GetButtonDown(Config.ToggleButton.Name))
			{
				Player.m_localPlayer.m_buildPieces.RightPiece();
				Player.m_localPlayer.SetupPlacementGhost();
			}
		}

		public override void OnPlacePiece(Player self, Piece piece)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			bool button = ZInput.GetButton(Config.ShiftModifierButton.Name);
			bool button2 = ZInput.GetButton(Config.CtrlModifierButton.Name);
			bool button3 = ZInput.GetButton(Config.AltModifierButton.Name);
			if (button2)
			{
				Selection.Instance.AddPiecesInRadius(((Component)this).transform.position, ToolComponentBase.SelectionRadius);
			}
			else if (Object.op_Implicit((Object)(object)BlueprintManager.LastHoveredPiece) && BlueprintManager.CanCapture(BlueprintManager.LastHoveredPiece))
			{
				if (button)
				{
					if ((Object)(object)StartPiece == (Object)null)
					{
						Selection.Instance.AddPiece(BlueprintManager.LastHoveredPiece);
						StartPiece = BlueprintManager.LastHoveredPiece;
					}
					else
					{
						Selection.Instance.AddPiecesBetween(StartPiece, BlueprintManager.LastHoveredPiece);
						StartPiece = null;
					}
				}
				else if (button3)
				{
					Selection.Instance.AddGrowFromPiece(BlueprintManager.LastHoveredPiece);
				}
				else
				{
					Selection.Instance.AddPiece(BlueprintManager.LastHoveredPiece);
				}
			}
			UpdateDescription();
		}
	}
	internal class DeleteObjectsComponent : ToolComponentBase
	{
		public override void OnUpdatePlacement(Player self)
		{
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			EnableSelectionProjector(self, enableMask: true);
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				if (ZInput.GetButton(Config.ShiftModifierButton.Name))
				{
					UpdateCameraOffset(axis);
				}
				else
				{
					UpdateSelectionRadius(axis);
				}
				UndoRotation(self, axis);
			}
		}

		public override void OnPlacePiece(Player self, Piece piece)
		{
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			if (!Config.AllowTerrainmodConfig.Value && !SynchronizationManager.Instance.PlayerIsAdmin)
			{
				MessageHud.instance.ShowMessage((MessageType)2, "$msg_terrain_disabled", 0, (Sprite)null, false, true);
				return;
			}
			int num = (ZInput.GetButton(Config.CtrlModifierButton.Name) ? RemoveObjects(self.m_placementGhost.transform, ToolComponentBase.SelectionRadius, new Type[1] { typeof(Piece) }, new Type[1] { typeof(PlanPiece) }) : ((!ZInput.GetButton(Config.AltModifierButton.Name)) ? RemoveObjects(self.m_placementGhost.transform, ToolComponentBase.SelectionRadius, null, new Type[5]
			{
				typeof(Character),
				typeof(TerrainModifier),
				typeof(ZSFX),
				typeof(Piece),
				typeof(ItemDrop)
			}) : RemoveObjects(self.m_placementGhost.transform, ToolComponentBase.SelectionRadius, null, new Type[3]
			{
				typeof(Character),
				typeof(TerrainModifier),
				typeof(ZSFX)
			})));
			if (num > 0)
			{
				MessageHud.instance.ShowMessage((MessageType)2, Localization.instance.Localize("$msg_removed_objects", new string[1] { num.ToString() }), 0, (Sprite)null, false, true);
			}
		}

		private int RemoveObjects(Transform transform, float radius, Type[] includeTypes, Type[] excludeTypes)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogDebug((object)$"Entered RemoveVegetation {transform.position} / {radius}");
			int num = 0;
			ZNetScene instance = ZNetScene.instance;
			try
			{
				Vector3 startPosition = transform.position;
				if (Location.IsInsideNoBuildLocation(startPosition))
				{
					return num;
				}
				IEnumerable<GameObject> enumerable = from obj in Object.FindObjectsOfType<GameObject>()
					where Vector3.Distance(startPosition, obj.transform.position) <= radius && Object.op_Implicit((Object)(object)obj.GetComponent<ZNetView>()) && (includeTypes == null || includeTypes.All((Type x) => (Object)(object)obj.GetComponent(x) != (Object)null)) && (excludeTypes == null || excludeTypes.All((Type x) => (Object)(object)obj.GetComponent(x) == (Object)null))
					select obj;
				List<ZDO> list = new List<ZDO>();
				ZNetView val = default(ZNetView);
				foreach (GameObject item in enumerable)
				{
					if (item.TryGetComponent<ZNetView>(ref val))
					{
						Selection.Instance.Remove(val.m_zdo.m_uid);
						list.Add(val.m_zdo);
						val.ClaimOwnership();
						instance.Destroy(item);
						num++;
					}
				}
				UndoRemove undoRemove = new UndoRemove(list);
				UndoManager.Instance.Add(Config.BlueprintUndoQueueNameConfig.Value, (IUndoAction)(object)undoRemove);
				Logger.LogDebug((object)$"Removed {num} objects");
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"Error while removing objects: {arg}");
			}
			return num;
		}
	}
	internal class PaintComponent : ToolComponentBase
	{
		public override void OnUpdatePlacement(Player self)
		{
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			EnableSelectionProjector(self, enableMask: true);
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				if (ZInput.GetButton(Config.ShiftModifierButton.Name))
				{
					UpdateCameraOffset(axis);
					UndoRotation(self, axis);
				}
				else if (ZInput.GetButton(Config.CtrlModifierButton.Name))
				{
					UpdateSelectionRotation(axis);
					UndoRotation(self, axis);
				}
				else
				{
					UpdateSelectionRadius(axis);
					UndoRotation(self, axis);
				}
			}
			if (ZInput.GetButtonDown(Config.ToggleButton.Name))
			{
				ToolComponentBase.SelectionProjector.SwitchShape();
			}
		}

		public override void OnPlacePiece(Player self, Piece piece)
		{
			if (Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) && self.m_placementMarkerInstance.activeSelf)
			{
				if (!Config.AllowTerrainmodConfig.Value && !SynchronizationManager.Instance.PlayerIsAdmin)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "$msg_terrain_disabled", 0, (Sprite)null, false, true);
					return;
				}
				((MonoBehaviour)this).StopAllCoroutines();
				((MonoBehaviour)this).StartCoroutine(ConstantDraw());
			}
		}

		private IEnumerator ConstantDraw()
		{
			Vector3 lastPos = Vector3.zero;
			Transform ghost = ((Component)ToolComponentBase.SelectionProjector).transform;
			while ((Object)(object)ghost != (Object)null && ZInput.GetButton("Attack"))
			{
				PaintType type = (PaintType)3;
				if (ZInput.GetButton(Config.CtrlModifierButton.Name))
				{
					type = (PaintType)0;
				}
				else if (ZInput.GetButton(Config.AltModifierButton.Name))
				{
					type = (PaintType)2;
				}
				if (ghost.position != lastPos)
				{
					Dictionary<TerrainComp, Indices> compilerIndices = null;
					Vector3 position = ToolComponentBase.SelectionProjector.GetPosition();
					float radius = ToolComponentBase.SelectionProjector.GetRadius();
					int rotation = ToolComponentBase.SelectionProjector.GetRotation();
					if (ToolComponentBase.SelectionProjector.GetShape() == ShapedProjector.ProjectorShape.Circle)
					{
						compilerIndices = TerrainTools.GetCompilerIndicesWithCircle(position, radius * 2f, BlockCheck.Off);
					}
					if (ToolComponentBase.SelectionProjector.GetShape() == ShapedProjector.ProjectorShape.Square)
					{
						compilerIndices = TerrainTools.GetCompilerIndicesWithRect(position, radius * 2f, radius * 2f, (float)rotation * (float)Math.PI / 180f, BlockCheck.Off);
					}
					TerrainTools.PaintTerrain(compilerIndices, position, radius, type);
					lastPos = ghost.position;
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
		}
	}
	internal class SelectionToolComponentBase : ToolComponentBase
	{
		public override void OnStart()
		{
			UpdateDescription();
			Selection.Instance.StartHighlightSelection();
		}

		public override void OnOnDestroy()
		{
			Selection.Instance.StopHighlightSelection();
		}

		public override void UpdateDescription()
		{
			Hud.instance.m_pieceDescription.text = Selection.Instance.ToString();
		}
	}
	internal class TerrainComponent : ToolComponentBase
	{
		public override void OnStart()
		{
			ResetMarkerOffset = false;
		}

		public override void OnUpdatePlacement(Player self)
		{
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			EnableSelectionProjector(self);
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				bool button = ZInput.GetButton(Config.CtrlModifierButton.Name);
				bool button2 = ZInput.GetButton(Config.AltModifierButton.Name);
				bool button3 = ZInput.GetButton(Config.ShiftModifierButton.Name);
				if (button2)
				{
					ToolComponentBase.MarkerOffset.y += GetPlacementOffset(axis);
					UndoRotation(self, axis);
				}
				else if (button3)
				{
					UpdateCameraOffset(axis);
					UndoRotation(self, axis);
				}
				else if (button)
				{
					UpdateSelectionRotation(axis);
					UndoRotation(self, axis);
				}
				else
				{
					UpdateSelectionRadius(axis);
					UndoRotation(self, axis);
				}
			}
			if (ZInput.GetButtonDown(Config.ToggleButton.Name))
			{
				ToolComponentBase.SelectionProjector.SwitchShape();
			}
		}

		public override void OnPlacePiece(Player self, Piece piece)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)self.m_placementMarkerInstance) || !self.m_placementMarkerInstance.activeSelf)
			{
				return;
			}
			if (!Config.AllowTerrainmodConfig.Value && !SynchronizationManager.Instance.PlayerIsAdmin)
			{
				MessageHud.instance.ShowMessage((MessageType)2, "$msg_terrain_disabled", 0, (Sprite)null, false, true);
				return;
			}
			Dictionary<TerrainComp, Indices> compilerIndices = null;
			Vector3 position = ToolComponentBase.SelectionProjector.GetPosition();
			float radius = ToolComponentBase.SelectionProjector.GetRadius();
			int rotation = ToolComponentBase.SelectionProjector.GetRotation();
			if (ToolComponentBase.SelectionProjector.GetShape() == ShapedProjector.ProjectorShape.Circle)
			{
				compilerIndices = TerrainTools.GetCompilerIndicesWithCircle(position, radius * 2f, BlockCheck.Off);
			}
			if (ToolComponentBase.SelectionProjector.GetShape() == ShapedProjector.ProjectorShape.Square)
			{
				compilerIndices = TerrainTools.GetCompilerIndicesWithRect(position, radius * 2f, radius * 2f, (float)rotation * (float)Math.PI / 180f, BlockCheck.Off);
			}
			if (ZInput.GetButton(Config.AltModifierButton.Name))
			{
				TerrainTools.ResetTerrain(compilerIndices, position, radius);
			}
			else if (ZInput.GetButton(Config.CtrlModifierButton.Name))
			{
				TerrainTools.LevelTerrain(compilerIndices, position, radius, Mathf.Clamp01(Config.TerrainSmoothConfig.Value), position.y);
			}
			else
			{
				TerrainTools.LevelTerrain(compilerIndices, position, radius, 0f, position.y);
			}
			ToolComponentBase.MarkerOffset = Vector3.zero;
		}
	}
	internal class ToolComponentBase : MonoBehaviour
	{
		public static ShapedProjector SelectionProjector;

		public static float SelectionRadius = 10f;

		public static int SelectionRotation;

		public static float CameraOffset;

		public static Vector3 PlacementOffset = Vector3.zero;

		public static Vector3 MarkerOffset = Vector3.zero;

		internal bool SuppressGizmo = true;

		internal bool SuppressPieceHighlight = true;

		internal bool ResetPlacementOffset = true;

		internal bool ResetMarkerOffset = true;

		private void Start()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			OnStart();
			if (ResetPlacementOffset)
			{
				PlacementOffset = Vector3.zero;
			}
			if (ResetMarkerOffset)
			{
				MarkerOffset = Vector3.zero;
			}
			Player.UpdatePlacement += new hook_UpdatePlacement(Player_UpdatePlacement);
			Player.UpdateWearNTearHover += new hook_UpdateWearNTearHover(Player_UpdateWearNTearHover);
			Player.TryPlacePiece += new hook_TryPlacePiece(Player_TryPlacePiece);
			Player.UpdatePlacementGhost += new hook_UpdatePlacementGhost(Player_UpdatePlacementGhost);
			Player.PieceRayTest += new hook_PieceRayTest(Player_PieceRayTest);
			GameCamera.UpdateCamera += new hook_UpdateCamera(GameCamera_UpdateCamera);
			Hud.SetupPieceInfo += new hook_SetupPieceInfo(Hud_SetupPieceInfo);
			Logger.LogDebug((object)(((Object)((Component)this).gameObject).name + " started"));
		}

		public virtual void OnStart()
		{
		}

		private void OnDestroy()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				Logger.LogDebug((object)"Skipping destroy because the game is exiting");
				return;
			}
			OnOnDestroy();
			DisableSelectionProjector();
			Player.UpdatePlacement -= new hook_UpdatePlacement(Player_UpdatePlacement);
			Player.UpdateWearNTearHover -= new hook_UpdateWearNTearHover(Player_UpdateWearNTearHover);
			Player.TryPlacePiece -= new hook_TryPlacePiece(Player_TryPlacePiece);
			Player.UpdatePlacementGhost -= new hook_UpdatePlacementGhost(Player_UpdatePlacementGhost);
			Player.PieceRayTest -= new hook_PieceRayTest(Player_PieceRayTest);
			GameCamera.UpdateCamera -= new hook_UpdateCamera(GameCamera_UpdateCamera);
			Hud.SetupPieceInfo -= new hook_SetupPieceInfo(Hud_SetupPieceInfo);
			Logger.LogDebug((object)(((Object)((Component)this).gameObject).name + " destroyed"));
		}

		public virtual void OnOnDestroy()
		{
		}

		private void Player_UpdatePlacement(orig_UpdatePlacement orig, Player self, bool takeInput, float dt)
		{
			orig.Invoke(self, takeInput, dt);
			if (Object.op_Implicit((Object)(object)self.m_placementGhost) && takeInput)
			{
				OnUpdatePlacement(self);
			}
		}

		public virtual void OnUpdatePlacement(Player self)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			PlacementOffset = Vector3.zero;
			MarkerOffset = Vector3.zero;
			CameraOffset = 0f;
			DisableSelectionProjector();
		}

		private void Player_UpdateWearNTearHover(orig_UpdateWearNTearHover orig, Player self)
		{
			if (!SuppressPieceHighlight)
			{
				orig.Invoke(self);
			}
		}

		public float GetPlacementOffset(float scrollWheel)
		{
			bool flag = scrollWheel < 0f;
			if (Config.InvertPlacementOffsetScrollConfig.Value)
			{
				flag = !flag;
			}
			if (flag)
			{
				return 0f - Config.PlacementOffsetIncrementConfig.Value;
			}
			return Config.PlacementOffsetIncrementConfig.Value;
		}

		public void UndoRotation(Player player, float scrollWheel)
		{
			if (scrollWheel < 0f)
			{
				player.m_placeRotation++;
			}
			else
			{
				player.m_placeRotation--;
			}
		}

		public void UpdateSelectionRadius(float scrollWheel)
		{
			if (!((Object)(object)SelectionProjector == (Object)null))
			{
				bool flag = scrollWheel < 0f;
				if (Config.InvertSelectionScrollConfig.Value)
				{
					flag = !flag;
				}
				if (flag)
				{
					SelectionRadius -= Config.SelectionIncrementConfig.Value;
				}
				else
				{
					SelectionRadius += Config.SelectionIncrementConfig.Value;
				}
				SelectionRadius = Mathf.Clamp(SelectionRadius, 2f, 100f);
				SelectionProjector.SetRadius(SelectionRadius);
			}
		}

		public void UpdateSelectionRotation(float scrollWheel)
		{
			if (!((Object)(object)SelectionProjector == (Object)null))
			{
				bool flag = scrollWheel < 0f;
				if (Config.InvertRotationScrollConfig.Value)
				{
					flag = !flag;
				}
				if (flag)
				{
					SelectionRotation -= Config.RotationIncrementConfig.Value;
				}
				else
				{
					SelectionRotation += Config.RotationIncrementConfig.Value;
				}
				SelectionProjector.SetRotation(SelectionRotation);
			}
		}

		public void EnableSelectionProjector(Player self, bool enableMask = false)
		{
			if ((Object)(object)SelectionProjector == (Object)null)
			{
				SelectionProjector = self.m_placementMarkerInstance.AddComponent<ShapedProjector>();
				SelectionProjector.Enable();
				SelectionProjector.SetRadius(SelectionRadius);
				SelectionProjector.SetRotation(SelectionRotation);
			}
			if (enableMask)
			{
				SelectionProjector.EnableMask();
			}
			else
			{
				SelectionProjector.DisableMask();
			}
		}

		public void DisableSelectionProjector()
		{
			if ((Object)(object)SelectionProjector != (Object)null)
			{
				SelectionProjector.Disable();
				Object.DestroyImmediate((Object)(object)SelectionProjector);
			}
		}

		public void UpdateCameraOffset(float scrollWheel)
		{
			float num = 0f;
			float num2 = 30f;
			bool flag = scrollWheel < 0f;
			if (Config.InvertCameraOffsetScrollConfig.Value)
			{
				flag = !flag;
			}
			if (flag)
			{
				CameraOffset = Mathf.Clamp(CameraOffset + Config.CameraOffsetIncrementConfig.Value, num, num2);
			}
			else
			{
				CameraOffset = Mathf.Clamp(CameraOffset - Config.CameraOffsetIncrementConfig.Value, num, num2);
			}
		}

		internal void Player_UpdatePlacementGhost(orig_UpdatePlacementGhost orig, Player self, bool flashGuardStone)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, flashGuardStone);
			if (Object.op_Implicit((Object)(object)self.m_placementMarkerInstance))
			{
				self.m_placementMarkerInstance.transform.up = Vector3.back;
				if (Object.op_Implicit((Object)(object)self.m_placementGhost) && PlacementOffset != Vector3.zero)
				{
					Quaternion rotation = self.m_placementGhost.transform.rotation;
					Transform transform = self.m_placementGhost.transform;
					Quaternion val = Quaternion.Inverse(rotation);
					transform.Rotate(((Quaternion)(ref val)).eulerAngles);
					self.m_placementGhost.transform.Translate(PlacementOffset);
					self.m_placementGhost.transform.Rotate(((Quaternion)(ref rotation)).eulerAngles);
				}
			}
		}

		private bool Player_PieceRayTest(orig_PieceRayTest orig, Player self, out Vector3 point, out Vector3 normal, out Piece piece, out Heightmap heightmap, out Collider waterSurface, bool water)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			bool flag = orig.Invoke(self, ref point, ref normal, ref piece, ref heightmap, ref waterSurface, water);
			if (flag && Object.op_Implicit((Object)(object)self.m_placementGhost) && MarkerOffset != Vector3.zero)
			{
				point += self.m_placementGhost.transform.TransformDirection(MarkerOffset);
			}
			OnPieceHovered(piece);
			return flag;
		}

		public virtual void OnPieceHovered(Piece hoveredPiece)
		{
		}

		private bool Player_TryPlacePiece(orig_TryPlacePiece orig, Player self, Piece piece)
		{
			OnPlacePiece(self, piece);
			return false;
		}

		public virtual void OnPlacePiece(Player self, Piece piece)
		{
		}

		private void GameCamera_UpdateCamera(orig_UpdateCamera orig, GameCamera self, float dt)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, dt);
			if (PatcherBuildCamera.UpdateCamera && Object.op_Implicit((Object)(object)Player.m_localPlayer) && ((Character)Player.m_localPlayer).InPlaceMode())
			{
				Object.op_Implicit((Object)(object)Player.m_localPlayer.m_placementGhost);
			}
			Transform transform = ((Component)self).transform;
			transform.position += new Vector3(0f, CameraOffset, 0f);
		}

		private void Hud_SetupPieceInfo(orig_SetupPieceInfo orig, Hud self, Piece piece)
		{
			orig.Invoke(self, piece);
			if (!self.m_pieceSelectionWindow.activeSelf)
			{
				UpdateDescription();
			}
		}

		public virtual void UpdateDescription()
		{
		}
	}
}