Decompiled source of FineWoodPieces v1.4.8

FineWoodPieces.dll

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

[assembly: AssemblyFileVersion("1.4.8")]
[assembly: Guid("C53803CC-D333-4666-B35B-7B53D7AFA18E")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyProduct("FineWoodPieces")]
[assembly: AssemblyCompany("blacks7ar")]
[assembly: AssemblyConfiguration("")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyTitle("FineWoodPieces")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyDescription("https://valheim.thunderstore.io/package/blacks7ar/FineWoodPieces/")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.8.0")]
[module: UnverifiableCode]
[module: <d8246041-d695-4abc-abff-c4fc457f3e0e>RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[<1205671b-08a2-4aa1-a591-e18e00a33491>Embedded]
	[CompilerGenerated]
	internal sealed class <1205671b-08a2-4aa1-a591-e18e00a33491>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<1205671b-08a2-4aa1-a591-e18e00a33491>Embedded]
	internal sealed class <d8246041-d695-4abc-abff-c4fc457f3e0e>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <d8246041-d695-4abc-abff-c4fc457f3e0e>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FineWoodPieces
{
	[BepInPlugin("blacks7ar.FineWoodPieces", "FineWoodPieces", "1.4.8")]
	[BepInIncompatibility("blacks7ar.ClayBuildPieces")]
	[BepInIncompatibility("blacks7ar.FineWoodFurnitures")]
	[BepInIncompatibility("blacks7ar.FineWoodBuildPieces")]
	public class Plugin : BaseUnityPlugin
	{
		private const string modGUID = "blacks7ar.FineWoodPieces";

		public const string modName = "FineWoodPieces";

		public const string modAuthor = "blacks7ar";

		public const string modVersion = "1.4.8";

		public const string modLink = "https://valheim.thunderstore.io/package/blacks7ar/FineWoodPieces/";

		private static string configFileName = "blacks7ar.FineWoodPieces.cfg";

		private static string configFileFullPath;

		public static readonly ManualLogSource FWPLogger;

		private static readonly Harmony _harmony;

		private static readonly ConfigSync _configSync;

		private static ConfigEntry<Toggle> _serverConfigLocked;

		public static ConfigEntry<Toggle> _enableReed;

		public static ConfigEntry<float> _reedGroupRadius;

		public static ConfigEntry<int> _reedGroupSizeMin;

		public static ConfigEntry<int> _reedGroupSizeMax;

		public static ConfigEntry<float> _reedMax;

		public static ConfigEntry<Toggle> _enableClay;

		public static ConfigEntry<float> _clayGroupRadius;

		public static ConfigEntry<int> _clayGroupSizeMin;

		public static ConfigEntry<int> _clayGroupSizeMax;

		public static ConfigEntry<float> _clayMax;

		public static ConfigEntry<Toggle> _enableClayBig;

		public static ConfigEntry<float> _clayBigGroupRadius;

		public static ConfigEntry<int> _clayBigGroupSizeMin;

		public static ConfigEntry<int> _clayBigGroupSizeMax;

		public static ConfigEntry<float> _clayBigMax;

		public static ConfigEntry<float> _secPerUnit;

		public static ConfigEntry<int> _maxClay;

		public static ConfigEntry<Biome> _clayPit1Biome;

		public static ConfigEntry<BiomeArea> _clayPit1BiomeArea;

		public static ConfigEntry<float> _clayPit1MinDistance;

		public static ConfigEntry<int> _clayPit1Count;

		public static ConfigEntry<Biome> _clayPit2Biome;

		public static ConfigEntry<BiomeArea> _clayPit2BiomeArea;

		public static ConfigEntry<float> _clayPit2MinDistance;

		public static ConfigEntry<int> _clayPit2Count;

		public static ConfigEntry<Toggle> _hideTrapDoorHoverText;

		private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedConfig = true)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedConfig ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			_configSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedConfig;
			return val2;
		}

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

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

		public void Awake()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Expected O, but got Unknown
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Expected O, but got Unknown
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Expected O, but got Unknown
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Expected O, but got Unknown
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Expected O, but got Unknown
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Expected O, but got Unknown
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Expected O, but got Unknown
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Expected O, but got Unknown
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Expected O, but got Unknown
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Expected O, but got Unknown
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Expected O, but got Unknown
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Expected O, but got Unknown
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Expected O, but got Unknown
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Expected O, but got Unknown
			//IL_04da: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Expected O, but got Unknown
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0517: Expected O, but got Unknown
			Localizer.Load();
			_serverConfigLocked = config("1- ServerSync", "Lock Configuration", Toggle.On, new ConfigDescription("If On, the configuration is locked and can be changed by server admins only.", (AcceptableValueBase)null, Array.Empty<object>()));
			_configSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
			_hideTrapDoorHoverText = config("8- TrapDoor", "Hide HoverText", Toggle.On, new ConfigDescription("If On, trap doors hover text and interact prompt will be hidden.", (AcceptableValueBase)null, Array.Empty<object>()));
			_enableReed = config("2- Reed", "Enable", Toggle.On, new ConfigDescription("If On, harvestable reeds will spawn across meadows and black forest biomes.", (AcceptableValueBase)null, Array.Empty<object>()));
			_reedGroupRadius = config("2- Reed", "Group Radius", 4f, new ConfigDescription("Group radius.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f), Array.Empty<object>()));
			_reedGroupSizeMin = config("2- Reed", "Group Size Min", 4, new ConfigDescription("Minimum group size.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20), Array.Empty<object>()));
			_reedGroupSizeMax = config("2- Reed", "Group Size Max", 8, new ConfigDescription("Maximum group size.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20), Array.Empty<object>()));
			_reedMax = config("2- Reed", "Max", 10f, new ConfigDescription("Maximum amount per zone.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 20f), Array.Empty<object>()));
			_enableClay = config("3- Clay-Pickable", "Enable", Toggle.On, new ConfigDescription("If On, pickable clays will spawn to all biomes except ashlands and deepnorth.", (AcceptableValueBase)null, Array.Empty<object>()));
			_clayGroupRadius = config("3- Clay-Pickable", "Group Radius", 2f, new ConfigDescription("Group radius.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f), Array.Empty<object>()));
			_clayGroupSizeMin = config("3- Clay-Pickable", "Group Size Min", 2, new ConfigDescription("Minimum group size.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20), Array.Empty<object>()));
			_clayGroupSizeMax = config("3- Clay-Pickable", "Group Size Max", 6, new ConfigDescription("Maximum group size.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20), Array.Empty<object>()));
			_clayMax = config("3- Clay-Pickable", "Max", 20f, new ConfigDescription("Maximum amount per zone.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 20f), Array.Empty<object>()));
			_enableClayBig = config("4- Clay-Cluster", "Enable", Toggle.On, new ConfigDescription("If On, a giant cluster of clays will spawn to all biomes except ashlands and deepnorth.", (AcceptableValueBase)null, Array.Empty<object>()));
			_clayBigGroupRadius = config("4- Clay-Cluster", "Group Radius", 20f, new ConfigDescription("Group radius.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f), Array.Empty<object>()));
			_clayBigGroupSizeMin = config("4- Clay-Cluster", "Group Size Min", 1, new ConfigDescription("Minimum group size.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20), Array.Empty<object>()));
			_clayBigGroupSizeMax = config("4- Clay-Cluster", "Group Size Max", 1, new ConfigDescription("Maximum group size.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20), Array.Empty<object>()));
			_clayBigMax = config("4- Clay-Cluster", "Max", 5f, new ConfigDescription("Maximum amount per zone.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 20f), Array.Empty<object>()));
			_secPerUnit = config("5- Collector", "Duration", 120f, new ConfigDescription("How long does the collector would take to collect clays from pits in seconds.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(30f, 300f), Array.Empty<object>()));
			_maxClay = config("5- Collector", "Max Capacity", 10, new ConfigDescription("Maximum Capacity.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), Array.Empty<object>()));
			_clayPit1Biome = config<Biome>("7- ClayPit-NeckSpawn", "Biome", (Biome)1, new ConfigDescription("Biome to spawn the clay pit location.", (AcceptableValueBase)null, Array.Empty<object>()));
			_clayPit1BiomeArea = config<BiomeArea>("7- ClayPit-NeckSpawn", "Biome Area", (BiomeArea)3, new ConfigDescription("Biome area.", (AcceptableValueBase)null, Array.Empty<object>()));
			_clayPit1MinDistance = config("7- ClayPit-NeckSpawn", "Minimum Distance", 128f, new ConfigDescription("Minimum distance to group.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 500f), Array.Empty<object>()));
			_clayPit1Count = config("7- ClayPit-NeckSpawn", "Max Count", 100, new ConfigDescription("Maximum count to try to spawn.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 200), Array.Empty<object>()));
			_clayPit2Biome = config<Biome>("6- ClayPit-BoarSpawn", "Biome", (Biome)1, new ConfigDescription("Biome to spawn the clay pit location.", (AcceptableValueBase)null, Array.Empty<object>()));
			_clayPit2BiomeArea = config<BiomeArea>("6- ClayPit-BoarSpawn", "Biome Area", (BiomeArea)3, new ConfigDescription("Biome area.", (AcceptableValueBase)null, Array.Empty<object>()));
			_clayPit2MinDistance = config("6- ClayPit-BoarSpawn", "Minimum Distance", 128f, new ConfigDescription("Minimum distance to group.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 500f), Array.Empty<object>()));
			_clayPit2Count = config("6- ClayPit-BoarSpawn", "Max Count", 100, new ConfigDescription("Maximum count to try to spawn.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 200), Array.Empty<object>()));
			PrefabsSetup.Init();
			ClayPitSetup.Init();
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			ConfigWatcher();
		}

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

		static Plugin()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			configFileFullPath = configPath + directorySeparatorChar + configFileName;
			FWPLogger = Logger.CreateLogSource("FineWoodPieces");
			_harmony = new Harmony("blacks7ar.FineWoodPieces");
			_configSync = new ConfigSync("blacks7ar.FineWoodPieces")
			{
				DisplayName = "FineWoodPieces",
				CurrentVersion = "1.4.8",
				MinimumRequiredVersion = "1.4.8"
			};
		}
	}
}
namespace FineWoodPieces.Patches
{
	[HarmonyPatch]
	public class ClayCollectorPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(ClayCollector), "Awake")]
		private static void Awake_Prefix(ref float ___m_secPerUnit, ref int ___m_maxClay, ClayCollector __instance)
		{
			Plugin._secPerUnit.SettingChanged += delegate
			{
				__instance.m_secPerUnit = Plugin._secPerUnit.Value;
			};
			___m_secPerUnit = Plugin._secPerUnit.Value;
			Plugin._maxClay.SettingChanged += delegate
			{
				__instance.m_maxClay = Plugin._maxClay.Value;
			};
			___m_maxClay = Plugin._maxClay.Value;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ClayCollector), "UpdateEffects")]
		private static void UpdateEffects_Postfix(ClayCollector __instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid() || !((Object)((Component)__instance).gameObject).name.StartsWith("BCP_Clay"))
			{
				return;
			}
			Transform val = Utils.FindChild(((Component)__instance).gameObject.transform, "refinery_high", (IterativeSearchType)0);
			Transform val2 = Utils.FindChild(((Component)__instance).gameObject.transform, "refinery_high_worn", (IterativeSearchType)0);
			Transform val3 = Utils.FindChild(((Component)__instance).gameObject.transform, "refineryBroken", (IterativeSearchType)0);
			if (__instance.GetStatusText() == __instance.m_collectingText)
			{
				if (((Component)val).gameObject.activeInHierarchy)
				{
					((Component)val).gameObject.GetComponent<Animator>().speed = 1f;
				}
				else if (((Component)val2).gameObject.activeInHierarchy)
				{
					((Component)val2).gameObject.GetComponent<Animator>().speed = 1f;
				}
				else if (((Component)val3).gameObject.activeInHierarchy)
				{
					((Component)val3).gameObject.GetComponent<Animator>().speed = 1f;
				}
			}
			else if (((Component)val).gameObject.activeInHierarchy)
			{
				((Component)val).gameObject.GetComponent<Animator>().speed = 0f;
			}
			else if (((Component)val2).gameObject.activeInHierarchy)
			{
				((Component)val2).gameObject.GetComponent<Animator>().speed = 0f;
			}
			else if (((Component)val3).gameObject.activeInHierarchy)
			{
				((Component)val3).gameObject.GetComponent<Animator>().speed = 0f;
			}
		}
	}
	[HarmonyPatch]
	public class ObjectDBPatch
	{
		[HarmonyPriority(700)]
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		[HarmonyPostfix]
		public static void Awake_Postfix(ObjectDB __instance)
		{
			RegisterPrefabsToObjectDB.Init();
			RegisterRecipesToObjectDB.Init();
			__instance.UpdateItemHashes();
		}

		[HarmonyPriority(700)]
		[HarmonyPostfix]
		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		public static void CopyOtherDB_Postfix(ObjectDB __instance)
		{
			RegisterPrefabsToObjectDB.Init();
			RegisterRecipesToObjectDB.Init();
			__instance.UpdateItemHashes();
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	public class ZNetScenePatch
	{
		public static void Postfix()
		{
			RegisterPrefabsToZNetScene.Init();
			RegisterPrefabsToZNetScene.Effects();
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "ValidateVegetation")]
	public class ZoneSystemPatch
	{
		private static readonly List<ZoneVegetation> _resourceList = new List<ZoneVegetation>();

		public static void Prefix(ZoneSystem __instance)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00df: 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_00f7: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: 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_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			foreach (ZoneVegetation resource in _resourceList)
			{
				__instance.m_vegetation.Remove(resource);
			}
			_resourceList.Clear();
			ZoneVegetation item = new ZoneVegetation
			{
				m_enable = (Plugin._enableReed.Value == Toggle.On),
				m_groupRadius = Plugin._reedGroupRadius.Value,
				m_groupSizeMin = Plugin._reedGroupSizeMin.Value,
				m_groupSizeMax = Plugin._reedGroupSizeMax.Value,
				m_max = Plugin._reedMax.Value,
				m_chanceToUseGroundTilt = 1f,
				m_biome = (Biome)9,
				m_minAltitude = -0.6f,
				m_maxAltitude = 1.8f,
				m_maxTerrainDelta = 2f,
				m_prefab = PrefabsSetup._pickableReed
			};
			ZoneVegetation item2 = new ZoneVegetation
			{
				m_enable = (Plugin._enableClay.Value == Toggle.On),
				m_groupRadius = Plugin._clayGroupRadius.Value,
				m_groupSizeMin = Plugin._clayGroupSizeMin.Value,
				m_groupSizeMax = Plugin._clayGroupSizeMax.Value,
				m_max = Plugin._clayMax.Value,
				m_chanceToUseGroundTilt = 1f,
				m_biome = (Biome)539,
				m_minAltitude = -0.5f,
				m_maxAltitude = 2f,
				m_maxTerrainDelta = 2f,
				m_prefab = PrefabsSetup._pickableClay
			};
			ZoneVegetation item3 = new ZoneVegetation
			{
				m_enable = (Plugin._enableClayBig.Value == Toggle.On),
				m_groupRadius = Plugin._clayBigGroupRadius.Value,
				m_groupSizeMin = Plugin._clayBigGroupSizeMin.Value,
				m_groupSizeMax = Plugin._clayBigGroupSizeMax.Value,
				m_max = Plugin._clayBigMax.Value,
				m_chanceToUseGroundTilt = 1f,
				m_biome = (Biome)539,
				m_minAltitude = -0.5f,
				m_maxAltitude = 2f,
				m_maxTerrainDelta = 2f,
				m_prefab = PrefabsSetup._pickableClayBig
			};
			_resourceList.Add(item);
			_resourceList.Add(item2);
			_resourceList.Add(item3);
			foreach (ZoneVegetation resource2 in _resourceList)
			{
				__instance.m_vegetation.Add(resource2);
			}
		}
	}
}
namespace FineWoodPieces.Functions
{
	public class ClayCollector : MonoBehaviour, Hoverable, Interactable
	{
		public string m_name;

		public Transform m_spawnPoint;

		public float m_secPerUnit = 10f;

		public int m_maxClay = 4;

		public ItemDrop m_clayItem;

		public EffectList m_spawnEffect = new EffectList();

		public GameObject m_enabledObject;

		public Biome m_biome;

		[Header("Texts")]
		public string m_extractText = "$bcp_claycollector_extract";

		public string m_collectingText = "$bcp_claycollector_collecting";

		public string m_notConnectedText = "$bcp_claycollector_notconnected";

		public string m_fullText = "$bcp_claycollector_full";

		public ZNetView m_nview;

		private Collider m_collider;

		private Piece m_piece;

		private bool m_connected;

		public void Awake()
		{
			m_nview = ((Component)this).GetComponent<ZNetView>();
			m_collider = ((Component)this).GetComponentInChildren<Collider>();
			m_piece = ((Component)this).GetComponent<Piece>();
			if (m_nview.GetZDO() != null)
			{
				if (m_nview.IsOwner() && m_nview.GetZDO().GetLong(ZDOVars.s_lastTime, 0L) == 0L)
				{
					m_nview.GetZDO().Set(ZDOVars.s_lastTime, ZNet.instance.GetTime().Ticks);
				}
				m_nview.Register("RPC_Extract", (Action<long>)RPC_Extract);
				m_nview.Register("RPC_UpdateEffects", (Action<long>)RPC_UpdateEffects);
				((MonoBehaviour)this).InvokeRepeating("UpdateTicks", Random.Range(0f, 2f), 5f);
			}
		}

		public string GetHoverText()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!PrivateArea.CheckAccess(((Component)this).transform.position, 0f, false, false))
			{
				return Localization.instance.Localize(m_name + "\n$bcp_noaccess");
			}
			int tarLevel = GetTarLevel();
			string statusText = GetStatusText();
			string text = ((!m_connected) ? (m_name + "\n( " + statusText + ", " + tarLevel + " / " + m_maxClay + " ) ") : (m_name + "\n( " + statusText + ", " + tarLevel + " / " + m_maxClay + " ) <color=orange>" + TimeLeft() + "</color>"));
			if (tarLevel > 0)
			{
				text = text + "\n[<color=yellow><b>$KEY_Use</b></color>] " + m_extractText;
			}
			return Localization.instance.Localize(text);
		}

		public string GetHoverName()
		{
			return m_name;
		}

		public bool Interact(Humanoid character, bool repeat, bool alt)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (repeat)
			{
				return false;
			}
			if (!PrivateArea.CheckAccess(((Component)this).transform.position, 0f, true, false))
			{
				return true;
			}
			if (GetTarLevel() <= 0)
			{
				return false;
			}
			Extract();
			return true;
		}

		public string GetStatusText()
		{
			if (GetTarLevel() >= m_maxClay)
			{
				return m_fullText;
			}
			if (!m_connected)
			{
				return m_notConnectedText;
			}
			return m_collectingText;
		}

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

		public void Extract()
		{
			m_nview.InvokeRPC("RPC_Extract", Array.Empty<object>());
		}

		public void RPC_Extract(long caller)
		{
			//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_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_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_005c: 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_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_0074: Unknown result type (might be due to invalid IL or missing references)
			int tarLevel = GetTarLevel();
			if (tarLevel > 0)
			{
				m_spawnEffect.Create(m_spawnPoint.position, Quaternion.identity, (Transform)null, 1f, -1);
				for (int i = 0; i < tarLevel; i++)
				{
					Vector2 val = Random.insideUnitCircle * 0.5f;
					Vector3 val2 = m_spawnPoint.position + new Vector3(val.x, 0.25f * (float)i, val.y);
					Object.Instantiate<ItemDrop>(m_clayItem, val2, Quaternion.identity);
				}
				ResetLevel();
				m_nview.InvokeRPC(ZNetView.Everybody, "RPC_UpdateEffects", Array.Empty<object>());
			}
		}

		private float GetTimeSinceLastUpdate()
		{
			DateTime dateTime = new DateTime(m_nview.GetZDO().GetLong(ZDOVars.s_lastTime, ZNet.instance.GetTime().Ticks));
			DateTime time = ZNet.instance.GetTime();
			TimeSpan timeSpan = time - dateTime;
			m_nview.GetZDO().Set(ZDOVars.s_lastTime, time.Ticks);
			double num = timeSpan.TotalSeconds;
			if (num < 0.0)
			{
				num = 0.0;
			}
			return (float)num;
		}

		public void ResetLevel()
		{
			m_nview.GetZDO().Set(ZDOVars.s_level, 0, false);
		}

		public void IncreaseLevel(int i)
		{
			int tarLevel = GetTarLevel();
			tarLevel += i;
			tarLevel = Mathf.Clamp(tarLevel, 0, m_maxClay);
			m_nview.GetZDO().Set(ZDOVars.s_level, tarLevel, false);
		}

		private int GetTarLevel()
		{
			if (m_nview.GetZDO() != null)
			{
				return m_nview.GetZDO().GetInt(ZDOVars.s_level, 0);
			}
			return 0;
		}

		public void UpdateTicks()
		{
			//IL_0016: 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)
			if (CheckBiome() && !m_connected)
			{
				Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, 0.2f);
				for (int i = 0; i < array.Length; i++)
				{
					LiquidVolume componentInParent = ((Component)array[i]).GetComponentInParent<LiquidVolume>();
					if (!((Object)(object)componentInParent == (Object)null) && (int)componentInParent.m_liquidType == 0)
					{
						m_connected = true;
						break;
					}
				}
			}
			bool flag = CheckBiome() && m_connected;
			if (m_nview.IsOwner() && flag)
			{
				float timeSinceLastUpdate = GetTimeSinceLastUpdate();
				if (GetTarLevel() < m_maxClay)
				{
					float @float = m_nview.GetZDO().GetFloat(ZDOVars.s_product, 0f);
					@float += timeSinceLastUpdate;
					if (@float > m_secPerUnit)
					{
						int i2 = (int)(@float / m_secPerUnit);
						IncreaseLevel(i2);
						@float = 0f;
					}
					m_nview.GetZDO().Set(ZDOVars.s_product, @float);
				}
			}
			UpdateEffects();
		}

		public void RPC_UpdateEffects(long caller)
		{
			UpdateEffects();
		}

		public void UpdateEffects()
		{
			bool active = GetTarLevel() < m_maxClay && m_connected && GetStatusText() == m_collectingText;
			m_enabledObject.SetActive(active);
		}

		private bool CheckBiome()
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			return (Heightmap.FindBiome(((Component)this).transform.position) & m_biome) > 0;
		}

		private string TimeLeft()
		{
			string result = "";
			if (GetTarLevel() == m_maxClay)
			{
				return result;
			}
			if (!m_nview.IsValid() || !m_nview.IsOwner())
			{
				return result;
			}
			float @float = m_nview.GetZDO().GetFloat(ZDOVars.s_product, 0f);
			float num = m_secPerUnit - @float;
			int num2 = Mathf.FloorToInt((float)((int)num / 60));
			int num3 = Mathf.FloorToInt((float)((int)num % 60));
			return $"[ {num2:00}:{num3:00} ]";
		}
	}
	public static class ClayPitSetup
	{
		public static void Init()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			Location.ConfigurationEnabled = false;
			new Location(PrefabsSetup._finewoodBundle, "BCP_ClayPit")
			{
				Biome = Plugin._clayPit1Biome.Value,
				SpawnAltitude = new LocationManager.Range(1f, 60f),
				SpawnDistance = new LocationManager.Range(100f, 7000f),
				HeightDelta = new LocationManager.Range(0f, 2f),
				SpawnArea = Plugin._clayPit1BiomeArea.Value,
				Rotation = Rotation.Random,
				CanSpawn = true,
				GroupName = "claypit",
				MinimumDistanceFromGroup = Plugin._clayPit1MinDistance.Value,
				Count = Plugin._clayPit1Count.Value,
				ForestThreshold = new LocationManager.Range(0f, 1.1f),
				CreatureSpawner = 
				{
					{ "neck_spawner_1", "Neck" },
					{ "neck_spawner_2", "Neck" },
					{ "neck_spawner_3", "Neck" },
					{ "neck_spawner_4", "Neck" },
					{ "neck_spawner_5", "Neck" },
					{ "neck_spawner_6", "Neck" },
					{ "neck_spawner_7", "Neck" },
					{ "neck_respawner_1", "Neck" },
					{ "neck_respawner_2", "Neck" }
				}
			};
			new Location(PrefabsSetup._finewoodBundle, "BCP_ClayPit1")
			{
				Biome = Plugin._clayPit2Biome.Value,
				SpawnAltitude = new LocationManager.Range(1f, 60f),
				SpawnDistance = new LocationManager.Range(100f, 7000f),
				HeightDelta = new LocationManager.Range(0f, 2f),
				SpawnArea = Plugin._clayPit2BiomeArea.Value,
				Rotation = Rotation.Random,
				CanSpawn = true,
				GroupName = "claypit",
				MinimumDistanceFromGroup = Plugin._clayPit2MinDistance.Value,
				Count = Plugin._clayPit2Count.Value,
				ForestThreshold = new LocationManager.Range(0f, 1.1f),
				CreatureSpawner = 
				{
					{ "boar_spawner_1", "Boar" },
					{ "boar_spawner_2", "Boar" },
					{ "boar_spawner_3", "Boar" },
					{ "boar_spawner_4", "Boar" },
					{ "boar_spawner_5", "Boar" },
					{ "boar_spawner_6", "Boar" },
					{ "boar_spawner_7", "Boar" },
					{ "boar_respawner_1", "Boar" },
					{ "boar_respawner_2", "Boar" }
				}
			};
		}
	}
	public static class Helper
	{
		public static void AddGameObject(this ZNetScene zNetScene, GameObject gameObject, bool overWrite = true)
		{
			GameObject prefab;
			if ((Object)(object)(prefab = zNetScene.GetPrefab(((Object)gameObject).name)) != (Object)null)
			{
				if (!overWrite)
				{
					return;
				}
				zNetScene.m_prefabs.Remove(prefab);
				zNetScene.m_namedPrefabs.Remove(StringExtensionMethods.GetStableHashCode(((Object)gameObject).name));
			}
			zNetScene.m_prefabs.Add(gameObject);
			zNetScene.m_namedPrefabs.Add(StringExtensionMethods.GetStableHashCode(((Object)gameObject).name), gameObject);
		}

		public static void AddGameObject(this ObjectDB objectDB, GameObject gameObject, bool overWrite = true)
		{
			GameObject itemPrefab;
			if ((Object)(object)(itemPrefab = objectDB.GetItemPrefab(((Object)gameObject).name)) != (Object)null)
			{
				if (!overWrite)
				{
					return;
				}
				objectDB.m_items.Remove(itemPrefab);
				objectDB.m_itemByHash.Remove(StringExtensionMethods.GetStableHashCode(((Object)gameObject).name));
			}
			objectDB.m_items.Add(gameObject);
			objectDB.m_itemByHash.Add(StringExtensionMethods.GetStableHashCode(((Object)gameObject).name), gameObject);
		}

		public static void AddRecipe(this ObjectDB objectDB, Recipe recipe, bool overWrite = true)
		{
			Recipe recipe2;
			if ((Object)(object)(recipe2 = objectDB.GetRecipe(recipe.m_item.m_itemData)) != (Object)null)
			{
				if (!overWrite)
				{
					return;
				}
				objectDB.m_recipes.Remove(recipe2);
			}
			objectDB.m_recipes.Add(recipe);
		}

		public static void AddToHammer(this ObjectDB objectDB, GameObject gameObject, bool overWrite = true)
		{
			PieceTable buildPieces = PrefabsSetup._fineHammer.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
			if (buildPieces.m_pieces.Contains(gameObject))
			{
				if (!overWrite)
				{
					return;
				}
				buildPieces.m_pieces.Remove(gameObject);
			}
			buildPieces.m_pieces.Add(gameObject);
		}

		public static bool ObjectDBAwake()
		{
			if ((Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items.Count != 0)
			{
				return (Object)(object)ObjectDB.instance.GetItemPrefab("Wood") != (Object)null;
			}
			return false;
		}

		public static bool ZNetSceneAwake()
		{
			if ((Object)(object)ZNetScene.instance != (Object)null && ZNetScene.instance.m_prefabs.Count != 0)
			{
				return (Object)(object)ZNetScene.instance.GetPrefab("piece_workbench") != (Object)null;
			}
			return false;
		}
	}
	public static class Logging
	{
		public static void LogDebug(string debug)
		{
			Plugin.FWPLogger.LogDebug((object)debug);
		}

		public static void LogInfo(string info)
		{
			Plugin.FWPLogger.LogInfo((object)info);
		}

		public static void LogWarning(string warning)
		{
			Plugin.FWPLogger.LogWarning((object)warning);
		}

		public static void LogError(string error)
		{
			Plugin.FWPLogger.LogError((object)error);
		}
	}
	public static class PrefabsSetup
	{
		public static AssetBundle _finewoodBundle;

		public static GameObject _barrelClutter;

		public static GameObject _bronzeFrameChest;

		public static GameObject _fineHammer;

		public static GameObject _fineHammerRepair;

		public static GameObject _finewoodBasket;

		public static GameObject _finewoodBeam1x1;

		public static GameObject _finewoodBeam2x2;

		public static GameObject _finewoodBeam26;

		public static GameObject _finewoodBeam45;

		public static GameObject _logChair;

		public static GameObject _finewoodDecoWall;

		public static GameObject _finewoodDoor;

		public static GameObject _finewoodFloor1x1;

		public static GameObject _finewoodFloor2x2;

		public static GameObject _finewoodGate;

		public static GameObject _finewoodHalfWall;

		public static GameObject _finewoodLedge;

		public static GameObject _finewoodPole1x1;

		public static GameObject _finewoodPole2x2;

		public static GameObject _finewoodQuaterWall;

		public static GameObject _finewoodRoof26;

		public static GameObject _finewoodRoof45;

		public static GameObject _finewoodRoofCross26;

		public static GameObject _finewoodRoofCross45;

		public static GameObject _finewoodRoofICorner26;

		public static GameObject _finewoodRoofICorner45;

		public static GameObject _finewoodRoofOCorner26;

		public static GameObject _finewoodRoofOCorner45;

		public static GameObject _finewoodRoofTop26;

		public static GameObject _finewoodRoofTop45;

		public static GameObject _finewoodStair;

		public static GameObject _finewoodStepLadder;

		public static GameObject _finewoodStool;

		public static GameObject _finewoodWall;

		public static GameObject _finewoodWallRoof26;

		public static GameObject _finewoodWallRoof26_UpsideDown;

		public static GameObject _finewoodWallRoof45;

		public static GameObject _finewoodWallRoof45_UpsideDown;

		public static GameObject _finewoodWindowShutter;

		public static GameObject _longCrate;

		public static GameObject _pickableReed;

		public static GameObject _shelfClutter;

		public static GameObject _stoneLighPost;

		public static GameObject _stoneRoof26;

		public static GameObject _stoneRoof45;

		public static GameObject _stoneRoofICorner26;

		public static GameObject _stoneRoofICorner45;

		public static GameObject _stoneRoofOCorner26;

		public static GameObject _stoneRoofOCorner45;

		public static GameObject _stoneRoofTop26;

		public static GameObject _stoneRoofTop45;

		public static GameObject _straw;

		public static GameObject _thatchHalfWall;

		public static GameObject _thatchQuaterWall;

		public static GameObject _thatchWall;

		public static GameObject _finewoodBed1;

		public static GameObject _finewoodBed2;

		public static GameObject _finewoodBench1;

		public static GameObject _finewoodBench2;

		public static GameObject _finewoodBench3;

		public static GameObject _finewoodBench4;

		public static GameObject _finewoodBench5;

		public static GameObject _finewoodBench6;

		public static GameObject _finewoodBench7;

		public static GameObject _finewoodCabinet1;

		public static GameObject _finewoodCabinet2;

		public static GameObject _finewoodCabinet3;

		public static GameObject _finewoodCabinet4;

		public static GameObject _finewoodCabinet5;

		public static GameObject _finewoodCabinet6;

		public static GameObject _horizontalDecoWall;

		public static GameObject _finewoodChair1;

		public static GameObject _finewoodChair2;

		public static GameObject _finewoodChair3;

		public static GameObject _finewoodChair4;

		public static GameObject _finewoodChair5;

		public static GameObject _finewoodCrib;

		public static GameObject _deskDrawer1;

		public static GameObject _deskDrawer2;

		public static GameObject _deskDrawer3;

		public static GameObject _deskDrawer4;

		public static GameObject _deskDrawer5;

		public static GameObject _finewoodTable1;

		public static GameObject _miniStool1;

		public static GameObject _miniStool2;

		public static GameObject _miniTable1;

		public static GameObject _miniTable2;

		public static GameObject _miniTable3;

		public static GameObject _shelf1;

		public static GameObject _shelf2;

		public static GameObject _shelf3;

		public static GameObject _shelf4;

		public static GameObject _shelf5;

		public static GameObject _stool1;

		public static GameObject _stool2;

		public static GameObject _finewoodChair6;

		public static GameObject _finewoodTable2;

		public static GameObject _finewoodTable3;

		public static GameObject _finewoodTable4;

		public static GameObject _finewoodTable5;

		public static GameObject _finewoodTable6;

		public static GameObject _finewoodTable7;

		public static GameObject _finewoodTable8;

		public static GameObject _finewoodTable9;

		public static GameObject _poolChair;

		public static GameObject _stepLadder;

		public static GameObject _armorStand;

		public static GameObject _stepLadder2;

		public static GameObject _plant1;

		public static GameObject _plant2;

		public static GameObject _plant3;

		public static GameObject _plant4;

		public static GameObject _plant5;

		public static GameObject _plant6;

		public static GameObject _plant7;

		public static GameObject _plant8;

		public static GameObject _finewoodBench8;

		public static GameObject _finewoodBench9;

		public static GameObject _finewoodCabinet7;

		public static GameObject _cupboard;

		public static GameObject _finewoodChair7;

		public static GameObject _loxDoubleBed;

		public static GameObject _loxBed;

		public static GameObject _plant9;

		public static GameObject _plant10;

		public static GameObject _plant11;

		public static GameObject _plant12;

		public static GameObject _plant13;

		public static GameObject _candle;

		public static GameObject _clay;

		public static GameObject _clayArch;

		public static GameObject _clayBase1;

		public static GameObject _clayBase2;

		public static GameObject _clayBaseCorner;

		public static GameObject _clayBlock1x1;

		public static GameObject _clayBlock2x1x1;

		public static GameObject _clayBlock2x2_Enforced;

		public static GameObject _clayBlock2x2x1;

		public static GameObject _clayBlock2x2x2;

		public static GameObject _clayBlock_OutCorner;

		public static GameObject _clayBlock_SlopeInverted1x2;

		public static GameObject _clayBlockOut1;

		public static GameObject _clayBlockOut2;

		public static GameObject _clayBlockSlope1x2;

		public static GameObject _clayColumn1;

		public static GameObject _clayColumn2;

		public static GameObject _clayFloor;

		public static GameObject _clayFloorLarge;

		public static GameObject _clayFloorTriangle;

		public static GameObject _clayHead1;

		public static GameObject _clayHead2;

		public static GameObject _clayLightPost;

		public static GameObject _clayRoof26;

		public static GameObject _clayRoof45;

		public static GameObject _clayRoofICorner26;

		public static GameObject _clayRoofICorner45;

		public static GameObject _clayRoofOCorner26;

		public static GameObject _clayRoofOCorner45;

		public static GameObject _clayRoofTop26;

		public static GameObject _clayRoofTop45;

		public static GameObject _clayStair;

		public static GameObject _clayTileFloor1x1;

		public static GameObject _clayTileFloor2x2;

		public static GameObject _clayTileWall1x1;

		public static GameObject _clayTileWall2x2;

		public static GameObject _clayTileWall2x4;

		public static GameObject _clayTip;

		public static GameObject _flowerStand1;

		public static GameObject _flowerStand2;

		public static GameObject _lantern1;

		public static GameObject _lantern2;

		public static GameObject _lantern3;

		public static GameObject _lantern4;

		public static GameObject _lantern5;

		public static GameObject _lantern6;

		public static GameObject _lantern7;

		public static GameObject _leatherBed;

		public static GameObject _pickableClay;

		public static GameObject _pickableClayBig;

		public static GameObject _plant14;

		public static GameObject _plant15;

		public static GameObject _plant16;

		public static GameObject _plant17;

		public static GameObject _plant18;

		public static GameObject _clayArch2;

		public static GameObject _clayArmorStand;

		public static GameObject _clayChest;

		public static GameObject _clayCorgi;

		public static GameObject _clayDeer;

		public static GameObject _clayHare;

		public static GameObject _clayPillar;

		public static GameObject _fenceGate;

		public static GameObject _fencePillar1;

		public static GameObject _fencePillar2;

		public static GameObject _fencePillar3;

		public static GameObject _fencePillar4;

		public static GameObject _fenceTile1;

		public static GameObject _fenceTile2;

		public static GameObject _fenceTile3;

		public static GameObject _fenceTile4;

		public static GameObject _finewoodArch;

		public static GameObject _finewoodDragon;

		public static GameObject _finewoodRaven;

		public static GameObject _finewoodWolf;

		public static GameObject _heavyGate;

		public static GameObject _woodenArmorStand;

		public static GameObject _glassWindow1;

		public static GameObject _glassWindow2;

		private static GameObject _clayPit;

		private static GameObject _clayPit2;

		public static GameObject _clayCollector;

		public static GameObject _thatchWindow;

		public static GameObject _thatchWindowHalf;

		public static GameObject _thatchWindowQuarter;

		public static GameObject _trapDoor;

		public static GameObject _window;

		public static GameObject _windowHalf;

		public static GameObject _windowQuarter;

		public static void Init()
		{
			_finewoodBundle = Location.PrefabManager.RegisterAssetBundle("finewoodbundle");
			_barrelClutter = _finewoodBundle.LoadAsset<GameObject>("BFP_BarrelClutter");
			ShaderReplacer.Replace(_barrelClutter);
			_bronzeFrameChest = _finewoodBundle.LoadAsset<GameObject>("BFP_BronzeFrameChest");
			ShaderReplacer.Replace(_bronzeFrameChest);
			_fineHammer = _finewoodBundle.LoadAsset<GameObject>("BFP_FineHammer");
			_fineHammerRepair = _finewoodBundle.LoadAsset<GameObject>("BFP_FineHammerRepair");
			_finewoodBasket = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodBasket");
			_finewoodBeam1x1 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodBeam1x1");
			ShaderReplacer.Replace(_finewoodBeam1x1);
			_finewoodBeam2x2 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodBeam2x2");
			ShaderReplacer.Replace(_finewoodBeam2x2);
			_finewoodBeam26 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodBeam26");
			ShaderReplacer.Replace(_finewoodBeam26);
			_finewoodBeam45 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodBeam45");
			ShaderReplacer.Replace(_finewoodBeam45);
			_logChair = _finewoodBundle.LoadAsset<GameObject>("BFP_LogChair");
			ShaderReplacer.Replace(_logChair);
			_finewoodDecoWall = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodDecoWall");
			_finewoodDoor = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodDoor");
			ShaderReplacer.Replace(_finewoodDoor);
			_finewoodFloor1x1 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodFloor1x1");
			ShaderReplacer.Replace(_finewoodFloor1x1);
			_finewoodFloor2x2 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodFloor2x2");
			ShaderReplacer.Replace(_finewoodFloor2x2);
			_finewoodGate = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodGate");
			ShaderReplacer.Replace(_finewoodGate);
			_finewoodHalfWall = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodHalfWall");
			ShaderReplacer.Replace(_finewoodHalfWall);
			_finewoodLedge = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodLedge");
			ShaderReplacer.Replace(_finewoodLedge);
			_finewoodPole1x1 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodPole1x1");
			ShaderReplacer.Replace(_finewoodPole1x1);
			_finewoodPole2x2 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodPole2x2");
			ShaderReplacer.Replace(_finewoodPole2x2);
			_finewoodQuaterWall = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodQuarterWall");
			ShaderReplacer.Replace(_finewoodQuaterWall);
			_finewoodRoof26 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRoof26");
			ShaderReplacer.Replace(_finewoodRoof26);
			_finewoodRoof45 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRoof45");
			ShaderReplacer.Replace(_finewoodRoof45);
			_finewoodRoofCross26 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRoofCross26");
			ShaderReplacer.Replace(_finewoodRoofCross26);
			_finewoodRoofCross45 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRoofCross45");
			ShaderReplacer.Replace(_finewoodRoofCross45);
			_finewoodRoofICorner26 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRoofICorner26");
			ShaderReplacer.Replace(_finewoodRoofICorner26);
			_finewoodRoofICorner45 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRoofICorner45");
			ShaderReplacer.Replace(_finewoodRoofICorner45);
			_finewoodRoofOCorner26 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRoofOCorner26");
			ShaderReplacer.Replace(_finewoodRoofOCorner26);
			_finewoodRoofOCorner45 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRoofOCorner45");
			ShaderReplacer.Replace(_finewoodRoofOCorner45);
			_finewoodRoofTop26 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRoofTop26");
			ShaderReplacer.Replace(_finewoodRoofTop26);
			_finewoodRoofTop45 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRoofTop45");
			ShaderReplacer.Replace(_finewoodRoofTop45);
			_finewoodStair = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodStair");
			ShaderReplacer.Replace(_finewoodStair);
			_finewoodStepLadder = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodStepLadder");
			ShaderReplacer.Replace(_finewoodStepLadder);
			_finewoodStool = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodStool");
			ShaderReplacer.Replace(_finewoodStool);
			_finewoodWall = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodWall");
			ShaderReplacer.Replace(_finewoodWall);
			_finewoodWallRoof26 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodWallRoof26");
			ShaderReplacer.Replace(_finewoodWallRoof26);
			_finewoodWallRoof26_UpsideDown = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodWallRoof26_UpsideDown");
			ShaderReplacer.Replace(_finewoodWallRoof26_UpsideDown);
			_finewoodWallRoof45 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodWallRoof45");
			ShaderReplacer.Replace(_finewoodWallRoof45);
			_finewoodWallRoof45_UpsideDown = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodWallRoof45_UpsideDown");
			ShaderReplacer.Replace(_finewoodWallRoof45_UpsideDown);
			_finewoodWindowShutter = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodWindowShutter");
			ShaderReplacer.Replace(_finewoodWindowShutter);
			_longCrate = _finewoodBundle.LoadAsset<GameObject>("BFP_LongCrate");
			ShaderReplacer.Replace(_longCrate);
			_pickableReed = _finewoodBundle.LoadAsset<GameObject>("BFP_Pickable_Reed");
			ShaderReplacer.Replace(_pickableReed);
			_shelfClutter = _finewoodBundle.LoadAsset<GameObject>("BFP_ShelfClutter");
			ShaderReplacer.Replace(_shelfClutter);
			_stoneLighPost = _finewoodBundle.LoadAsset<GameObject>("BFP_StoneLightPost");
			ShaderReplacer.Replace(_stoneLighPost);
			_stoneRoof26 = _finewoodBundle.LoadAsset<GameObject>("BFP_StoneRoof26");
			ShaderReplacer.Replace(_stoneRoof26);
			_stoneRoof45 = _finewoodBundle.LoadAsset<GameObject>("BFP_StoneRoof45");
			ShaderReplacer.Replace(_stoneRoof45);
			_stoneRoofICorner26 = _finewoodBundle.LoadAsset<GameObject>("BFP_StoneRoofICorner26");
			ShaderReplacer.Replace(_stoneRoofICorner26);
			_stoneRoofICorner45 = _finewoodBundle.LoadAsset<GameObject>("BFP_StoneRoofICorner45");
			ShaderReplacer.Replace(_stoneRoofICorner45);
			_stoneRoofOCorner26 = _finewoodBundle.LoadAsset<GameObject>("BFP_StoneRoofOCorner26");
			ShaderReplacer.Replace(_stoneRoofOCorner26);
			_stoneRoofOCorner45 = _finewoodBundle.LoadAsset<GameObject>("BFP_StoneRoofOCorner45");
			ShaderReplacer.Replace(_stoneRoofOCorner45);
			_stoneRoofTop26 = _finewoodBundle.LoadAsset<GameObject>("BFP_StoneRoofTop26");
			ShaderReplacer.Replace(_stoneRoofTop26);
			_stoneRoofTop45 = _finewoodBundle.LoadAsset<GameObject>("BFP_StoneRoofTop45");
			ShaderReplacer.Replace(_stoneRoofTop45);
			_straw = _finewoodBundle.LoadAsset<GameObject>("BFP_Straw");
			ShaderReplacer.Replace(_straw);
			_thatchHalfWall = _finewoodBundle.LoadAsset<GameObject>("BFP_ThatchHalfWall");
			ShaderReplacer.Replace(_thatchHalfWall);
			_thatchQuaterWall = _finewoodBundle.LoadAsset<GameObject>("BFP_ThatchQuarterWall");
			ShaderReplacer.Replace(_thatchQuaterWall);
			_thatchWall = _finewoodBundle.LoadAsset<GameObject>("BFP_ThatchWall");
			ShaderReplacer.Replace(_thatchWall);
			_finewoodBed1 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodBed1");
			ShaderReplacer.Replace(_finewoodBed1);
			_finewoodBed2 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodBed2");
			ShaderReplacer.Replace(_finewoodBed2);
			_finewoodBench1 = _finewoodBundle.LoadAsset<GameObject>("BFP_Bench1");
			ShaderReplacer.Replace(_finewoodBench1);
			_finewoodBench2 = _finewoodBundle.LoadAsset<GameObject>("BFP_Bench2");
			ShaderReplacer.Replace(_finewoodBench2);
			_finewoodBench3 = _finewoodBundle.LoadAsset<GameObject>("BFP_Bench3");
			ShaderReplacer.Replace(_finewoodBench3);
			_finewoodBench4 = _finewoodBundle.LoadAsset<GameObject>("BFP_Bench4");
			ShaderReplacer.Replace(_finewoodBench4);
			_finewoodBench5 = _finewoodBundle.LoadAsset<GameObject>("BFP_Bench5");
			ShaderReplacer.Replace(_finewoodBench5);
			_finewoodBench6 = _finewoodBundle.LoadAsset<GameObject>("BFP_Bench6");
			ShaderReplacer.Replace(_finewoodBench6);
			_finewoodBench7 = _finewoodBundle.LoadAsset<GameObject>("BFP_Bench7");
			ShaderReplacer.Replace(_finewoodBench7);
			_finewoodCabinet1 = _finewoodBundle.LoadAsset<GameObject>("BFP_Cabinet1");
			ShaderReplacer.Replace(_finewoodCabinet1);
			_finewoodCabinet2 = _finewoodBundle.LoadAsset<GameObject>("BFP_Cabinet2");
			ShaderReplacer.Replace(_finewoodCabinet2);
			_finewoodCabinet3 = _finewoodBundle.LoadAsset<GameObject>("BFP_Cabinet3");
			ShaderReplacer.Replace(_finewoodCabinet3);
			_finewoodCabinet4 = _finewoodBundle.LoadAsset<GameObject>("BFP_Cabinet4");
			ShaderReplacer.Replace(_finewoodCabinet4);
			_finewoodCabinet5 = _finewoodBundle.LoadAsset<GameObject>("BFP_Cabinet5");
			ShaderReplacer.Replace(_finewoodCabinet5);
			_finewoodCabinet6 = _finewoodBundle.LoadAsset<GameObject>("BFP_Cabinet6");
			ShaderReplacer.Replace(_finewoodCabinet6);
			_finewoodChair1 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodChair1");
			ShaderReplacer.Replace(_finewoodChair1);
			_horizontalDecoWall = _finewoodBundle.LoadAsset<GameObject>("BFP_HorizontalDecoWall");
			_finewoodChair2 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodChair2");
			ShaderReplacer.Replace(_finewoodChair2);
			_finewoodChair3 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodChair3");
			ShaderReplacer.Replace(_finewoodChair3);
			_finewoodChair4 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodChair4");
			ShaderReplacer.Replace(_finewoodChair4);
			_finewoodChair5 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodChair5");
			ShaderReplacer.Replace(_finewoodChair5);
			_finewoodCrib = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodCrib");
			ShaderReplacer.Replace(_finewoodCrib);
			_deskDrawer1 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodDrawer1");
			ShaderReplacer.Replace(_deskDrawer1);
			_deskDrawer2 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodDrawer2");
			ShaderReplacer.Replace(_deskDrawer2);
			_deskDrawer3 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodDrawer3");
			ShaderReplacer.Replace(_deskDrawer3);
			_deskDrawer4 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodDrawer4");
			ShaderReplacer.Replace(_deskDrawer4);
			_deskDrawer5 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodDrawer5");
			ShaderReplacer.Replace(_deskDrawer5);
			_finewoodTable1 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodTable1");
			ShaderReplacer.Replace(_finewoodTable1);
			_miniStool1 = _finewoodBundle.LoadAsset<GameObject>("BFP_MiniStool1");
			ShaderReplacer.Replace(_miniStool1);
			_miniStool2 = _finewoodBundle.LoadAsset<GameObject>("BFP_MiniStool2");
			ShaderReplacer.Replace(_miniStool2);
			_miniTable1 = _finewoodBundle.LoadAsset<GameObject>("BFP_MiniTable1");
			ShaderReplacer.Replace(_miniTable1);
			_miniTable2 = _finewoodBundle.LoadAsset<GameObject>("BFP_MiniTable2");
			ShaderReplacer.Replace(_miniTable2);
			_miniTable3 = _finewoodBundle.LoadAsset<GameObject>("BFP_MiniTable4");
			ShaderReplacer.Replace(_miniTable3);
			_shelf1 = _finewoodBundle.LoadAsset<GameObject>("BFP_Shelf1");
			ShaderReplacer.Replace(_shelf1);
			_shelf2 = _finewoodBundle.LoadAsset<GameObject>("BFP_Shelf2");
			ShaderReplacer.Replace(_shelf2);
			_shelf3 = _finewoodBundle.LoadAsset<GameObject>("BFP_Shelf3");
			ShaderReplacer.Replace(_shelf3);
			_shelf4 = _finewoodBundle.LoadAsset<GameObject>("BFP_Shelf4");
			ShaderReplacer.Replace(_shelf4);
			_shelf5 = _finewoodBundle.LoadAsset<GameObject>("BFP_Shelf5");
			ShaderReplacer.Replace(_shelf5);
			_stool1 = _finewoodBundle.LoadAsset<GameObject>("BFP_Stool1");
			ShaderReplacer.Replace(_stool1);
			_stool2 = _finewoodBundle.LoadAsset<GameObject>("BFP_Stool2");
			ShaderReplacer.Replace(_stool2);
			_finewoodChair6 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodChair6");
			ShaderReplacer.Replace(_finewoodChair6);
			_finewoodTable2 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodTable2");
			ShaderReplacer.Replace(_finewoodTable2);
			_finewoodTable3 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodTable3");
			ShaderReplacer.Replace(_finewoodTable3);
			_finewoodTable4 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodTable4");
			ShaderReplacer.Replace(_finewoodTable4);
			_finewoodTable5 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodTable5");
			ShaderReplacer.Replace(_finewoodTable5);
			_finewoodTable6 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodTable6");
			ShaderReplacer.Replace(_finewoodTable6);
			_finewoodTable7 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodTable7");
			ShaderReplacer.Replace(_finewoodTable7);
			_finewoodTable8 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodTable8");
			ShaderReplacer.Replace(_finewoodTable8);
			_finewoodTable9 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodTable9");
			ShaderReplacer.Replace(_finewoodTable9);
			_poolChair = _finewoodBundle.LoadAsset<GameObject>("BFP_PoolChair");
			ShaderReplacer.Replace(_poolChair);
			_stepLadder = _finewoodBundle.LoadAsset<GameObject>("BFP_StepLadder1");
			ShaderReplacer.Replace(_stepLadder);
			_armorStand = _finewoodBundle.LoadAsset<GameObject>("BFP_ArmorStand");
			ShaderReplacer.Replace(_armorStand);
			_stepLadder2 = _finewoodBundle.LoadAsset<GameObject>("BFP_StepLadder2");
			ShaderReplacer.Replace(_stepLadder2);
			_plant1 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant1");
			ShaderReplacer.Replace(_plant1);
			_plant2 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant2");
			ShaderReplacer.Replace(_plant2);
			_plant3 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant3");
			ShaderReplacer.Replace(_plant3);
			_plant4 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant4");
			ShaderReplacer.Replace(_plant4);
			_plant5 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant5");
			ShaderReplacer.Replace(_plant5);
			_plant6 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant6");
			ShaderReplacer.Replace(_plant6);
			_plant7 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant7");
			ShaderReplacer.Replace(_plant7);
			_plant8 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant8");
			ShaderReplacer.Replace(_plant8);
			_finewoodBench8 = _finewoodBundle.LoadAsset<GameObject>("BFP_Bench8");
			ShaderReplacer.Replace(_finewoodBench8);
			_finewoodBench9 = _finewoodBundle.LoadAsset<GameObject>("BFP_Bench9");
			ShaderReplacer.Replace(_finewoodBench9);
			_finewoodCabinet7 = _finewoodBundle.LoadAsset<GameObject>("BFP_Cabinet7");
			ShaderReplacer.Replace(_finewoodCabinet7);
			_cupboard = _finewoodBundle.LoadAsset<GameObject>("BFP_Cupboard");
			ShaderReplacer.Replace(_cupboard);
			_finewoodChair7 = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodChair7");
			ShaderReplacer.Replace(_finewoodChair7);
			_loxDoubleBed = _finewoodBundle.LoadAsset<GameObject>("BFP_LoxDoubleBed");
			ShaderReplacer.Replace(_loxDoubleBed);
			_loxBed = _finewoodBundle.LoadAsset<GameObject>("BFP_LoxBed");
			ShaderReplacer.Replace(_loxBed);
			_plant9 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant9");
			ShaderReplacer.Replace(_plant9);
			_plant10 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant10");
			ShaderReplacer.Replace(_plant10);
			_plant11 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant11");
			ShaderReplacer.Replace(_plant11);
			_plant12 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant12");
			ShaderReplacer.Replace(_plant12);
			_plant13 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant13");
			ShaderReplacer.Replace(_plant13);
			_candle = _finewoodBundle.LoadAsset<GameObject>("BFP_Candle1");
			ShaderReplacer.Replace(_candle);
			_clay = _finewoodBundle.LoadAsset<GameObject>("BFP_Clay");
			ShaderReplacer.Replace(_clay);
			_clayArch = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayArch");
			ShaderReplacer.Replace(_clayArch);
			_clayBase1 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBase1");
			ShaderReplacer.Replace(_clayBase1);
			_clayBase2 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBase2");
			ShaderReplacer.Replace(_clayBase2);
			_clayBaseCorner = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBaseCorner");
			ShaderReplacer.Replace(_clayBaseCorner);
			_clayBlock1x1 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBlock1x1");
			ShaderReplacer.Replace(_clayBlock1x1);
			_clayBlock2x1x1 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBlock2x1x1");
			ShaderReplacer.Replace(_clayBlock2x1x1);
			_clayBlock2x2_Enforced = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBlock2x2_Enforced");
			ShaderReplacer.Replace(_clayBlock2x2_Enforced);
			_clayBlock2x2x1 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBlock2x2x1");
			ShaderReplacer.Replace(_clayBlock2x2x1);
			_clayBlock2x2x2 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBlock2x2x2");
			ShaderReplacer.Replace(_clayBlock2x2x2);
			_clayBlock_OutCorner = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBlock_OutCorner");
			ShaderReplacer.Replace(_clayBlock_OutCorner);
			_clayBlock_SlopeInverted1x2 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBlock_SlopeInverted1x2");
			ShaderReplacer.Replace(_clayBlock_SlopeInverted1x2);
			_clayBlockOut1 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBlockOut1");
			ShaderReplacer.Replace(_clayBlockOut1);
			_clayBlockOut2 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBlockOut2");
			ShaderReplacer.Replace(_clayBlockOut2);
			_clayBlockSlope1x2 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayBlockSlope1x2");
			ShaderReplacer.Replace(_clayBlockSlope1x2);
			_clayColumn1 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayColumn1");
			ShaderReplacer.Replace(_clayColumn1);
			_clayColumn2 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayColumn2");
			ShaderReplacer.Replace(_clayColumn2);
			_clayFloor = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayFloor");
			ShaderReplacer.Replace(_clayFloor);
			_clayFloorLarge = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayFloorLarge");
			ShaderReplacer.Replace(_clayFloorLarge);
			_clayFloorTriangle = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayFloorTriangle");
			ShaderReplacer.Replace(_clayFloorTriangle);
			_clayHead1 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayHead1");
			ShaderReplacer.Replace(_clayHead1);
			_clayHead2 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayHead2");
			ShaderReplacer.Replace(_clayHead2);
			_clayLightPost = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayLightPost");
			ShaderReplacer.Replace(_clayLightPost);
			_clayRoof26 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayRoof26");
			ShaderReplacer.Replace(_clayRoof26);
			_clayRoof45 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayRoof45");
			ShaderReplacer.Replace(_clayRoof45);
			_clayRoofICorner26 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayRoofICorner26");
			ShaderReplacer.Replace(_clayRoofICorner26);
			_clayRoofICorner45 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayRoofICorner45");
			ShaderReplacer.Replace(_clayRoofICorner45);
			_clayRoofOCorner26 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayRoofOCorner26");
			ShaderReplacer.Replace(_clayRoofOCorner26);
			_clayRoofOCorner45 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayRoofOCorner45");
			ShaderReplacer.Replace(_clayRoofOCorner45);
			_clayRoofTop26 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayRoofTop26");
			ShaderReplacer.Replace(_clayRoofTop26);
			_clayRoofTop45 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayRoofTop45");
			ShaderReplacer.Replace(_clayRoofTop45);
			_clayStair = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayStair");
			ShaderReplacer.Replace(_clayStair);
			_clayTileFloor1x1 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayTileFloor1x1");
			ShaderReplacer.Replace(_clayTileFloor1x1);
			_clayTileFloor2x2 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayTileFloor2x2");
			ShaderReplacer.Replace(_clayTileFloor2x2);
			_clayTileWall1x1 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayTileWall1x1");
			ShaderReplacer.Replace(_clayTileWall1x1);
			_clayTileWall2x2 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayTileWall2x2");
			ShaderReplacer.Replace(_clayTileWall2x2);
			_clayTileWall2x4 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayTileWall2x4");
			ShaderReplacer.Replace(_clayTileWall2x4);
			_clayTip = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayTip");
			ShaderReplacer.Replace(_clayTip);
			_flowerStand1 = _finewoodBundle.LoadAsset<GameObject>("BFP_FlowerStand1");
			ShaderReplacer.Replace(_flowerStand1);
			_flowerStand2 = _finewoodBundle.LoadAsset<GameObject>("BFP_FlowerStand2");
			ShaderReplacer.Replace(_flowerStand2);
			_lantern1 = _finewoodBundle.LoadAsset<GameObject>("BFP_Lantern1");
			ShaderReplacer.Replace(_lantern1);
			_lantern2 = _finewoodBundle.LoadAsset<GameObject>("BFP_Lantern2");
			ShaderReplacer.Replace(_lantern2);
			_lantern3 = _finewoodBundle.LoadAsset<GameObject>("BFP_Lantern3");
			ShaderReplacer.Replace(_lantern3);
			_lantern4 = _finewoodBundle.LoadAsset<GameObject>("BFP_Lantern4");
			ShaderReplacer.Replace(_lantern4);
			_lantern5 = _finewoodBundle.LoadAsset<GameObject>("BFP_Lantern5");
			ShaderReplacer.Replace(_lantern5);
			_lantern6 = _finewoodBundle.LoadAsset<GameObject>("BFP_Lantern6");
			ShaderReplacer.Replace(_lantern6);
			_lantern7 = _finewoodBundle.LoadAsset<GameObject>("BFP_Lantern7");
			ShaderReplacer.Replace(_lantern7);
			_leatherBed = _finewoodBundle.LoadAsset<GameObject>("BFP_LeatherBed");
			ShaderReplacer.Replace(_leatherBed);
			_pickableClay = _finewoodBundle.LoadAsset<GameObject>("BFP_Pickable_Clay");
			ShaderReplacer.Replace(_pickableClay);
			_pickableClayBig = _finewoodBundle.LoadAsset<GameObject>("BFP_Pickable_ClayBig");
			ShaderReplacer.Replace(_pickableClayBig);
			_plant14 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant14");
			ShaderReplacer.Replace(_plant14);
			_plant15 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant15");
			ShaderReplacer.Replace(_plant15);
			_plant16 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant16");
			ShaderReplacer.Replace(_plant16);
			_plant17 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant17");
			ShaderReplacer.Replace(_plant17);
			_plant18 = _finewoodBundle.LoadAsset<GameObject>("BFP_Plant18");
			ShaderReplacer.Replace(_plant18);
			_clayArch2 = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayArch2");
			ShaderReplacer.Replace(_clayArch2);
			_clayArmorStand = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayArmorStand");
			ShaderReplacer.Replace(_clayArmorStand);
			_clayChest = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayChest");
			ShaderReplacer.Replace(_clayChest);
			_clayCorgi = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayCorgi");
			ShaderReplacer.Replace(_clayCorgi);
			_clayDeer = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayDeer");
			ShaderReplacer.Replace(_clayDeer);
			_clayHare = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayHare");
			ShaderReplacer.Replace(_clayHare);
			_clayPillar = _finewoodBundle.LoadAsset<GameObject>("BFP_ClayPillar");
			ShaderReplacer.Replace(_clayPillar);
			_fenceGate = _finewoodBundle.LoadAsset<GameObject>("BFP_FenceGate");
			ShaderReplacer.Replace(_fenceGate);
			_fencePillar1 = _finewoodBundle.LoadAsset<GameObject>("BFP_FencePillar1");
			ShaderReplacer.Replace(_fencePillar1);
			_fencePillar2 = _finewoodBundle.LoadAsset<GameObject>("BFP_FencePillar2");
			ShaderReplacer.Replace(_fencePillar2);
			_fencePillar3 = _finewoodBundle.LoadAsset<GameObject>("BFP_FencePillar3");
			ShaderReplacer.Replace(_fencePillar3);
			_fencePillar4 = _finewoodBundle.LoadAsset<GameObject>("BFP_FencePillar4");
			ShaderReplacer.Replace(_fencePillar4);
			_fenceTile1 = _finewoodBundle.LoadAsset<GameObject>("BFP_FenceTile1");
			ShaderReplacer.Replace(_fenceTile1);
			_fenceTile2 = _finewoodBundle.LoadAsset<GameObject>("BFP_FenceTile2");
			ShaderReplacer.Replace(_fenceTile2);
			_fenceTile3 = _finewoodBundle.LoadAsset<GameObject>("BFP_FenceTile3");
			ShaderReplacer.Replace(_fenceTile3);
			_fenceTile4 = _finewoodBundle.LoadAsset<GameObject>("BFP_FenceTile4");
			ShaderReplacer.Replace(_fenceTile4);
			_finewoodArch = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodArch");
			ShaderReplacer.Replace(_finewoodArch);
			_finewoodDragon = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodDragon");
			ShaderReplacer.Replace(_finewoodDragon);
			_finewoodRaven = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodRaven");
			ShaderReplacer.Replace(_finewoodRaven);
			_finewoodWolf = _finewoodBundle.LoadAsset<GameObject>("BFP_FineWoodWolf");
			ShaderReplacer.Replace(_finewoodWolf);
			_heavyGate = _finewoodBundle.LoadAsset<GameObject>("BFP_HeavyGate");
			ShaderReplacer.Replace(_heavyGate);
			_woodenArmorStand = _finewoodBundle.LoadAsset<GameObject>("BFP_WoodenArmorStand");
			ShaderReplacer.Replace(_woodenArmorStand);
			_glassWindow1 = _finewoodBundle.LoadAsset<GameObject>("BFP_GlassWindow1");
			_glassWindow2 = _finewoodBundle.LoadAsset<GameObject>("BFP_GlassWindow3");
			_clayPit = _finewoodBundle.LoadAsset<GameObject>("BCP_ClayPit");
			ShaderReplacer.Replace(_clayPit);
			_clayPit2 = _finewoodBundle.LoadAsset<GameObject>("BCP_ClayPit1");
			ShaderReplacer.Replace(_clayPit2);
			_clayCollector = _finewoodBundle.LoadAsset<GameObject>("BCP_ClayCollector");
			if (!Object.op_Implicit((Object)(object)_clayCollector.GetComponent<ClayCollector>()))
			{
				_clayCollector.AddComponent<ClayCollector>();
			}
			ShaderReplacer.Replace(_clayCollector);
			_thatchWindow = _finewoodBundle.LoadAsset<GameObject>("BFP_ThatchWindow");
			ShaderReplacer.Replace(_thatchWindow);
			_thatchWindowHalf = _finewoodBundle.LoadAsset<GameObject>("BFP_ThatchWindow_Half");
			ShaderReplacer.Replace(_thatchWindowHalf);
			_thatchWindowQuarter = _finewoodBundle.LoadAsset<GameObject>("BFP_ThatchWindow_Quarter");
			ShaderReplacer.Replace(_thatchWindowQuarter);
			_trapDoor = _finewoodBundle.LoadAsset<GameObject>("BFP_TrapDoor");
			if (!Object.op_Implicit((Object)(object)_trapDoor.GetComponent<TrapDoor>()))
			{
				Object.Destroy((Object)(object)_trapDoor.GetComponent<Door>());
				_trapDoor.AddComponent<TrapDoor>();
			}
			ShaderReplacer.Replace(_trapDoor);
			_window = _finewoodBundle.LoadAsset<GameObject>("BFP_Window");
			ShaderReplacer.Replace(_window);
			_windowHalf = _finewoodBundle.LoadAsset<GameObject>("BFP_Window_Half");
			ShaderReplacer.Replace(_windowHalf);
			_windowQuarter = _finewoodBundle.LoadAsset<GameObject>("BFP_Window_Quarter");
			ShaderReplacer.Replace(_windowQuarter);
		}

		private static AssetBundle GetAssetBundleFromResources(string filename)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single((string x) => x.EndsWith(filename));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			return AssetBundle.LoadFromStream(stream);
		}
	}
	public static class RegisterPrefabsToObjectDB
	{
		private static ObjectDB _objectDB => ObjectDB.instance;

		public static void Init()
		{
			if (Helper.ObjectDBAwake())
			{
				_objectDB.AddGameObject(PrefabsSetup._fineHammer);
				_objectDB.AddGameObject(PrefabsSetup._straw);
				_objectDB.AddGameObject(PrefabsSetup._clay);
			}
		}
	}
	public static class RegisterPrefabsToZNetScene
	{
		private static ZNetScene _zNetScene => ZNetScene.instance;

		public static void Init()
		{
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Expected O, but got Unknown
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Expected O, but got Unknown
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0762: Unknown result type (might be due to invalid IL or missing references)
			//IL_0767: Unknown result type (might be due to invalid IL or missing references)
			//IL_07db: Unknown result type (might be due to invalid IL or missing references)
			//IL_082c: Expected O, but got Unknown
			//IL_0b2f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b5a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b60: Expected O, but got Unknown
			//IL_0b69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b84: Expected O, but got Unknown
			//IL_0b8f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dcb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dd0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e44: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e95: Expected O, but got Unknown
			//IL_0feb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ff0: Unknown result type (might be due to invalid IL or missing references)
			//IL_1064: Unknown result type (might be due to invalid IL or missing references)
			//IL_10b5: Expected O, but got Unknown
			//IL_1159: Unknown result type (might be due to invalid IL or missing references)
			//IL_115e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1173: Unknown result type (might be due to invalid IL or missing references)
			//IL_117a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1182: Expected O, but got Unknown
			//IL_1184: Unknown result type (might be due to invalid IL or missing references)
			//IL_1189: Unknown result type (might be due to invalid IL or missing references)
			//IL_119e: Unknown result type (might be due to invalid IL or missing references)
			//IL_11a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_11ad: Expected O, but got Unknown
			//IL_11d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_124e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1253: Unknown result type (might be due to invalid IL or missing references)
			//IL_1268: Unknown result type (might be due to invalid IL or missing references)
			//IL_126f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1277: Expected O, but got Unknown
			//IL_128a: Unknown result type (might be due to invalid IL or missing references)
			//IL_128f: Unknown result type (might be due to invalid IL or missing references)
			//IL_12a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_12ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_12b3: Expected O, but got Unknown
			if (Helper.ZNetSceneAwake())
			{
				_zNetScene.AddGameObject(PrefabsSetup._barrelClutter);
				_zNetScene.AddGameObject(PrefabsSetup._bronzeFrameChest);
				_zNetScene.AddGameObject(PrefabsSetup._fineHammer);
				_zNetScene.AddGameObject(PrefabsSetup._fineHammerRepair);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBasket);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBeam1x1);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBeam2x2);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBeam26);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBeam45);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBed1);
				_zNetScene.AddGameObject(PrefabsSetup._logChair);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodDecoWall);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodDoor);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodFloor1x1);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodFloor2x2);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodGate);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodHalfWall);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodLedge);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodPole1x1);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodPole2x2);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodQuaterWall);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRoof26);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRoof45);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRoofCross26);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRoofCross45);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRoofICorner26);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRoofICorner45);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRoofOCorner26);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRoofOCorner45);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRoofTop26);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRoofTop45);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodStair);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodStepLadder);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodStool);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodWall);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodWallRoof26);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodWallRoof26_UpsideDown);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodWallRoof45);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodWallRoof45_UpsideDown);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodWindowShutter);
				_zNetScene.AddGameObject(PrefabsSetup._longCrate);
				_zNetScene.AddGameObject(PrefabsSetup._pickableReed);
				_zNetScene.AddGameObject(PrefabsSetup._shelfClutter);
				_zNetScene.AddGameObject(PrefabsSetup._stoneLighPost);
				Fireplace component = PrefabsSetup._stoneLighPost.GetComponent<Fireplace>();
				component.m_fuelItem = _zNetScene.GetPrefab("Coal").GetComponent<ItemDrop>();
				FireworkItem[] array = new FireworkItem[1];
				FireworkItem val = new FireworkItem
				{
					m_fireworkItemCount = 1,
					m_fireworkItem = _zNetScene.GetPrefab("Resin").GetComponent<ItemDrop>()
				};
				EffectList val2 = new EffectList();
				val2.m_effectPrefabs = (EffectData[])(object)new EffectData[1]
				{
					new EffectData
					{
						m_prefab = _zNetScene.GetPrefab("vfx_Firework_Rocket")
					}
				};
				val.m_fireworksEffects = val2;
				array[0] = val;
				component.m_fireworkItemList = (FireworkItem[])(object)array;
				_zNetScene.AddGameObject(PrefabsSetup._stoneRoof26);
				_zNetScene.AddGameObject(PrefabsSetup._stoneRoof45);
				_zNetScene.AddGameObject(PrefabsSetup._stoneRoofICorner26);
				_zNetScene.AddGameObject(PrefabsSetup._stoneRoofICorner45);
				_zNetScene.AddGameObject(PrefabsSetup._stoneRoofOCorner26);
				_zNetScene.AddGameObject(PrefabsSetup._stoneRoofOCorner45);
				_zNetScene.AddGameObject(PrefabsSetup._stoneRoofTop26);
				_zNetScene.AddGameObject(PrefabsSetup._stoneRoofTop45);
				_zNetScene.AddGameObject(PrefabsSetup._straw);
				_zNetScene.AddGameObject(PrefabsSetup._thatchWall);
				_zNetScene.AddGameObject(PrefabsSetup._thatchQuaterWall);
				_zNetScene.AddGameObject(PrefabsSetup._thatchWall);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBed2);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBench1);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBench2);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBench3);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBench4);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBench5);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBench6);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBench7);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodCabinet1);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodCabinet2);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodCabinet3);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodCabinet4);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodCabinet5);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodCabinet6);
				_zNetScene.AddGameObject(PrefabsSetup._horizontalDecoWall);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodChair1);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodChair2);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodChair3);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodChair4);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodChair5);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodCrib);
				_zNetScene.AddGameObject(PrefabsSetup._deskDrawer1);
				_zNetScene.AddGameObject(PrefabsSetup._deskDrawer2);
				_zNetScene.AddGameObject(PrefabsSetup._deskDrawer3);
				_zNetScene.AddGameObject(PrefabsSetup._deskDrawer4);
				_zNetScene.AddGameObject(PrefabsSetup._deskDrawer5);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodTable1);
				_zNetScene.AddGameObject(PrefabsSetup._miniStool1);
				_zNetScene.AddGameObject(PrefabsSetup._miniStool2);
				_zNetScene.AddGameObject(PrefabsSetup._miniTable1);
				_zNetScene.AddGameObject(PrefabsSetup._miniTable2);
				_zNetScene.AddGameObject(PrefabsSetup._miniTable3);
				_zNetScene.AddGameObject(PrefabsSetup._shelf1);
				_zNetScene.AddGameObject(PrefabsSetup._shelf2);
				_zNetScene.AddGameObject(PrefabsSetup._shelf3);
				_zNetScene.AddGameObject(PrefabsSetup._shelf4);
				_zNetScene.AddGameObject(PrefabsSetup._shelf5);
				_zNetScene.AddGameObject(PrefabsSetup._stool1);
				_zNetScene.AddGameObject(PrefabsSetup._stool2);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodChair6);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodTable2);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodTable3);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodTable4);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodTable5);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodTable6);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodTable7);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodTable8);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodTable9);
				_zNetScene.AddGameObject(PrefabsSetup._poolChair);
				_zNetScene.AddGameObject(PrefabsSetup._stepLadder);
				_zNetScene.AddGameObject(PrefabsSetup._armorStand);
				PrefabsSetup._armorStand.GetComponent<ArmorStand>().m_supports = new List<ArmorStandSupport>(1)
				{
					new ArmorStandSupport
					{
						m_items = new List<ItemDrop>(4)
						{
							_zNetScene.GetPrefab("ArmorBronzeChest").GetComponent<ItemDrop>(),
							_zNetScene.GetPrefab("ArmorIronChest").GetComponent<ItemDrop>(),
							_zNetScene.GetPrefab("ArmorCarapaceChest").GetComponent<ItemDrop>(),
							_zNetScene.GetPrefab("ArmorMageChest").GetComponent<ItemDrop>()
						},
						m_supports = new List<GameObject>(2)
						{
							((Component)Utils.FindChild(PrefabsSetup._armorStand.transform, "ArmLeft", (IterativeSearchType)0)).gameObject,
							((Component)Utils.FindChild(PrefabsSetup._armorStand.transform, "ArmRight", (IterativeSearchType)0)).gameObject
						}
					}
				};
				_zNetScene.AddGameObject(PrefabsSetup._stepLadder2);
				_zNetScene.AddGameObject(PrefabsSetup._plant1);
				_zNetScene.AddGameObject(PrefabsSetup._plant2);
				_zNetScene.AddGameObject(PrefabsSetup._plant3);
				_zNetScene.AddGameObject(PrefabsSetup._plant4);
				_zNetScene.AddGameObject(PrefabsSetup._plant5);
				_zNetScene.AddGameObject(PrefabsSetup._plant6);
				_zNetScene.AddGameObject(PrefabsSetup._plant7);
				_zNetScene.AddGameObject(PrefabsSetup._plant8);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBench8);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodBench9);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodCabinet7);
				_zNetScene.AddGameObject(PrefabsSetup._cupboard);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodChair7);
				_zNetScene.AddGameObject(PrefabsSetup._loxDoubleBed);
				_zNetScene.AddGameObject(PrefabsSetup._loxBed);
				_zNetScene.AddGameObject(PrefabsSetup._plant9);
				_zNetScene.AddGameObject(PrefabsSetup._plant10);
				_zNetScene.AddGameObject(PrefabsSetup._plant11);
				_zNetScene.AddGameObject(PrefabsSetup._plant12);
				_zNetScene.AddGameObject(PrefabsSetup._plant13);
				_zNetScene.AddGameObject(PrefabsSetup._candle);
				_zNetScene.AddGameObject(PrefabsSetup._clay);
				_zNetScene.AddGameObject(PrefabsSetup._clayArch);
				_zNetScene.AddGameObject(PrefabsSetup._clayBase1);
				_zNetScene.AddGameObject(PrefabsSetup._clayBase2);
				_zNetScene.AddGameObject(PrefabsSetup._clayBaseCorner);
				_zNetScene.AddGameObject(PrefabsSetup._clayBlock1x1);
				_zNetScene.AddGameObject(PrefabsSetup._clayBlock2x1x1);
				_zNetScene.AddGameObject(PrefabsSetup._clayBlock2x2_Enforced);
				_zNetScene.AddGameObject(PrefabsSetup._clayBlock2x2x1);
				_zNetScene.AddGameObject(PrefabsSetup._clayBlock2x2x2);
				_zNetScene.AddGameObject(PrefabsSetup._clayBlock_OutCorner);
				_zNetScene.AddGameObject(PrefabsSetup._clayBlock_SlopeInverted1x2);
				_zNetScene.AddGameObject(PrefabsSetup._clayBlockOut1);
				_zNetScene.AddGameObject(PrefabsSetup._clayBlockOut2);
				_zNetScene.AddGameObject(PrefabsSetup._clayBlockSlope1x2);
				_zNetScene.AddGameObject(PrefabsSetup._clayColumn1);
				_zNetScene.AddGameObject(PrefabsSetup._clayColumn2);
				_zNetScene.AddGameObject(PrefabsSetup._clayFloor);
				_zNetScene.AddGameObject(PrefabsSetup._clayFloorLarge);
				_zNetScene.AddGameObject(PrefabsSetup._clayFloorTriangle);
				_zNetScene.AddGameObject(PrefabsSetup._clayHead1);
				_zNetScene.AddGameObject(PrefabsSetup._clayHead2);
				_zNetScene.AddGameObject(PrefabsSetup._clayLightPost);
				Fireplace component2 = PrefabsSetup._clayLightPost.GetComponent<Fireplace>();
				component2.m_fuelItem = _zNetScene.GetPrefab("Coal").GetComponent<ItemDrop>();
				FireworkItem[] array2 = new FireworkItem[1];
				val = new FireworkItem
				{
					m_fireworkItemCount = 1,
					m_fireworkItem = _zNetScene.GetPrefab("Resin").GetComponent<ItemDrop>()
				};
				val2 = new EffectList();
				val2.m_effectPrefabs = (EffectData[])(object)new EffectData[1]
				{
					new EffectData
					{
						m_prefab = _zNetScene.GetPrefab("vfx_Firework_Rocket")
					}
				};
				val.m_fireworksEffects = val2;
				array2[0] = val;
				component2.m_fireworkItemList = (FireworkItem[])(object)array2;
				_zNetScene.AddGameObject(PrefabsSetup._clayRoof26);
				_zNetScene.AddGameObject(PrefabsSetup._clayRoof45);
				_zNetScene.AddGameObject(PrefabsSetup._clayRoofICorner26);
				_zNetScene.AddGameObject(PrefabsSetup._clayRoofICorner45);
				_zNetScene.AddGameObject(PrefabsSetup._clayRoofOCorner26);
				_zNetScene.AddGameObject(PrefabsSetup._clayRoofOCorner45);
				_zNetScene.AddGameObject(PrefabsSetup._clayRoofTop26);
				_zNetScene.AddGameObject(PrefabsSetup._clayRoofTop45);
				_zNetScene.AddGameObject(PrefabsSetup._clayStair);
				_zNetScene.AddGameObject(PrefabsSetup._clayTileFloor1x1);
				_zNetScene.AddGameObject(PrefabsSetup._clayTileFloor2x2);
				_zNetScene.AddGameObject(PrefabsSetup._clayTileWall1x1);
				_zNetScene.AddGameObject(PrefabsSetup._clayTileWall2x2);
				_zNetScene.AddGameObject(PrefabsSetup._clayTileWall2x4);
				_zNetScene.AddGameObject(PrefabsSetup._clayTip);
				_zNetScene.AddGameObject(PrefabsSetup._flowerStand1);
				_zNetScene.AddGameObject(PrefabsSetup._flowerStand2);
				_zNetScene.AddGameObject(PrefabsSetup._lantern1);
				_zNetScene.AddGameObject(PrefabsSetup._lantern2);
				_zNetScene.AddGameObject(PrefabsSetup._lantern3);
				_zNetScene.AddGameObject(PrefabsSetup._lantern4);
				_zNetScene.AddGameObject(PrefabsSetup._lantern5);
				_zNetScene.AddGameObject(PrefabsSetup._lantern6);
				_zNetScene.AddGameObject(PrefabsSetup._lantern7);
				_zNetScene.AddGameObject(PrefabsSetup._leatherBed);
				_zNetScene.AddGameObject(PrefabsSetup._pickableClay);
				_zNetScene.AddGameObject(PrefabsSetup._pickableClayBig);
				_zNetScene.AddGameObject(PrefabsSetup._plant14);
				_zNetScene.AddGameObject(PrefabsSetup._plant15);
				_zNetScene.AddGameObject(PrefabsSetup._plant16);
				_zNetScene.AddGameObject(PrefabsSetup._plant17);
				_zNetScene.AddGameObject(PrefabsSetup._plant18);
				_zNetScene.AddGameObject(PrefabsSetup._clayArch2);
				_zNetScene.AddGameObject(PrefabsSetup._clayArmorStand);
				PrefabsSetup._clayArmorStand.GetComponent<ArmorStand>().m_supports = new List<ArmorStandSupport>(1)
				{
					new ArmorStandSupport
					{
						m_items = new List<ItemDrop>(4)
						{
							_zNetScene.GetPrefab("ArmorBronzeChest").GetComponent<ItemDrop>(),
							_zNetScene.GetPrefab("ArmorIronChest").GetComponent<ItemDrop>(),
							_zNetScene.GetPrefab("ArmorCarapaceChest").GetComponent<ItemDrop>(),
							_zNetScene.GetPrefab("ArmorMageChest").GetComponent<ItemDrop>()
						},
						m_supports = new List<GameObject>(2)
						{
							((Component)Utils.FindChild(PrefabsSetup._clayArmorStand.transform, "ArmLeft", (IterativeSearchType)0)).gameObject,
							((Component)Utils.FindChild(PrefabsSetup._clayArmorStand.transform, "ArmRight", (IterativeSearchType)0)).gameObject
						}
					}
				};
				_zNetScene.AddGameObject(PrefabsSetup._clayChest);
				_zNetScene.AddGameObject(PrefabsSetup._clayCorgi);
				_zNetScene.AddGameObject(PrefabsSetup._clayDeer);
				_zNetScene.AddGameObject(PrefabsSetup._clayHare);
				_zNetScene.AddGameObject(PrefabsSetup._clayPillar);
				_zNetScene.AddGameObject(PrefabsSetup._fenceGate);
				_zNetScene.AddGameObject(PrefabsSetup._fencePillar1);
				_zNetScene.AddGameObject(PrefabsSetup._fencePillar2);
				_zNetScene.AddGameObject(PrefabsSetup._fencePillar3);
				_zNetScene.AddGameObject(PrefabsSetup._fencePillar4);
				_zNetScene.AddGameObject(PrefabsSetup._fenceTile1);
				_zNetScene.AddGameObject(PrefabsSetup._fenceTile2);
				_zNetScene.AddGameObject(PrefabsSetup._fenceTile3);
				_zNetScene.AddGameObject(PrefabsSetup._fenceTile4);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodArch);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodDragon);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodRaven);
				_zNetScene.AddGameObject(PrefabsSetup._finewoodWolf);
				_zNetScene.AddGameObject(PrefabsSetup._heavyGate);
				_zNetScene.AddGameObject(PrefabsSetup._woodenArmorStand);
				PrefabsSetup._woodenArmorStand.GetComponent<ArmorStand>().m_supports = new List<ArmorStandSupport>(1)
				{
					new ArmorStandSupport
					{
						m_items = new List<ItemDrop>(4)
						{
							_zNetScene.GetPrefab("ArmorBronzeChest").GetComponent<ItemDrop>(),
							_zNetScene.GetPrefab("ArmorIronChest").GetComponent<ItemDrop>(),
							_zNetScene.GetPrefab("ArmorCarapaceChest").GetComponent<ItemDrop>(),
							_zNetScene.GetPrefab("ArmorMageChest").GetComponent<ItemDrop>()
						},
						m_supports = new List<GameObject>(2)
						{
							((Component)Utils.FindChild(PrefabsSetup._woodenArmorStand.transform, "ArmLeft", (IterativeSearchType)0)).gameObject,
							((Component)Utils.FindChild(PrefabsSetup._woodenArmorStand.transform, "ArmRight", (IterativeSearchType)0)).gameObject
						}
					}
				};
				_zNetScene.AddGameObject(PrefabsSetup._glassWindow1);
				_zNetScene.AddGameObject(PrefabsSetup._glassWindow2);
				_zNetScene.AddGameObject(PrefabsSetup._clayCollector);
				ClayCollector component3 = PrefabsSetup._clayCollector.GetComponent<ClayCollector>();
				component3.m_name = "$bcp_claycollector";
				component3.m_spawnPoint = Utils.FindChild(PrefabsSetup._clayCollector.transform, "spawnpoint", (IterativeSearchType)0);
				component3.m_secPerUnit = Plugin._secPerUnit.Value;
				component3.m_maxClay = Plugin._maxClay.Value;
				component3.m_clayItem = PrefabsSetup._clay.GetComponent<ItemDrop>();
				component3.m_spawnEffect.m_effectPrefabs = (EffectData[])(object)new EffectData[2]
				{
					new EffectData
					{
						m_prefab = _zNetScene.GetPrefab("sfx_pickable_pick"),
						m_enabled = true,
						m_variant = -1
					},
					new EffectData
					{
						m_prefab = _zNetScene.GetPrefab("vfx_pickable_pick"),
						m_enabled = true,
						m_variant = -1
					}
				};
				component3.m_enabledObject = ((Component)Utils.FindChild(PrefabsSetup._clayCollector.transform, "_enabled", (IterativeSearchType)0)).gameObject;
				component3.m_biome = (Biome)1;
				_zNetScene.AddGameObject(PrefabsSetup._thatchWindow);
				_zNetScene.AddGameObject(PrefabsSetup._thatchWindowHalf);
				_zNetScene.AddGameObject(PrefabsSetup._thatchWindowQuarter);
				_zNetScene.AddGameObject(PrefabsSetup._trapDoor);
				TrapDoor component4 = PrefabsSetup._trapDoor.GetComponent<TrapDoor>();
				component4.m_name = PrefabsSetup._trapDoor.GetComponent<Piece>().m_name;
				component4.m_checkGuardStone = true;
				component4.m_openEffects.m_effectPrefabs = (EffectData[])(object)new EffectData[1]
				{
					new EffectData
					{
						m_prefab = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_door_open"),
						m_enabled = true,
						m_variant = -1
					}
				};
				component4.m_closeEffects.m_effectPrefabs = (EffectData[])(object)new EffectData[1]
				{
					new EffectData
					{
						m_prefab = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_door_close"),
						m_enabled = true,
						m_variant = -1
					}
				};
				_zNetScene.AddGameObject(PrefabsSetup._window);
				_zNetScene.AddGameObject(PrefabsSetup._windowHalf);
				_zNetScene.AddGameObject(PrefabsSetup._windowQuarter);
			}
		}

		public static void Effects()
		{
			if (Helper.ZNetSceneAwake())
			{
				GameObject gameObject = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_fx_ArmorStand_pick");
				_zNetScene.AddGameObject(gameObject);
				GameObject gameObject2 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_barley_hit");
				_zNetScene.AddGameObject(gameObject2);
				GameObject gameObject3 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_build_hammer_default");
				_zNetScene.AddGameObject(gameObject3);
				GameObject gameObject4 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_build_hammer_stone");
				_zNetScene.AddGameObject(gameObject4);
				GameObject gameObject5 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_build_hammer_wood");
				_zNetScene.AddGameObject(gameObject5);
				GameObject gameObject6 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_chest_close");
				_zNetScene.AddGameObject(gameObject6);
				GameObject gameObject7 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_chest_open");
				_zNetScene.AddGameObject(gameObject7);
				GameObject gameObject8 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_door_close");
				_zNetScene.AddGameObject(gameObject8);
				GameObject gameObject9 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_door_open");
				_zNetScene.AddGameObject(gameObject9);
				GameObject gameObject10 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_FireAddFuel");
				_zNetScene.AddGameObject(gameObject10);
				GameObject gameObject11 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_pickable_pick");
				_zNetScene.AddGameObject(gameObject11);
				GameObject gameObject12 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_rock_destroyed");
				_zNetScene.AddGameObject(gameObject12);
				GameObject gameObject13 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_rock_hit");
				_zNetScene.AddGameObject(gameObject13);
				GameObject gameObject14 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_window_open");
				_zNetScene.AddGameObject(gameObject14);
				GameObject gameObject15 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_windows_close");
				_zNetScene.AddGameObject(gameObject15);
				GameObject gameObject16 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_sfx_wood_destroyed");
				_zNetScene.AddGameObject(gameObject16);
				GameObject gameObject17 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_barley_destroyed");
				_zNetScene.AddGameObject(gameObject17);
				GameObject gameObject18 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_dvergpost_destroyed");
				_zNetScene.AddGameObject(gameObject18);
				GameObject gameObject19 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_FireAddFuel");
				_zNetScene.AddGameObject(gameObject19);
				GameObject gameObject20 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_MarbleDestroyed");
				_zNetScene.AddGameObject(gameObject20);
				GameObject gameObject21 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_MarbleHit");
				_zNetScene.AddGameObject(gameObject21);
				GameObject gameObject22 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_pickable_pick");
				_zNetScene.AddGameObject(gameObject22);
				GameObject gameObject23 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_Place_bed");
				_zNetScene.AddGameObject(gameObject23);
				GameObject gameObject24 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_Place_chest");
				_zNetScene.AddGameObject(gameObject24);
				GameObject gameObject25 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_Place_stone_floor");
				_zNetScene.AddGameObject(gameObject25);
				GameObject gameObject26 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_Place_stone_wall_2x1");
				_zNetScene.AddGameObject(gameObject26);
				GameObject gameObject27 = PrefabsSetup._finewoodBundle.LoadAsset<GameObject>("bfp_vfx_Place_wood_beam");
				_zNetScene.AddGameObject(gameObject27);
				GameObjec