Decompiled source of balrond bundling machine v1.0.1

plugins/BalrondPackager.dll

Decompiled a month ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using HarmonyLib;
using LitJson2;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("BalrondPackager")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BalrondPackager")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("cde312a0-cf19-4264-8616-e1c74774beed")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
public class BalrondUnpackager : MonoBehaviour, Hoverable, Interactable
{
	public string m_name = "Unpacking Station";

	public string m_useItemText = "Use";

	public ItemDrop m_requiredItem;

	public Transform m_itemSpawnPoint;

	public float m_SpawnDelay = 2f;

	[Header("Effects")]
	public EffectList m_spawnStartEffects = new EffectList();

	public EffectList m_spawnFinishEffects = new EffectList();

	public Transform m_roofCheckPoint;

	public bool m_requiresRoof = false;

	private ZNetView m_nview;

	private void Awake()
	{
		m_nview = ((Component)this).GetComponent<ZNetView>();
		if ((Object)(object)m_nview == (Object)null || m_nview.GetZDO() == null)
		{
			ZLog.Log((object)"Missing ZnetView Component");
		}
		else if ((Object)(object)m_requiredItem == (Object)null)
		{
			m_requiredItem = ZNetScene.instance.m_prefabs.Find((GameObject x) => ((Object)x).name == "CustomPackageItem_bal").GetComponent<ItemDrop>();
		}
	}

	public string GetHoverText()
	{
		//IL_0007: 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$piece_noaccess");
		}
		return Localization.instance.Localize(m_name + "\n[<color=yellow><b>1-8</b></color>] \n" + m_useItemText) + " " + Localization.instance.Localize(((Component)m_requiredItem).GetComponent<ItemDrop>().m_itemData.m_shared.m_name);
	}

	public string GetHoverName()
	{
		return m_name;
	}

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

	public bool UseItem(Humanoid user, ItemData item)
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)user != (Object)(object)Player.m_localPlayer)
		{
			return true;
		}
		if (!PrivateArea.CheckAccess(((Component)this).transform.position, 0f, true, false))
		{
			return true;
		}
		if (!((Object)item.m_dropPrefab).name.Contains(((Object)m_requiredItem).name))
		{
			((Character)user).Message((MessageType)2, "Can't unpack this", 0, (Sprite)null);
			return true;
		}
		if (Object.op_Implicit((Object)(object)m_itemSpawnPoint))
		{
			m_spawnStartEffects.Create(m_itemSpawnPoint.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
			spawnItems(item);
		}
		((Character)user).ShowRemovedMessage(item, 1);
		user.GetInventory().RemoveItem(item);
		((Character)user).Message((MessageType)2, "Unpacked", 0, (Sprite)null);
		return true;
	}

	public bool CheckUsable(Player player, bool showMessage)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		if (m_requiresRoof && !player.NoCostCheat())
		{
			float num = default(float);
			bool flag = default(bool);
			Cover.GetCoverForPoint(m_roofCheckPoint.position, ref num, ref flag, 0.5f);
			if (!flag)
			{
				if (showMessage)
				{
					((Character)player).Message((MessageType)2, "$msg_stationneedroof", 0, (Sprite)null);
				}
				return false;
			}
			if ((double)num < 0.699999988079071)
			{
				if (showMessage)
				{
					((Character)player).Message((MessageType)2, "$msg_stationtooexposed", 0, (Sprite)null);
				}
				return false;
			}
		}
		return true;
	}

	private Vector3 GetSpawnPosition()
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		return ((Object)(object)m_itemSpawnPoint != (Object)null) ? m_itemSpawnPoint.position : ((Component)this).transform.position;
	}

	private void spawnItems(ItemData itemData)
	{
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		string value = "";
		itemData.m_customData.TryGetValue("BalrondPackageAmount", out value);
		if (value == null || !(value != ""))
		{
			return;
		}
		int num = int.Parse(value);
		for (int i = 0; i < num; i++)
		{
			string value2 = "";
			itemData.m_customData.TryGetValue("BalrondPackageIndex-" + i, out value2);
			if (value2 != null && value2 != "")
			{
				string[] array = value2.Split(new char[1] { '.' });
				string itemName = array[0];
				int stack = int.Parse(array[1]);
				GameObject val = ObjectDB.instance.m_items.Find((GameObject x) => ((Object)x).name == itemName);
				Object.Instantiate<ItemDrop>(val.GetComponent<ItemDrop>(), GetSpawnPosition(), Quaternion.identity).m_itemData.m_stack = stack;
			}
		}
	}
}
namespace BalrondPackager
{
	public class BalrondTranslator
	{
		public static Dictionary<string, Dictionary<string, string>> translations = new Dictionary<string, Dictionary<string, string>>();

		public static Dictionary<string, string> getLanguage(string language)
		{
			Dictionary<string, string> result = null;
			try
			{
				result = translations[language];
			}
			catch (Exception)
			{
			}
			return result;
		}
	}
	public class BalrondPackager : MonoBehaviour
	{
		public enum Response
		{
			Fail,
			Success,
			Conversion,
			Empty
		}

		public Switch m_incinerateSwitch;

		public Container m_container;

		public Animator m_leverAnim;

		public EffectList m_leverEffects = new EffectList();

		public float m_effectDelayMin = 10f;

		public float m_effectDelayMax = 15f;

		[Header("Conversion")]
		public ItemDrop m_defaultResult;

		public int m_defaultCost = 1;

		private ZNetView m_nview;

		private bool isInUse;

		public Transform output;

		public GameObject m_enabled;

		public EffectList m_produceEffects = new EffectList();

		private void Awake()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			Switch incinerateSwitch = m_incinerateSwitch;
			incinerateSwitch.m_onUse = (Callback)Delegate.Combine((Delegate?)(object)incinerateSwitch.m_onUse, (Delegate?)new Callback(OnIncinerate));
			Switch incinerateSwitch2 = m_incinerateSwitch;
			incinerateSwitch2.m_onHover = (TooltipCallback)Delegate.Combine((Delegate?)(object)incinerateSwitch2.m_onHover, (Delegate?)new TooltipCallback(GetLeverHoverText));
			m_nview = ((Component)this).GetComponent<ZNetView>();
			if (!((Object)(object)m_nview == (Object)null) && m_nview.GetZDO() != null)
			{
				m_nview.Register<long>("RPC_RequestPackage", (Action<long, long>)RPC_RequestPackage);
				m_nview.Register<int>("RPC_PackageRespons", (Action<long, int>)RPC_PackageRespons);
				m_nview.Register("RPC_AnimateLever", (Action<long>)RPC_AnimateLever);
				m_nview.Register("RPC_AnimateLeverReturn", (Action<long>)RPC_AnimateLeverReturn);
				m_enabled.SetActive(false);
			}
		}

		private void StopAOE()
		{
			isInUse = false;
		}

		public string GetLeverHoverText()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return (!PrivateArea.CheckAccess(((Component)this).transform.position, 0f, true, false)) ? Localization.instance.Localize("$piece_packager\n$piece_noaccess") : Localization.instance.Localize("[<color=yellow><b>$KEY_Use</b></color>] $piece_pulllever");
		}

		private bool OnIncinerate(Switch sw, Humanoid user, ItemData item)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!m_nview.IsValid() || !m_nview.HasOwner() || !PrivateArea.CheckAccess(((Component)this).transform.position, 0f, true, false))
			{
				return false;
			}
			m_nview.InvokeRPC("RPC_RequestPackage", new object[1] { Game.instance.GetPlayerProfile().GetPlayerID() });
			return true;
		}

		private void RPC_RequestPackage(long uid, long playerID)
		{
			ZLog.Log((object)("Player " + uid + " wants to package " + ((Object)((Component)this).gameObject).name + "   im: " + ZDOMan.GetSessionID()));
			if (!m_nview.IsOwner())
			{
				ZLog.Log((object)"  but im not the owner");
			}
			else if (m_container.IsInUse() || isInUse)
			{
				m_nview.InvokeRPC(uid, "RPC_PackageRespons", new object[1] { 0 });
				ZLog.Log((object)"  but it's in use");
			}
			else if (m_container.GetInventory().NrOfItems() == 0)
			{
				m_nview.InvokeRPC(uid, "RPC_IncinerateRespons", new object[1] { 3 });
				ZLog.Log((object)"  but it's empty");
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(Package(uid));
			}
		}

		private IEnumerator Package(long uid)
		{
			BalrondPackager packager = this;
			packager.isInUse = true;
			packager.m_nview.InvokeRPC(ZNetView.Everybody, "RPC_AnimateLever", Array.Empty<object>());
			packager.m_leverEffects.Create(((Component)packager).transform.position, ((Component)packager).transform.rotation, (Transform)null, 1f, -1);
			packager.m_enabled.SetActive(true);
			yield return (object)new WaitForSeconds(Random.Range(packager.m_effectDelayMin, packager.m_effectDelayMax));
			packager.m_nview.InvokeRPC(ZNetView.Everybody, "RPC_AnimateLeverReturn", Array.Empty<object>());
			packager.m_enabled.SetActive(false);
			if (!packager.m_nview.IsValid() || !packager.m_nview.IsOwner() || packager.m_container.IsInUse())
			{
				packager.isInUse = false;
				yield break;
			}
			((MonoBehaviour)packager).Invoke("StopAOE", 4f);
			Inventory inventory = packager.m_container.GetInventory();
			List<ItemData> items = inventory.GetAllItems();
			int num1 = ((items.Count != 0) ? 1 : 3);
			string description = "Contains: \n";
			ItemData wrongItem = null;
			ItemDrop package = Object.Instantiate<ItemDrop>(packager.m_defaultResult, packager.output.position, packager.output.rotation);
			m_produceEffects.Create(packager.output.position, packager.output.rotation, (Transform)null, 1f, -1);
			package.m_itemData.m_customData.Add("BalrondPackageAmount", items.Count.ToString());
			bool teleportable = true;
			int counter = 0;
			float weightCounter = 0f;
			foreach (ItemData item in items)
			{
				if (!validateItemType(item.m_shared.m_itemType) || ((Object)item.m_dropPrefab).name.Contains("CustomPackageItem_bal"))
				{
					num1 = 99;
					wrongItem = item;
					break;
				}
				string line = item.m_shared.m_name + " x" + item.m_stack + "\n";
				float weight = item.m_shared.m_weight * (float)item.m_stack;
				weightCounter += weight;
				description += line;
				package.m_itemData.m_customData.Add("BalrondPackageIndex-" + counter, ((Object)item.m_dropPrefab).name + "." + item.m_stack);
				if (!item.m_shared.m_teleportable)
				{
					teleportable = false;
				}
				counter++;
			}
			if (num1 == 1)
			{
				float finalWeight = weightCounter / 2f;
				package.m_itemData.m_customData.Add("BalrondPackageDescription", description);
				package.m_itemData.m_customData.Add("BalrondPackageWeight", finalWeight.ToString());
				package.m_itemData.m_customData.Add("BalrondPackageTeleportable", (teleportable ? 1 : 0).ToString());
				package.m_itemData.m_shared.m_description = description;
				package.m_itemData.m_shared.m_teleportable = teleportable;
				package.m_itemData.m_shared.m_weight = finalWeight;
				package.Save();
				string amountTest = "";
				package.m_itemData.m_customData.TryGetValue("BalrondPackageAmount", out amountTest);
				Debug.Log((object)("Bundle Amount: " + amountTest));
				string weightTest = "";
				package.m_itemData.m_customData.TryGetValue("BalrondPackageWeight", out weightTest);
				Debug.Log((object)("Bundle Weight: " + weightTest));
				string teleportableTest = "";
				package.m_itemData.m_customData.TryGetValue("BalrondPackageTeleportable", out teleportableTest);
				Debug.Log((object)("Bundle Teleportable: " + teleportableTest));
				string descTest = "";
				package.m_itemData.m_customData.TryGetValue("BalrondPackageDescription", out descTest);
				Debug.Log((object)("Bundle Desc: " + descTest));
				inventory.RemoveAll();
			}
			else
			{
				Object.DestroyImmediate((Object)(object)((Component)package).gameObject);
				Debug.Log((object)("Cant make bundle - wrong item: " + ((Object)wrongItem.m_dropPrefab).name));
			}
			packager.m_nview.InvokeRPC(uid, "RPC_PackageRespons", new object[1] { num1 });
		}

		private bool validateItemType(ItemType itemType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			return (int)itemType == 1 || (int)itemType == 2 || (int)itemType == 9 || (int)itemType == 16 || (int)itemType == 13;
		}

		private void RPC_PackageRespons(long uid, int r)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, r switch
				{
					1 => "$piece_packager_success", 
					2 => "$piece_packager_conversion", 
					3 => "$piece_packager_empty", 
					_ => "$piece_packager_fail", 
				}, 0, (Sprite)null);
			}
		}

		private void RPC_AnimateLever(long uid)
		{
			ZLog.Log((object)"DO THE THING WITH THE LEVER!");
			m_leverAnim.SetBool("Pulled", true);
		}

		private void RPC_AnimateLeverReturn(long uid)
		{
			ZLog.Log((object)"Lever return");
			m_leverAnim.SetBool("Pulled", false);
		}
	}
	public class DatabaseAddMethods
	{
		public void AddItems(List<GameObject> items)
		{
			foreach (GameObject item in items)
			{
				AddItem(item);
			}
		}

		public void AddRecipes(List<Recipe> recipes)
		{
			foreach (Recipe recipe in recipes)
			{
				AddRecipe(recipe);
			}
		}

		public void AddStatuseffects(List<StatusEffect> statusEffects)
		{
			foreach (StatusEffect statusEffect in statusEffects)
			{
				AddStatus(statusEffect);
			}
		}

		private bool IsObjectDBValid()
		{
			return (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items.Count != 0 && ObjectDB.instance.m_recipes.Count != 0 && (Object)(object)ObjectDB.instance.GetItemPrefab("Amber") != (Object)null;
		}

		private void AddStatus(StatusEffect status)
		{
			if (!IsObjectDBValid())
			{
				return;
			}
			if ((Object)(object)status != (Object)null)
			{
				if ((Object)(object)ObjectDB.instance.GetStatusEffect(status.m_nameHash) == (Object)null)
				{
					ObjectDB.instance.m_StatusEffects.Add(status);
				}
				else
				{
					Debug.Log((object)(Launch.projectName + ":  " + ((Object)status).name + " - Status already in the game"));
				}
			}
			else
			{
				Debug.LogError((object)(Launch.projectName + ":  " + ((Object)status).name + " - Status not found"));
			}
		}

		private void AddRecipe(Recipe recipe)
		{
			if (!IsObjectDBValid())
			{
				return;
			}
			if ((Object)(object)recipe != (Object)null)
			{
				if ((Object)(object)ObjectDB.instance.m_recipes.Find((Recipe x) => ((Object)x).name == ((Object)recipe).name) == (Object)null)
				{
					if ((Object)(object)recipe.m_item != (Object)null)
					{
						ObjectDB.instance.m_recipes.Add(recipe);
					}
				}
				else
				{
					Debug.Log((object)(Launch.projectName + ":  " + ((Object)recipe).name + " - Recipe with this name already in the Game"));
				}
			}
			else
			{
				Debug.LogError((object)(Launch.projectName + ":  " + ((Object)recipe).name + " - Recipe not found"));
			}
		}

		private void AddItem(GameObject newPrefab)
		{
			if (!IsObjectDBValid())
			{
				return;
			}
			ItemDrop component = newPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component != (Object)null)
			{
				if ((Object)(object)ObjectDB.instance.GetItemPrefab(((Object)newPrefab).name) == (Object)null)
				{
					ObjectDB.instance.m_items.Add(newPrefab);
					Dictionary<int, GameObject> dictionary = (Dictionary<int, GameObject>)typeof(ObjectDB).GetField("m_itemByHash", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(ObjectDB.instance);
					dictionary[((Object)newPrefab).name.GetHashCode()] = newPrefab;
				}
				else
				{
					Debug.Log((object)(Launch.projectName + ": " + ((Object)newPrefab).name + " - ItemDrop already exist"));
				}
			}
			else
			{
				Debug.LogError((object)(Launch.projectName + ": " + ((Object)newPrefab).name + " - ItemDrop not found on prefab"));
			}
		}
	}
	public class FxReplacment
	{
		public void ReplaceOnObject(GameObject gameObject, ZNetScene zNetScene)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			SpawnArea component = gameObject.GetComponent<SpawnArea>();
			if ((Object)(object)component != (Object)null)
			{
				EffectList spawnEffects = component.m_spawnEffects;
				if (spawnEffects != null)
				{
					findEffectsAndChange(spawnEffects.m_effectPrefabs, zNetScene);
				}
			}
			Destructible component2 = gameObject.GetComponent<Destructible>();
			if ((Object)(object)component2 != (Object)null)
			{
				EffectList hitEffect = component2.m_hitEffect;
				if (hitEffect != null)
				{
					findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
				}
				EffectList destroyedEffect = component2.m_destroyedEffect;
				if (destroyedEffect != null)
				{
					findEffectsAndChange(destroyedEffect.m_effectPrefabs, zNetScene);
				}
			}
			Projectile component3 = gameObject.GetComponent<Projectile>();
			if ((Object)(object)component3 != (Object)null)
			{
				EffectList hitEffects = component3.m_hitEffects;
				if (hitEffects != null)
				{
					findEffectsAndChange(hitEffects.m_effectPrefabs, zNetScene);
				}
				EffectList hitWaterEffects = component3.m_hitWaterEffects;
				if (hitWaterEffects != null)
				{
					findEffectsAndChange(hitWaterEffects.m_effectPrefabs, zNetScene);
				}
				EffectList spawnOnHitEffects = component3.m_spawnOnHitEffects;
				if (spawnOnHitEffects != null)
				{
					findEffectsAndChange(spawnOnHitEffects.m_effectPrefabs, zNetScene);
				}
			}
		}

		public void ReplaceOnVegetation(GameObject gameObject, ZNetScene zNetScene)
		{
			Pickable component = gameObject.GetComponent<Pickable>();
			if ((Object)(object)component != (Object)null)
			{
				fixPlant(component, zNetScene);
			}
			Destructible component2 = gameObject.GetComponent<Destructible>();
			if ((Object)(object)component2 != (Object)null)
			{
				fixPDestructable(component2, zNetScene);
			}
			MineRock5 component3 = gameObject.GetComponent<MineRock5>();
			if ((Object)(object)component3 != (Object)null)
			{
				fixMineRock5(component3, zNetScene);
			}
			MineRock component4 = gameObject.GetComponent<MineRock>();
			if ((Object)(object)component4 != (Object)null)
			{
				fixMineRock(component4, zNetScene);
			}
		}

		private void fixPlant(Pickable pickable, ZNetScene zNetScene)
		{
			EffectList pickEffector = pickable.m_pickEffector;
			if (pickEffector != null)
			{
				findEffectsAndChange(pickEffector.m_effectPrefabs, zNetScene);
			}
		}

		private void fixPDestructable(Destructible minerock5, ZNetScene zNetScene)
		{
			EffectList hitEffect = minerock5.m_hitEffect;
			if (hitEffect != null)
			{
				findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
			}
			EffectList destroyedEffect = minerock5.m_destroyedEffect;
			if (destroyedEffect != null)
			{
				findEffectsAndChange(destroyedEffect.m_effectPrefabs, zNetScene);
			}
		}

		private void fixMineRock5(MineRock5 minerock5, ZNetScene zNetScene)
		{
			EffectList hitEffect = minerock5.m_hitEffect;
			if (hitEffect != null)
			{
				findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
			}
			EffectList destroyedEffect = minerock5.m_destroyedEffect;
			if (destroyedEffect != null)
			{
				findEffectsAndChange(destroyedEffect.m_effectPrefabs, zNetScene);
			}
		}

		private void fixMineRock(MineRock minerock5, ZNetScene zNetScene)
		{
			EffectList hitEffect = minerock5.m_hitEffect;
			if (hitEffect != null)
			{
				findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
			}
			EffectList destroyedEffect = minerock5.m_destroyedEffect;
			if (destroyedEffect != null)
			{
				findEffectsAndChange(destroyedEffect.m_effectPrefabs, zNetScene);
			}
		}

		public void ReplaceOnMonster(GameObject gameObject, ZNetScene zNetScene)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				Debug.LogWarning((object)(Launch.projectName + ":: GameObject not found"));
				return;
			}
			Humanoid component = gameObject.GetComponent<Humanoid>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)(Launch.projectName + ":: GameObject not found"));
				return;
			}
			EffectList dropEffects = component.m_dropEffects;
			if (dropEffects != null)
			{
				findEffectsAndChange(dropEffects.m_effectPrefabs, zNetScene);
			}
			EffectList backstabHitEffects = ((Character)component).m_backstabHitEffects;
			if (backstabHitEffects != null)
			{
				findEffectsAndChange(backstabHitEffects.m_effectPrefabs, zNetScene);
			}
			EffectList consumeItemEffects = component.m_consumeItemEffects;
			if (consumeItemEffects != null)
			{
				findEffectsAndChange(consumeItemEffects.m_effectPrefabs, zNetScene);
			}
			EffectList critHitEffects = ((Character)component).m_critHitEffects;
			if (critHitEffects != null)
			{
				findEffectsAndChange(critHitEffects.m_effectPrefabs, zNetScene);
			}
			EffectList deathEffects = ((Character)component).m_deathEffects;
			if (deathEffects != null)
			{
				findEffectsAndChange(deathEffects.m_effectPrefabs, zNetScene);
			}
			EffectList hitEffects = ((Character)component).m_hitEffects;
			if (hitEffects != null)
			{
				findEffectsAndChange(hitEffects.m_effectPrefabs, zNetScene);
			}
			EffectList jumpEffects = ((Character)component).m_jumpEffects;
			if (jumpEffects != null)
			{
				findEffectsAndChange(jumpEffects.m_effectPrefabs, zNetScene);
			}
			EffectList perfectBlockEffect = component.m_perfectBlockEffect;
			if (perfectBlockEffect != null)
			{
				findEffectsAndChange(perfectBlockEffect.m_effectPrefabs, zNetScene);
			}
			EffectList pickupEffects = component.m_pickupEffects;
			if (pickupEffects != null)
			{
				findEffectsAndChange(pickupEffects.m_effectPrefabs, zNetScene);
			}
			EffectList slideEffects = ((Character)component).m_slideEffects;
			if (slideEffects != null)
			{
				findEffectsAndChange(slideEffects.m_effectPrefabs, zNetScene);
			}
			EffectList tarEffects = ((Character)component).m_tarEffects;
			if (tarEffects != null)
			{
				findEffectsAndChange(tarEffects.m_effectPrefabs, zNetScene);
			}
			EffectList waterEffects = ((Character)component).m_waterEffects;
			if (waterEffects != null)
			{
				findEffectsAndChange(waterEffects.m_effectPrefabs, zNetScene);
			}
			FootStep component2 = gameObject.GetComponent<FootStep>();
			if (!((Object)(object)component2 != (Object)null))
			{
				return;
			}
			List<StepEffect> effects = component2.m_effects;
			foreach (StepEffect item in effects)
			{
				GameObject[] effectPrefabs = item.m_effectPrefabs;
				List<GameObject> list = new List<GameObject>();
				list.AddRange(effectPrefabs);
				for (int i = 0; i < list.Count; i++)
				{
					if ((Object)(object)list[i] != (Object)null)
					{
						string name = ((Object)list[i]).name;
						GameObject val = ZNetScene.instance.m_prefabs.Find((GameObject x) => ((Object)x).name == name);
						if (!((Object)(object)val == (Object)null))
						{
							list[i] = val;
						}
					}
				}
			}
		}

		public void ReplaceOnItem(GameObject gameObject, ZNetScene zNetScene)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			if (!((Object)(object)component == (Object)null))
			{
				EffectList hitEffect = component.m_itemData.m_shared.m_hitEffect;
				if (hitEffect != null)
				{
					findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
				}
				EffectList hitTerrainEffect = component.m_itemData.m_shared.m_hitTerrainEffect;
				if (hitTerrainEffect != null)
				{
					findEffectsAndChange(hitTerrainEffect.m_effectPrefabs, zNetScene);
				}
				EffectList holdStartEffect = component.m_itemData.m_shared.m_holdStartEffect;
				if (holdStartEffect != null)
				{
					findEffectsAndChange(holdStartEffect.m_effectPrefabs, zNetScene);
				}
				EffectList trailStartEffect = component.m_itemData.m_shared.m_trailStartEffect;
				if (trailStartEffect != null)
				{
					findEffectsAndChange(trailStartEffect.m_effectPrefabs, zNetScene);
				}
				EffectList blockEffect = component.m_itemData.m_shared.m_blockEffect;
				if (blockEffect != null)
				{
					findEffectsAndChange(blockEffect.m_effectPrefabs, zNetScene);
				}
			}
		}

		public void ReplaceFxOnPiece(GameObject gameObject, ZNetScene zNetScene)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			Piece component = gameObject.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null)
			{
				EffectList placeEffect = component.m_placeEffect;
				if (placeEffect != null)
				{
					findEffectsAndChange(placeEffect.m_effectPrefabs, zNetScene);
				}
			}
			WearNTear component2 = gameObject.GetComponent<WearNTear>();
			if ((Object)(object)component2 != (Object)null)
			{
				EffectList hitEffect = component2.m_hitEffect;
				if (hitEffect != null)
				{
					findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
				}
			}
		}

		private void findEffectsAndChange(EffectData[] effects, ZNetScene zNetScene)
		{
			if (effects == null || effects.Length == 0)
			{
				return;
			}
			foreach (EffectData val in effects)
			{
				if ((Object)(object)val.m_prefab != (Object)null)
				{
					string name = ((Object)val.m_prefab).name;
					GameObject val2 = zNetScene.m_prefabs.Find((GameObject x) => (Object)(object)x != (Object)null && ((Object)x).name == name);
					if ((Object)(object)val2 != (Object)null)
					{
						val.m_prefab = val2;
					}
					else
					{
						Debug.LogWarning((object)("Coulnt not find in Znet fx name:" + name));
					}
				}
			}
		}
	}
	[Serializable]
	public class MappedEffectList
	{
		public List<EffectInfo> pieceEffect;

		public List<EffectInfo> destroyedEffects;

		public List<EffectInfo> hitEffects;

		public List<EffectInfo> switchEffect;

		public List<EffectInfo> blockEffect;

		public List<EffectInfo> equipEffect;

		public List<EffectInfo> hitEffect;

		public List<EffectInfo> hitTerrainEffect;

		public List<EffectInfo> holdStartEffect;

		public List<EffectInfo> startEffect;

		public List<EffectInfo> trailStartEffect;

		public List<EffectInfo> triggerEffect;

		public List<EffectInfo> unequipEffect;

		public EffectList createEffectListFromInfo(List<EffectInfo> list)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			EffectList val = new EffectList();
			List<EffectData> list2 = new List<EffectData>();
			val.m_effectPrefabs = list2.ToArray();
			return val;
		}

		private EffectData createEffectData(EffectInfo info)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			EffectData val = new EffectData();
			val.m_inheritParentRotation = info.inheritRotation;
			val.m_multiplyParentVisualScale = info.multiplyScale;
			val.m_childTransform = info.childName;
			val.m_inheritParentScale = info.inheritScale;
			val.m_variant = info.variant;
			val.m_scale = info.scale;
			val.m_attach = info.attach;
			val.m_follow = info.follow;
			val.m_prefab = ZNetScene.instance.m_prefabs.Find((GameObject x) => ((Object)x).name == info.name);
			return val;
		}
	}
	[Serializable]
	public struct EffectInfo
	{
		public string name;

		public bool enabled;

		public int variant;

		public bool attach;

		public bool follow;

		public bool inheritRotation;

		public bool inheritScale;

		public bool multiplyScale;

		public bool radnomRotation;

		public bool scale;

		public string childName;

		public EffectInfo(string name, bool enabled = true, int variant = -1, bool attach = false, bool follow = false, bool inheritRotation = false, bool inheritScale = false, bool multiplyScale = false, bool radnomRotation = false, bool scale = false, string childName = null)
		{
			this.name = name;
			this.enabled = enabled;
			this.variant = variant;
			this.attach = attach;
			this.follow = follow;
			this.inheritRotation = inheritRotation;
			this.inheritScale = inheritScale;
			this.multiplyScale = multiplyScale;
			this.radnomRotation = radnomRotation;
			this.scale = scale;
			this.childName = childName;
		}
	}
	public class ModResourceLoader
	{
		public AssetBundle assetBundle;

		public List<GameObject> buildPrefabs = new List<GameObject>();

		public List<GameObject> plantPrefabs = new List<GameObject>();

		public List<GameObject> itemPrefabs = new List<GameObject>();

		public List<GameObject> monsterPrefabs = new List<GameObject>();

		public List<GameObject> vegetationPrefabs = new List<GameObject>();

		public List<GameObject> clutterPrefabs = new List<GameObject>();

		public List<GameObject> locationPrefabs = new List<GameObject>();

		public List<GameObject> roomPrefabs = new List<GameObject>();

		public List<GameObject> vfxPrefabs = new List<GameObject>();

		public List<Sprite> backgrounds = new List<Sprite>();

		public FxReplacment fxReplacment = new FxReplacment();

		public List<Recipe> recipes = new List<Recipe>();

		public List<StatusEffect> statusEffects = new List<StatusEffect>();

		public static Sprite scrapCopper;

		public StatusEffect newBarleyStatus = null;

		public ShaderReplacment shaderReplacment = new ShaderReplacment();

		public Sprite newLogo = null;

		public void loadAssets()
		{
			assetBundle = GetAssetBundleFromResources("balrondpackager");
			string basePath = "Assets/Custom/Comission/BalrondPackager/";
			loadPieces(basePath);
			loadItems(basePath);
			loadOther(basePath);
		}

		public void AddPrefabsToZnetScene(ZNetScene zNetScene)
		{
			validateAddedPrefabs(itemPrefabs, zNetScene);
			validateAddedPrefabs(plantPrefabs, zNetScene);
			validateAddedPrefabs(vfxPrefabs, zNetScene);
			validateAddedPrefabs(buildPrefabs, zNetScene);
			zNetScene.m_prefabs.RemoveAll((GameObject x) => (Object)(object)x == (Object)null);
			foreach (GameObject go in zNetScene.m_prefabs)
			{
				List<GameObject> list = zNetScene.m_prefabs.FindAll((GameObject x) => ((Object)x).name == ((Object)go).name);
				if (list.Count > 1)
				{
					Debug.LogWarning((object)("DUPLICATE: " + ((Object)go).name));
				}
			}
			setupBuildPiecesList(zNetScene);
			setupPackager(zNetScene);
			setupUnpackager(zNetScene);
		}

		private void validateAddedPrefabs(List<GameObject> list, ZNetScene zNetScene)
		{
			foreach (GameObject gameObject in list)
			{
				List<GameObject> list2 = zNetScene.m_prefabs.FindAll((GameObject x) => ((Object)x).name == ((Object)gameObject).name);
				if (list2.Count > 1)
				{
					Debug.LogWarning((object)("DUPLICATE: " + ((Object)gameObject).name));
				}
				else
				{
					zNetScene.m_prefabs.Add(gameObject);
				}
			}
		}

		private void setupBuildPiecesList(ZNetScene zNetScene)
		{
			string[] array = new string[4] { "Hammer", "HammerIron_bal", "HammerDverger_bal", "HammerBlackmetal_bal" };
			GameObject val = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "Hammer");
			PieceTable buildPieces = val.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
			string[] array2 = array;
			foreach (string name in array2)
			{
				addTableToTool(name, buildPieces, zNetScene);
			}
			List<GameObject> pieces = buildPieces.m_pieces;
			foreach (GameObject buildPrefab in buildPrefabs)
			{
				setupRavenGuide(buildPrefab, zNetScene.m_prefabs);
				AddToBuildList(buildPrefab, pieces);
			}
			GameObject val2 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "Hoe");
			PieceTable buildPieces2 = val2.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
			addTableToTool("BlackMetalHoe_bal", buildPieces2, zNetScene);
			GameObject val3 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "Cultivator");
			PieceTable buildPieces3 = val3.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
			addTableToTool("BlackMetalCultivator_bal", buildPieces3, zNetScene);
		}

		private void addTableToTool(string name, PieceTable pieceTable, ZNetScene zNetScene)
		{
			GameObject val = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == name);
			if (!((Object)(object)val == (Object)null))
			{
				val.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces = pieceTable;
			}
		}

		public void setupRavenGuide(GameObject gameObject, List<GameObject> gameObjects)
		{
			GameObject val = null;
			Transform val2 = gameObject.transform.Find("GuidePoint");
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			GameObject val3 = gameObjects.Find((GameObject x) => ((Object)x).name == "piece_workbench");
			if ((Object)(object)val3 != (Object)null)
			{
				GameObject gameObject2 = ((Component)val3.transform.Find("GuidePoint")).gameObject;
				if ((Object)(object)gameObject2 != (Object)null)
				{
					GuidePoint component = gameObject2.GetComponent<GuidePoint>();
					if ((Object)(object)component != (Object)null)
					{
						val = component.m_ravenPrefab;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)"Ravens not found");
			}
			else
			{
				((Component)val2).GetComponent<GuidePoint>().m_ravenPrefab = val;
			}
		}

		public void setupBuildPiecesListDB()
		{
			GameObject val = ObjectDB.instance.m_items.Find((GameObject x) => ((Object)x).name == "Hammer");
			List<GameObject> pieces = val.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
			foreach (GameObject buildPrefab in buildPrefabs)
			{
				AddToBuildList(buildPrefab, pieces);
			}
		}

		private void AddToBuildList(GameObject prefab, List<GameObject> buildPieces)
		{
			if ((Object)(object)buildPieces.Find((GameObject x) => ((Object)x).name == ((Object)prefab).name) == (Object)null)
			{
				buildPieces.Add(prefab);
			}
		}

		private AssetBundle GetAssetBundleFromResources(string filename)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(filename));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			return AssetBundle.LoadFromStream(stream);
		}

		private void loadPieces(string basePath)
		{
			string text = basePath + "Pieces/";
			string[] buildPieces = BuildPieceList.buildPieces;
			string[] array = buildPieces;
			foreach (string text2 in array)
			{
				GameObject val = assetBundle.LoadAsset<GameObject>(text + text2 + ".prefab");
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("Could not find piece with name: " + text2));
					continue;
				}
				ShaderReplacment.Replace(val);
				buildPrefabs.Add(val);
			}
		}

		private void loadItems(string basePath)
		{
			string text = basePath + "Items/";
			string[] items = ItemList.items;
			string[] array = items;
			foreach (string text2 in array)
			{
				GameObject val = assetBundle.LoadAsset<GameObject>(text + text2 + ".prefab");
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("Could not find item with name: " + text2));
					continue;
				}
				ShaderReplacment.Replace(val);
				itemPrefabs.Add(val);
			}
		}

		private void loadOther(string basePath)
		{
			string text = basePath + "Other/";
			string[] array = new string[0];
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				GameObject val = assetBundle.LoadAsset<GameObject>(text + text2 + ".prefab");
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("Could not find object with name: " + text2));
					continue;
				}
				ShaderReplacment.Replace(val);
				vfxPrefabs.Add(val);
			}
		}

		private void setupPackager(ZNetScene zNetScene)
		{
			GameObject val = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "packager_bal");
			BalrondPackager balrondPackager = val.GetComponent<BalrondPackager>();
			if ((Object)(object)balrondPackager == (Object)null)
			{
				balrondPackager = val.AddComponent<BalrondPackager>();
			}
			Incinerator component = val.GetComponent<Incinerator>();
			if ((Object)(object)component != (Object)null)
			{
				balrondPackager.m_container = component.m_container;
				balrondPackager.m_leverAnim = component.m_leverAnim;
				balrondPackager.m_leverEffects = component.m_leverEffects;
				balrondPackager.m_enabled = ((Component)val.transform.Find("_enabled")).gameObject;
				balrondPackager.output = val.transform.Find("output");
				balrondPackager.m_defaultResult = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "CustomPackageItem_bal").GetComponent<ItemDrop>();
				balrondPackager.m_defaultCost = 1;
				balrondPackager.m_incinerateSwitch = component.m_incinerateSwitch;
				Object.Destroy((Object)(object)component);
			}
		}

		private void setupUnpackager(ZNetScene zNetScene)
		{
			GameObject val = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "unpackager_bal");
			BalrondUnpackager balrondUnpackager = val.GetComponent<BalrondUnpackager>();
			if ((Object)(object)balrondUnpackager == (Object)null)
			{
				balrondUnpackager = val.AddComponent<BalrondUnpackager>();
			}
			balrondUnpackager.m_requiresRoof = false;
			balrondUnpackager.m_requiredItem = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "CustomPackageItem_bal").GetComponent<ItemDrop>();
			balrondUnpackager.m_itemSpawnPoint = ((Component)balrondUnpackager).transform.Find("spawnpoint");
			balrondUnpackager.m_roofCheckPoint = ((Component)balrondUnpackager).transform.Find("roof_check_pint");
		}
	}
	public class ReferenceMapper
	{
		public static void MappBuildPieceEffectsFromTarget(GameObject gameObject, string sourceName, List<GameObject> list, bool isTable = false)
		{
			GameObject val = list.Find((GameObject x) => ((Object)x).name == sourceName);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)("Didnt found source name: " + sourceName));
				return;
			}
			Piece component = gameObject.GetComponent<Piece>();
			Piece component2 = val.GetComponent<Piece>();
			WearNTear component3 = gameObject.GetComponent<WearNTear>();
			WearNTear component4 = val.GetComponent<WearNTear>();
			component.m_placeEffect = component2.m_placeEffect;
			component3.m_hitEffect = component4.m_hitEffect;
			component3.m_destroyedEffect = component4.m_destroyedEffect;
			component3.m_switchEffect = component4.m_switchEffect;
			if (isTable)
			{
				CraftingStation component5 = gameObject.GetComponent<CraftingStation>();
				CraftingStation component6 = val.GetComponent<CraftingStation>();
				component5.m_craftItemDoneEffects = component6.m_craftItemDoneEffects;
				component5.m_craftItemEffects = component6.m_craftItemEffects;
				component5.m_repairItemDoneEffects = component6.m_repairItemDoneEffects;
				component5.m_repairItemDoneEffects = component6.m_repairItemDoneEffects;
			}
		}

		public static void SwapEffectsForVanilla(EffectList effectList)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			List<EffectData> list = new List<EffectData>();
			EffectList val = new EffectList();
			EffectData[] effectPrefabs = effectList.m_effectPrefabs;
			foreach (EffectData effectData in effectPrefabs)
			{
				list.Add(RewriteEffectData(effectData));
			}
			val.m_effectPrefabs = list.ToArray();
			effectList = val;
		}

		private static EffectData RewriteEffectData(EffectData effectData)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			EffectData val = new EffectData();
			val.m_inheritParentRotation = effectData.m_inheritParentRotation;
			val.m_multiplyParentVisualScale = effectData.m_multiplyParentVisualScale;
			val.m_childTransform = effectData.m_childTransform;
			val.m_inheritParentScale = effectData.m_inheritParentScale;
			val.m_variant = effectData.m_variant;
			val.m_scale = effectData.m_scale;
			val.m_attach = effectData.m_attach;
			val.m_follow = effectData.m_follow;
			GameObject val2 = ZNetScene.instance.m_prefabs.Find((GameObject x) => (Object)(object)x != (Object)null && ((Object)x).name == ((Object)effectData.m_prefab).name);
			if ((Object)(object)val2 != (Object)null)
			{
				val.m_prefab = val2;
			}
			else
			{
				val.m_prefab = effectData.m_prefab;
			}
			return val;
		}

		public static void CreateEffectsForList(EffectList effectList, List<string> effectNames, bool clear = false)
		{
			List<EffectData> list = new List<EffectData>();
			if (!clear)
			{
				list.AddRange(effectList.m_effectPrefabs);
			}
			foreach (string effectName in effectNames)
			{
				EffectInfo info = new EffectInfo(effectName);
				EffectData item = createEffectData(info);
				list.Add(item);
			}
			effectList.m_effectPrefabs = list.ToArray();
		}

		private static EffectData createEffectData(EffectInfo info)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			EffectData val = new EffectData();
			val.m_inheritParentRotation = info.inheritRotation;
			val.m_multiplyParentVisualScale = info.multiplyScale;
			val.m_childTransform = info.childName;
			val.m_inheritParentScale = info.inheritScale;
			val.m_variant = info.variant;
			val.m_scale = info.scale;
			val.m_attach = info.attach;
			val.m_follow = info.follow;
			val.m_prefab = ZNetScene.instance.m_prefabs.Find((GameObject x) => ((Object)x).name == info.name);
			return val;
		}

		public static void MappFromTextFile(GameObject gameObject, MappedEffectList mappedEffectList)
		{
		}
	}
	public class ShaderReplacment
	{
		public static List<GameObject> prefabsToReplaceShader = new List<GameObject>();

		public static List<Material> materialsInPrefabs = new List<Material>();

		public string[] shaderlist = new string[49]
		{
			"Custom/AlphaParticle", "Custom/Blob", "Custom/Bonemass", "Custom/Clouds", "Custom/Creature", "Custom/Decal", "Custom/Distortion", "Custom/Flow", "Custom/FlowOpaque", "Custom/Grass",
			"Custom/GuiScroll", "Custom/Heightmap", "Custom/icon", "Custom/InteriorSide", "Custom/LitGui", "Custom/LitParticles", "Custom/mapshader", "Custom/ParticleDecal", "Custom/Piece", "Custom/Player",
			"Custom/Rug", "Custom/ShadowBlob", "Custom/SkyboxProcedural", "Custom/SkyObject", "Custom/StaticRock", "Custom/Tar", "Custom/Trilinearmap", "Custom/UI/BGBlur", "Custom/Vegetation", "Custom/Water",
			"Custom/WaterBottom", "Custom/WaterMask", "Custom/Yggdrasil", "Custom/Yggdrasil/root", "Hidden/BlitCopyHDRTonemap", "Hidden/Dof/DepthOfFieldHdr", "Hidden/Dof/DX11Dof", "Hidden/Internal-Loading", "Hidden/Internal-UIRDefaultWorld", "Hidden/SimpleClear",
			"Hidden/SunShaftsComposite", "Lux Lit Particles/ Bumped", "Lux Lit Particles/ Tess Bumped", "Particles/Standard Surface2", "Particles/Standard Unlit2", "Standard TwoSided", "ToonDeferredShading2017", "Unlit/DepthWrite", "Unlit/Lighting"
		};

		public static List<Shader> shaders = new List<Shader>();

		private static readonly HashSet<Shader> CachedShaders = new HashSet<Shader>();

		public static bool debug = true;

		public static Shader findShader(string name)
		{
			Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
			if (array.Length == 0)
			{
				Debug.LogWarning((object)"SHADER LIST IS EMPTY!");
				return null;
			}
			if (debug)
			{
			}
			return shaders.Find((Shader x) => ((Object)x).name == name);
		}

		public static Shader GetShaderByName(string name)
		{
			return shaders.Find((Shader x) => ((Object)x).name == name.Trim());
		}

		public static void debugShaderList(List<Shader> shadersRes)
		{
			foreach (Shader shadersRe in shadersRes)
			{
				Debug.LogWarning((object)("SHADER NAME IS: " + ((Object)shadersRe).name));
			}
			debug = false;
		}

		public static void Replace(GameObject gameObject)
		{
			prefabsToReplaceShader.Add(gameObject);
			GetMaterialsInPrefab(gameObject);
		}

		public static void GetMaterialsInPrefab(GameObject gameObject)
		{
			Renderer[] componentsInChildren = gameObject.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					continue;
				}
				Material[] array2 = sharedMaterials;
				foreach (Material val2 in array2)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						materialsInPrefabs.Add(val2);
					}
				}
			}
		}

		public static void getMeShaders()
		{
			AssetBundle[] array = Resources.FindObjectsOfTypeAll<AssetBundle>();
			AssetBundle[] array2 = array;
			foreach (AssetBundle val in array2)
			{
				IEnumerable<Shader> enumerable3;
				try
				{
					IEnumerable<Shader> enumerable2;
					if (!val.isStreamedSceneAssetBundle || !Object.op_Implicit((Object)(object)val))
					{
						IEnumerable<Shader> enumerable = val.LoadAllAssets<Shader>();
						enumerable2 = enumerable;
					}
					else
					{
						enumerable2 = from shader in ((IEnumerable<string>)val.GetAllAssetNames()).Select((Func<string, Shader>)val.LoadAsset<Shader>)
							where (Object)(object)shader != (Object)null
							select shader;
					}
					enumerable3 = enumerable2;
				}
				catch (Exception)
				{
					continue;
				}
				if (enumerable3 == null)
				{
					continue;
				}
				foreach (Shader item in enumerable3)
				{
					CachedShaders.Add(item);
				}
			}
		}

		public static void runMaterialFix()
		{
			getMeShaders();
			shaders.AddRange(CachedShaders);
			foreach (Material materialsInPrefab in materialsInPrefabs)
			{
				Shader shader = materialsInPrefab.shader;
				if (!((Object)(object)shader == (Object)null))
				{
					string name = ((Object)shader).name;
					if (!(name == "Standard") && !name.Contains("ScrollingTex") && name.Contains("Balrond"))
					{
						setProperValue(materialsInPrefab, name);
					}
				}
			}
		}

		private static void setProperValue(Material material, string shaderName)
		{
			string name = shaderName.Replace("Balrond", "Custom");
			name = checkNaming(name);
			Shader shaderByName = GetShaderByName(name);
			if ((Object)(object)shaderByName == (Object)null)
			{
				Debug.LogWarning((object)("Shader not found " + name));
			}
			else
			{
				material.shader = shaderByName;
			}
		}

		private static string checkNaming(string name)
		{
			string result = name;
			if (name.Contains("Bumped"))
			{
				result = name.Replace("Custom", "Lux Lit Particles");
			}
			if (name.Contains("Tess Bumped"))
			{
				result = name.Replace("Custom", "Lux Lit Particles");
			}
			if (name.Contains("Standard Surface"))
			{
				result = name.Replace("Custom", "Particles");
				result = result.Replace("Standard Surface2", "Standard Surface");
			}
			if (name.Contains("Standard Unlit"))
			{
				result = name.Replace("Custom", "Particles");
				result = result.Replace("Standard Unlit", "Standard Unlit2");
				result = result.Replace("Standard Unlit22", "Standard Unlit2");
			}
			return result;
		}
	}
	public class TableMapper
	{
		public static CraftingStation cauldron;

		public static CraftingStation workbench;

		public static CraftingStation heavyWorkbench;

		public static CraftingStation forge;

		public static CraftingStation ironworks;

		public static CraftingStation blackforge;

		public static CraftingStation stoneCutter;

		public static CraftingStation artisian;

		public static CraftingStation magetable;

		public static CraftingStation runeforge;

		public static CraftingStation tannery;

		public static CraftingStation fletcher;

		public static CraftingStation grill;

		public static CraftingStation alchemylab;

		public static List<GameObject> pieces = new List<GameObject>();

		public static void setupTables(List<GameObject> list)
		{
			pieces = list;
			prepareTables();
		}

		private static CraftingStation FindStation(List<GameObject> list, string name)
		{
			GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val != (Object)null)
			{
				return val.GetComponent<CraftingStation>();
			}
			Debug.LogWarning((object)("TableMapper - Station not found: " + name));
			return null;
		}

		private static void prepareTables()
		{
			cauldron = FindStation(pieces, "piece_cauldron");
			workbench = FindStation(pieces, "piece_workbench");
			heavyWorkbench = FindStation(pieces, "piece_heavy_workbench_bal");
			forge = FindStation(pieces, "forge");
			ironworks = FindStation(pieces, "piece_metalworks_bal");
			blackforge = FindStation(pieces, "blackforge");
			stoneCutter = FindStation(pieces, "piece_stonecutter");
			artisian = FindStation(pieces, "piece_artisanstation");
			runeforge = FindStation(pieces, "piece_runeforge_bal");
			magetable = FindStation(pieces, "piece_magetable");
			fletcher = FindStation(pieces, "piece_fletcher_bal");
		}
	}
	internal class BuildPieceList
	{
		public static string[] buildPieces = new string[2] { "packager_bal", "unpackager_bal" };
	}
	internal class ItemList
	{
		public static string[] items = new string[1] { "CustomPackageItem_bal" };
	}
	public class JsonLoader
	{
		public string defaultPath = string.Empty;

		public void loadJson()
		{
			LoadTranslations();
			justDefaultPath();
		}

		public void justDefaultPath()
		{
			string configPath = Paths.ConfigPath;
			string text = Path.Combine(configPath, "BalrondPackager-translation/");
			defaultPath = text;
		}

		public void createDefaultPath()
		{
			string configPath = Paths.ConfigPath;
			string text = Path.Combine(configPath, "BalrondPackager-translation/");
			if (!Directory.Exists(text))
			{
				CreateFolder(text);
			}
			else
			{
				Debug.Log((object)("BalrondPackager: Folder already exists: " + text));
			}
			defaultPath = text;
		}

		private string[] jsonFilePath(string folderName, string extension)
		{
			string configPath = Paths.ConfigPath;
			string text = Path.Combine(configPath, "BalrondPackager-translation/");
			if (!Directory.Exists(text))
			{
				CreateFolder(text);
			}
			else
			{
				Debug.Log((object)("BalrondPackager: Folder already exists: " + text));
			}
			string[] files = Directory.GetFiles(text, extension);
			Debug.Log((object)("BalrondPackager:" + folderName + " Json Files Found: " + files.Length));
			return files;
		}

		private static void CreateFolder(string path)
		{
			try
			{
				Directory.CreateDirectory(path);
				Debug.Log((object)"BalrondPackager: Folder created successfully.");
			}
			catch (Exception ex)
			{
				Debug.Log((object)("BalrondPackager: Error creating folder: " + ex.Message));
			}
		}

		private void LoadTranslations()
		{
			int num = 0;
			string[] array = jsonFilePath("Translation", "*.json");
			foreach (string text in array)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
				string json = File.ReadAllText(text);
				JsonData jsonData = JsonMapper.ToObject(json);
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				foreach (string key in jsonData.Keys)
				{
					dictionary[key] = jsonData[key].ToString();
				}
				if (dictionary != null)
				{
					BalrondTranslator.translations.Add(fileNameWithoutExtension, dictionary);
					Debug.Log((object)("BalrondPackager: Json Files Language: " + fileNameWithoutExtension));
					num++;
				}
				else
				{
					Debug.LogError((object)("BalrondPackager: Loading FAILED file: " + text));
				}
			}
			Debug.Log((object)("BalrondPackager: Translation JsonFiles Loaded: " + num));
		}
	}
	[BepInPlugin("balrond.astafaraios.BalrondPackager", "BalrondPackager", "1.0.1")]
	public class Launch : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Player), "UseStamina")]
		private class Player_UseStamina
		{
			private static bool Prefix()
			{
				if (Player.m_debugMode && ((Terminal)Console.instance).IsCheatsEnabled())
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "UseEitr")]
		private class Player_UseEtir
		{
			private static bool Prefix()
			{
				if (Player.m_debugMode && ((Terminal)Console.instance).IsCheatsEnabled())
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "SetupGui")]
		private class FejdStartup_SetupGUI
		{
			private static void Postfix()
			{
				string selectedLanguage = Localization.instance.GetSelectedLanguage();
				Dictionary<string, string> dictionary = BalrondTranslator.getLanguage("English");
				if ("English" != selectedLanguage)
				{
					Dictionary<string, string> language = BalrondTranslator.getLanguage(selectedLanguage);
					if (language != null)
					{
						dictionary = language;
					}
					else
					{
						Debug.Log((object)"BalrondPackager: Did not find translation file loading English");
					}
				}
				if (dictionary != null)
				{
					foreach (KeyValuePair<string, string> item in dictionary)
					{
						Localization.instance.AddWord(item.Key, item.Value);
					}
					return;
				}
				Debug.LogWarning((object)"BalrondPackager: No translation file found!");
			}
		}

		[HarmonyPatch(typeof(AudioMan), "Awake")]
		private static class AudioMan_Awake_Patch
		{
			private static void Postfix(AudioMan __instance)
			{
				foreach (GameObject itemPrefab in modResourceLoader.itemPrefabs)
				{
					AudioSource[] componentsInChildren = itemPrefab.GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val in componentsInChildren)
					{
						val.outputAudioMixerGroup = __instance.m_masterMixer.outputAudioMixerGroup;
					}
				}
				foreach (GameObject buildPrefab in modResourceLoader.buildPrefabs)
				{
					AudioSource[] componentsInChildren2 = buildPrefab.GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val2 in componentsInChildren2)
					{
						val2.outputAudioMixerGroup = __instance.m_masterMixer.outputAudioMixerGroup;
					}
				}
				foreach (GameObject monsterPrefab in modResourceLoader.monsterPrefabs)
				{
					AudioSource[] componentsInChildren3 = monsterPrefab.GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val3 in componentsInChildren3)
					{
						val3.outputAudioMixerGroup = __instance.m_masterMixer.outputAudioMixerGroup;
					}
				}
				foreach (GameObject vfxPrefab in modResourceLoader.vfxPrefabs)
				{
					AudioSource[] componentsInChildren4 = vfxPrefab.GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val4 in componentsInChildren4)
					{
						val4.outputAudioMixerGroup = __instance.m_masterMixer.outputAudioMixerGroup;
					}
				}
				foreach (GameObject vegetationPrefab in modResourceLoader.vegetationPrefabs)
				{
					AudioSource[] componentsInChildren5 = vegetationPrefab.GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val5 in componentsInChildren5)
					{
						val5.outputAudioMixerGroup = __instance.m_masterMixer.outputAudioMixerGroup;
					}
				}
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		public static class Object_CopyOtherDB_Path
		{
			public static void Postfix()
			{
				if (IsObjectDBValid())
				{
					modResourceLoader.setupBuildPiecesListDB();
					databaseAddMethods.AddItems(modResourceLoader.itemPrefabs);
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		public static class Inventory_AddItem_Path
		{
			public static void Postfix(Inventory __instance, ItemData item)
			{
				if ((Object)(object)item.m_dropPrefab != (Object)null && ((Object)item.m_dropPrefab).name.Contains("CustomPackageItem_bal"))
				{
					string value = "";
					string value2 = "";
					float num = 0f;
					int num2 = 0;
					string value3 = "";
					item.m_customData.TryGetValue("BalrondPackageDescription", out value);
					item.m_customData.TryGetValue("BalrondPackageWeight", out value2);
					item.m_customData.TryGetValue("BalrondPackageTeleportable", out value3);
					if (value3 != "" && value3 != null)
					{
						num2 = int.Parse(value3);
						item.m_shared.m_teleportable = num2 == 1;
					}
					if (value2 != "" && value2 != null)
					{
						num = float.Parse(value2, CultureInfo.GetCultureInfo("es-ES"));
						item.m_shared.m_weight = num;
					}
					if (value != "" && value != null)
					{
						item.m_shared.m_description = value;
					}
				}
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Awake")]
		public static class ItemDrop_Awake_Path
		{
			public static void Postfix(ItemDrop __instance)
			{
				if (((Object)((Component)__instance).gameObject).name.Contains("CustomPackageItem_bal"))
				{
					string value = "";
					string value2 = "";
					float num = 0f;
					int num2 = 0;
					string value3 = "";
					__instance.m_itemData.m_customData.TryGetValue("BalrondPackageDescription", out value);
					__instance.m_itemData.m_customData.TryGetValue("BalrondPackageWeight", out value2);
					__instance.m_itemData.m_customData.TryGetValue("BalrondPackageTeleportable", out value3);
					if (value3 != "" && value3 != null)
					{
						num2 = int.Parse(value3);
						__instance.m_itemData.m_shared.m_teleportable = ((num2 != 0) ? true : false);
					}
					if (value2 != "" && value2 != null)
					{
						num = float.Parse(value2, CultureInfo.GetCultureInfo("es-ES"));
						__instance.m_itemData.m_shared.m_weight = num;
					}
					if (value != "" && value != null)
					{
						__instance.m_itemData.m_shared.m_description = value;
					}
				}
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		public static class ObjectDB_Awake_Path
		{
			public static void Postfix()
			{
				if (IsObjectDBValid())
				{
					modResourceLoader.setupBuildPiecesListDB();
					databaseAddMethods.AddItems(modResourceLoader.itemPrefabs);
					databaseAddMethods.AddStatuseffects(modResourceLoader.statusEffects);
					databaseAddMethods.AddRecipes(modResourceLoader.recipes);
					ObjectDB.instance.m_recipes.Sort(SortByScore);
				}
			}

			private static int SortByScore(Recipe p1, Recipe p2)
			{
				if ((Object)(object)p1.m_item == (Object)null)
				{
					return 0;
				}
				if ((Object)(object)p2.m_item == (Object)null)
				{
					return 1;
				}
				return ((Object)p1.m_item).name.CompareTo(((Object)p2.m_item).name);
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		public static class ZNetScene_Awake_Path
		{
			public static bool hasSpawned;

			public static void Prefix(ZNetScene __instance)
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null)
				{
					Debug.LogWarning((object)(projectName + ": No ZnetScene found"));
					return;
				}
				modResourceLoader.AddPrefabsToZnetScene(__instance);
				if (!Launch.hasSpawned)
				{
					buildPieceBuilder.SetupBuildPieces(__instance.m_prefabs);
					if (!new ZNet().IsDedicated())
					{
						ShaderReplacment.runMaterialFix();
						Launch.hasSpawned = true;
					}
				}
			}
		}

		[HarmonyPriority(800)]
		[HarmonyPatch(typeof(Localization), "SetupLanguage")]
		private class Translation_SetupLanguage
		{
			private static void Prefix(Localization __instance, string language)
			{
				Dictionary<string, string> dictionary = BalrondTranslator.getLanguage("English");
				if ("English" != language)
				{
					Dictionary<string, string> language2 = BalrondTranslator.getLanguage(language);
					if (language2 != null)
					{
						dictionary = language2;
					}
					else
					{
						Debug.Log((object)"BalrondPackager: Did not find translation file loading English");
					}
				}
				if (dictionary != null)
				{
					foreach (KeyValuePair<string, string> item in dictionary)
					{
						__instance.AddWord(item.Key, item.Value);
					}
					return;
				}
				Debug.LogWarning((object)"BalrondPackager: No translation file found!");
			}
		}

		[HarmonyPriority(800)]
		[HarmonyPatch(typeof(Localization), "LoadCSV")]
		private class Translation_LoadCSV
		{
			private static void Prefix(Localization __instance, string language)
			{
				Dictionary<string, string> dictionary = BalrondTranslator.getLanguage("English");
				if ("English" != language)
				{
					Dictionary<string, string> language2 = BalrondTranslator.getLanguage(language);
					if (language2 != null)
					{
						dictionary = language2;
					}
					else
					{
						Debug.Log((object)"BalrondPackager: Did not find translation file loading English");
					}
				}
				if (dictionary != null)
				{
					foreach (KeyValuePair<string, string> item in dictionary)
					{
						__instance.AddWord(item.Key, item.Value);
					}
					return;
				}
				Debug.LogWarning((object)"BalrondPackager: No translation file found!");
			}
		}

		private readonly Harmony harmony = new Harmony("balrond.astafaraios.BalrondPackager");

		public const string PluginGUID = "balrond.astafaraios.BalrondPackager";

		public const string PluginName = "BalrondPackager";

		public const string PluginVersion = "1.0.1";

		public static ModResourceLoader modResourceLoader = new ModResourceLoader();

		public static DatabaseAddMethods databaseAddMethods = new DatabaseAddMethods();

		public static BuildPieceBuilder buildPieceBuilder = new BuildPieceBuilder();

		public static GameObject gui;

		public static GameObject gui2;

		public static string projectName = "BalrondPackager";

		public static JsonLoader jsonLoader = new JsonLoader();

		public static GameObject RootObject;

		public static GameObject PrefabContainer;

		public static bool hasSpawned = false;

		public static float biomeCounter = 1000f;

		public static List<string> loadingScreens = new List<string>();

		public static Dictionary<string, string> loadingScreens2 = new Dictionary<string, string>();

		public static Dictionary<string, DateTime> fileWriteTimes = new Dictionary<string, DateTime>();

		public static List<string> screensToLoad = new List<string>();

		public static string[] loadingTips = new string[0];

		public static Dictionary<string, Texture2D> cachedScreens = new Dictionary<string, Texture2D>();

		private void Awake()
		{
			jsonLoader.loadJson();
			createPrefabContainer();
			modResourceLoader.loadAssets();
			harmony.PatchAll();
		}

		public void createPrefabContainer()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			RootObject = new GameObject("_ValheimReforgedRoot");
			Object.DontDestroyOnLoad((Object)(object)RootObject);
			PrefabContainer = new GameObject("Prefabs");
			PrefabContainer.transform.parent = RootObject.transform;
			PrefabContainer.SetActive(false);
		}

		public static GameObject cloneMe(GameObject source, string name)
		{
			GameObject val = Object.Instantiate<GameObject>(source, PrefabContainer.transform);
			((Object)val).name = name;
			fixMaterials(val, source);
			val.SetActive(true);
			return val;
		}

		public static GameObject fixMaterials(GameObject clone, GameObject source)
		{
			MeshRenderer[] componentsInChildren = source.GetComponentsInChildren<MeshRenderer>();
			foreach (MeshRenderer val in componentsInChildren)
			{
				MeshRenderer[] componentsInChildren2 = clone.GetComponentsInChildren<MeshRenderer>();
				foreach (MeshRenderer val2 in componentsInChildren2)
				{
					if (((Object)val).name == ((Object)val2).name)
					{
						((Renderer)val2).materials = ((Renderer)val).sharedMaterials;
						((Renderer)val2).sharedMaterials = ((Renderer)val).sharedMaterials;
						break;
					}
				}
			}
			return clone;
		}

		private void OnDestroy()
		{
			harmony.UnpatchSelf();
		}

		private static bool IsObjectDBValid()
		{
			return (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items.Count != 0 && ObjectDB.instance.m_recipes.Count != 0 && (Object)(object)ObjectDB.instance.GetItemPrefab("Amber") != (Object)null;
		}
	}
	public class BuildPieceBuilder
	{
		private List<GameObject> list;

		private string[] piecesNames = new string[2] { "packager_bal", "unpackager_bal" };

		public void SetupBuildPieces(List<GameObject> list)
		{
			TableMapper.setupTables(list);
			this.list = list;
			string[] array = piecesNames;
			foreach (string name in array)
			{
				GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("Cant find buildpiece with name: " + name));
				}
				else
				{
					EditBuildPiece(val);
				}
			}
		}

		private void EditBuildPiece(GameObject gameObject)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			Piece component = gameObject.gameObject.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			string name = ((Object)component).name;
			string text = name;
			if (!(text == "packager_bal"))
			{
				if (text == "unpackager_bal")
				{
					SetStation(component, TableMapper.workbench);
					AddResources(component, "Stone", 10);
					AddResources(component, "Wood", 10);
					component.m_category = (PieceCategory)1;
				}
			}
			else
			{
				SetStation(component, TableMapper.forge);
				AddResources(component, "ElderBark", 20);
				AddResources(component, "SurtlingCore", 5);
				AddResources(component, "Stone", 10);
				AddResources(component, "Iron", 10);
				AddResources(component, "RoundLog", 10);
				component.m_category = (PieceCategory)1;
			}
		}

		private void PrepareForSpecificChest(DropTable dropTable, string name, int amount)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			DropData item = createBundleDefaultItem(name, amount);
			dropTable.m_drops.Add(item);
		}

		private DropData createBundleDefaultItem(string name, int amount)
		{
			//IL_0003: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			DropData result = default(DropData);
			result.m_stackMin = amount;
			result.m_stackMax = amount;
			result.m_dontScale = false;
			result.m_weight = 10f;
			result.m_item = FindItem(list, name);
			return result;
		}

		private void SetCampfire(Piece piece, string itemName, int startFuel, int maxFuel, float secPerFuel)
		{
			Fireplace component = ((Component)piece).GetComponent<Fireplace>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)("there is not fireplace component on:" + ((Object)((Component)piece).gameObject).name));
			}
		}

		private void SetStation(Piece piece, CraftingStation station)
		{
			piece.m_craftingStation = station;
		}

		private void EditResource(Piece piece, string itemName, int amount, bool remove = false)
		{
			if (remove)
			{
				List<Requirement> list = new List<Requirement>();
				Requirement[] resources = piece.m_resources;
				foreach (Requirement val in resources)
				{
					if (((Object)((Component)val.m_resItem).gameObject).name != itemName)
					{
						list.Add(val);
					}
				}
				piece.m_resources = list.ToArray();
				return;
			}
			Requirement[] resources2 = piece.m_resources;
			foreach (Requirement val2 in resources2)
			{
				if (((Object)((Component)val2.m_resItem).gameObject).name == itemName)
				{
					val2.m_amount = amount;
				}
			}
		}

		private void AddResources(Piece piece, string itemName, int amount, int amountPerLevel = 0, bool recover = true)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			List<Requirement> list = new List<Requirement>();
			list.AddRange(piece.m_resources);
			Requirement val = new Requirement();
			val.m_resItem = FindItem(this.list, itemName).GetComponent<ItemDrop>();
			val.m_amount = amount;
			val.m_amountPerLevel = amountPerLevel;
			val.m_recover = recover;
			list.Add(val);
			piece.m_resources = list.ToArray();
		}

		private GameObject FindItem(List<GameObject> list, string name, bool isStation = false)
		{
			GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if ((Object)(object)val == (Object)null && isStation)
			{
				return null;
			}
			Debug.LogWarning((object)(Launch.projectName + ": Item Not Found - " + name + ", Replaced With Wood"));
			return list.Find((GameObject x) => ((Object)x).name == "Wood");
		}

		private CraftingStation FindStation(List<GameObject> list, string name)
		{
			GameObject val = FindItem(list, name, isStation: true);
			if ((Object)(object)val != (Object)null)
			{
				return val.GetComponent<CraftingStation>();
			}
			return null;
		}
	}
	public class FoodDataBlock
	{
		public int health;

		public int stamina;

		public int etir;

		public int healthRegen;

		public int time;
	}
	public class Resource
	{
		public int amount = 1;

		public int amountPerLevel = 0;

		public bool recovery = true;

		public ItemDrop itemDrop;

		public Requirement pieceConfig;

		public string item = "Wood";

		public Resource()
		{
		}

		public Resource(string item, int amount, int amountPerLevel = 0, bool recovery = true)
		{
			this.item = item;
			this.amount = amount;
			this.amountPerLevel = amountPerLevel;
			this.recovery = recovery;
		}

		public void setItemDrop(GameObject prefab)
		{
			if ((Object)(object)prefab.GetComponent<ItemDrop>() != (Object)null)
			{
				itemDrop = prefab.GetComponent<ItemDrop>();
			}
			else
			{
				Debug.LogWarning((object)("DVERGER FURNITURE: NO ITEM DROP FOUND on prefab name: " + ((Object)prefab).name));
			}
		}

		public Requirement getPieceConfig()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_003e: Expected O, but got Unknown
			Requirement val = new Requirement
			{
				m_resItem = itemDrop,
				m_amount = amount,
				m_amountPerLevel = amountPerLevel,
				m_recover = recovery
			};
			Requirement result = val;
			pieceConfig = val;
			return result;
		}
	}
}
namespace LitJson2
{
	internal enum JsonType
	{
		None,
		Object,
		Array,
		String,
		Int,
		Long,
		Double,
		Boolean
	}
	internal interface IJsonWrapper : IList, IOrderedDictionary, IDictionary, ICollection, IEnumerable
	{
		bool IsArray { get; }

		bool IsBoolean { get; }

		bool IsDouble { get; }

		bool IsInt { get; }

		bool IsLong { get; }

		bool IsObject { get; }

		bool IsString { get; }

		bool GetBoolean();

		double GetDouble();

		int GetInt();

		JsonType GetJsonType();

		long GetLong();

		string GetString();

		void SetBoolean(bool val);

		void SetDouble(double val);

		void SetInt(int val);

		void SetJsonType(JsonType type);

		void SetLong(long val);

		void SetString(string val);

		string ToJson();

		void ToJson(JsonWriter writer);
	}
	internal class JsonData : IJsonWrapper, IList, IOrderedDictionary, IDictionary, ICollection, IEnumerable, IEquatable<JsonData>
	{
		private IList<JsonData> inst_array;

		private bool inst_boolean;

		private double inst_double;

		private int inst_int;

		private long inst_long;

		private IDictionary<string, JsonData> inst_object;

		private string inst_string;

		private string json;

		private JsonType type;

		private IList<KeyValuePair<string, JsonData>> object_list;

		public int Count => EnsureCollection().Count;

		public bool IsArray => type == JsonType.Array;

		public bool IsBoolean => type == JsonType.Boolean;

		public bool IsDouble => type == JsonType.Double;

		public bool IsInt => type == JsonType.Int;

		public bool IsLong => type == JsonType.Long;

		public bool IsObject => type == JsonType.Object;

		public bool IsString => type == JsonType.String;

		public ICollection<string> Keys
		{
			get
			{
				EnsureDictionary();
				return inst_object.Keys;
			}
		}

		int ICollection.Count => Count;

		bool ICollection.IsSynchronized => EnsureCollection().IsSynchronized;

		object ICollection.SyncRoot => EnsureCollection().SyncRoot;

		bool IDictionary.IsFixedSize => EnsureDictionary().IsFixedSize;

		bool IDictionary.IsReadOnly => EnsureDictionary().IsReadOnly;

		ICollection IDictionary.Keys
		{
			get
			{
				EnsureDictionary();
				IList<string> list = new List<string>();
				foreach (KeyValuePair<string, JsonData> item in object_list)
				{
					list.Add(item.Key);
				}
				return (ICollection)list;
			}
		}

		ICollection IDictionary.Values
		{
			get
			{
				EnsureDictionary();
				IList<JsonData> list = new List<JsonData>();
				foreach (KeyValuePair<string, JsonData> item in object_list)
				{
					list.Add(item.Value);
				}
				return (ICollection)list;
			}
		}

		bool IJsonWrapper.IsArray => IsArray;

		bool IJsonWrapper.IsBoolean => IsBoolean;

		bool IJsonWrapper.IsDouble => IsDouble;

		bool IJsonWrapper.IsInt => IsInt;

		bool IJsonWrapper.IsLong => IsLong;

		bool IJsonWrapper.IsObject => IsObject;

		bool IJsonWrapper.IsString => IsString;

		bool IList.IsFixedSize => EnsureList().IsFixedSize;

		bool IList.IsReadOnly => EnsureList().IsReadOnly;

		object IDictionary.this[object key]
		{
			get
			{
				return EnsureDictionary()[key];
			}
			set
			{
				if (!(key is string))
				{
					throw new ArgumentException("The key has to be a string");
				}
				JsonData value2 = ToJsonData(value);
				this[(string)key] = value2;
			}
		}

		object IOrderedDictionary.this[int idx]
		{
			get
			{
				EnsureDictionary();
				return object_list[idx].Value;
			}
			set
			{
				EnsureDictionary();
				JsonData value2 = ToJsonData(value);
				KeyValuePair<string, JsonData> keyValuePair = object_list[idx];
				inst_object[keyValuePair.Key] = value2;
				KeyValuePair<string, JsonData> value3 = new KeyValuePair<string, JsonData>(keyValuePair.Key, value2);
				object_list[idx] = value3;
			}
		}

		object IList.this[int index]
		{
			get
			{
				return EnsureList()[index];
			}
			set
			{
				EnsureList();
				JsonData value2 = ToJsonData(value);
				this[index] = value2;
			}
		}

		public JsonData this[string prop_name]
		{
			get
			{
				EnsureDictionary();
				return inst_object[prop_name];
			}
			set
			{
				EnsureDictionary();
				KeyValuePair<string, JsonData> keyValuePair = new KeyValuePair<string, JsonData>(prop_name, value);
				if (inst_object.ContainsKey(prop_name))
				{
					for (int i = 0; i < object_list.Count; i++)
					{
						if (object_list[i].Key == prop_name)
						{
							object_list[i] = keyValuePair;
							break;
						}
					}
				}
				else
				{
					object_list.Add(keyValuePair);
				}
				inst_object[prop_name] = value;
				json = null;
			}
		}

		public JsonData this[int index]
		{
			get
			{
				EnsureCollection();
				if (type == JsonType.Array)
				{
					return inst_array[index];
				}
				return object_list[index].Value;
			}
			set
			{
				EnsureCollection();
				if (type == JsonType.Array)
				{
					inst_array[index] = value;
				}
				else
				{
					KeyValuePair<string, JsonData> keyValuePair = object_list[index];
					KeyValuePair<string, JsonData> value2 = new KeyValuePair<string, JsonData>(keyValuePair.Key, value);
					object_list[index] = value2;
					inst_object[keyValuePair.Key] = value;
				}
				json = null;
			}
		}

		public JsonData()
		{
		}

		public JsonData(bool boolean)
		{
			type = JsonType.Boolean;
			inst_boolean = boolean;
		}

		public JsonData(double number)
		{
			type = JsonType.Double;
			inst_double = number;
		}

		public JsonData(int number)
		{
			type = JsonType.Int;
			inst_int = number;
		}

		public JsonData(long number)
		{
			type = JsonType.Long;
			inst_long = number;
		}

		public JsonData(object obj)
		{
			if (obj is bool)
			{
				type = JsonType.Boolean;
				inst_boolean = (bool)obj;
				return;
			}
			if (obj is double)
			{
				type = JsonType.Double;
				inst_double = (double)obj;
				return;
			}
			if (obj is int)
			{
				type = JsonType.Int;
				inst_int = (int)obj;
				return;
			}
			if (obj is long)
			{
				type = JsonType.Long;
				inst_long = (long)obj;
				return;
			}
			if (obj is string)
			{
				type = JsonType.String;
				inst_string = (string)obj;
				return;
			}
			throw new ArgumentException("Unable to wrap the given object with JsonData");
		}

		public JsonData(string str)
		{
			type = JsonType.String;
			inst_string = str;
		}

		public static implicit operator JsonData(bool data)
		{
			return new JsonData(data);
		}

		public static implicit operator JsonData(double data)
		{
			return new JsonData(data);
		}

		public static implicit operator JsonData(int data)
		{
			return new JsonData(data);
		}

		public static implicit operator JsonData(long data)
		{
			return new JsonData(data);
		}

		public static implicit operator JsonData(string data)
		{
			return new JsonData(data);
		}

		public static explicit operator bool(JsonData data)
		{
			if (data.type != JsonType.Boolean)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold a double");
			}
			return data.inst_boolean;
		}

		public static explicit operator double(JsonData data)
		{
			if (data.type != JsonType.Double)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold a double");
			}
			return data.inst_double;
		}

		public static explicit operator int(JsonData data)
		{
			if (data.type != JsonType.Int)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold an int");
			}
			return data.inst_int;
		}

		public static explicit operator long(JsonData data)
		{
			if (data.type != JsonType.Long)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold an int");
			}
			return data.inst_long;
		}

		public static explicit operator string(JsonData data)
		{
			if (data.type != JsonType.String)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold a string");
			}
			return data.inst_string;
		}

		void ICollection.CopyTo(Array array, int index)
		{
			EnsureCollection().CopyTo(array, index);
		}

		void IDictionary.Add(object key, object value)
		{
			JsonData value2 = ToJsonData(value);
			EnsureDictionary().Add(key, value2);
			KeyValuePair<string, JsonData> item = new KeyValuePair<string, JsonData>((string)key, value2);
			object_list.Add(item);
			json = null;
		}

		void IDictionary.Clear()
		{
			EnsureDictionary().Clear();
			object_list.Clear();
			json = null;
		}

		bool IDictionary.Contains(object key)
		{
			return EnsureDictionary().Contains(key);
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return ((IOrderedDictionary)this).GetEnumerator();
		}

		void IDictionary.Remove(object key)
		{
			EnsureDictionary().Remove(key);
			for (int i = 0; i < object_list.Count; i++)
			{
				if (object_list[i].Key == (string)key)
				{
					object_list.RemoveAt(i);
					break;
				}
			}
			json = null;
		}

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

		bool IJsonWrapper.GetBoolean()
		{
			if (type != JsonType.Boolean)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a boolean");
			}
			return inst_boolean;
		}

		double IJsonWrapper.GetDouble()
		{
			if (type != JsonType.Double)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a double");
			}
			return inst_double;
		}

		int IJsonWrapper.GetInt()
		{
			if (type != JsonType.Int)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold an int");
			}
			return inst_int;
		}

		long IJsonWrapper.GetLong()
		{
			if (type != JsonType.Long)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a long");
			}
			return inst_long;
		}

		string IJsonWrapper.GetString()
		{
			if (type != JsonType.String)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a string");
			}
			return inst_string;
		}

		void IJsonWrapper.SetBoolean(bool val)
		{
			type = JsonType.Boolean;
			inst_boolean = val;
			json = null;
		}

		void IJsonWrapper.SetDouble(double val)
		{
			type = JsonType.Double;
			inst_double = val;
			json = null;
		}

		void IJsonWrapper.SetInt(int val)
		{
			type = JsonType.Int;
			inst_int = val;
			json = null;
		}

		void IJsonWrapper.SetLong(long val)
		{
			type = JsonType.Long;
			inst_long = val;
			json = null;
		}

		void IJsonWrapper.SetString(string val)
		{
			type = JsonType.String;
			inst_string = val;
			json = null;
		}

		string IJsonWrapper.ToJson()
		{
			return ToJson();
		}

		void IJsonWrapper.ToJson(JsonWriter writer)
		{
			ToJson(writer);
		}

		int IList.Add(object value)
		{
			return Add(value);
		}

		void IList.Clear()
		{
			EnsureList().Clear();
			json = null;
		}

		bool IList.Contains(object value)
		{
			return EnsureList().Contains(value);
		}

		int IList.IndexOf(object value)
		{
			return EnsureList().IndexOf(value);
		}

		void IList.Insert(int index, object value)
		{
			EnsureList().Insert(index, value);
			json = null;
		}

		void IList.Remove(object value)
		{
			EnsureList().Remove(value);
			json = null;
		}

		void IList.RemoveAt(int index)
		{
			EnsureList().RemoveAt(index);
			json = null;
		}

		IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
		{
			EnsureDictionary();
			return new OrderedDictionaryEnumerator(object_list.GetEnumerator());
		}

		void IOrderedDictionary.Insert(int idx, object key, object value)
		{
			string text = (string)key;
			JsonData value2 = (this[text] = ToJsonData(value));
			KeyValuePair<string, JsonData> item = new KeyValuePair<string, JsonData>(text, value2);
			object_list.Insert(idx, item);
		}

		void IOrderedDictionary.RemoveAt(int idx)
		{
			EnsureDictionary();
			inst_object.Remove(object_list[idx].Key);
			object_list.RemoveAt(idx);
		}

		private ICollection EnsureCollection()
		{
			if (type == JsonType.Array)
			{
				return (ICollection)inst_array;
			}
			if (type == JsonType.Object)
			{
				return (ICollection)inst_object;
			}
			throw new InvalidOperationException("The JsonData instance has to be initialized first");
		}

		private IDictionary EnsureDictionary()
		{
			if (type == JsonType.Object)
			{
				return (IDictionary)inst_object;
			}
			if (type != 0)
			{
				throw new InvalidOperationException("Instance of JsonData is not a dictionary");
			}
			type = JsonType.Object;
			inst_object = new Dictionary<string, JsonData>();
			object_list = new List<KeyValuePair<string, JsonData>>();
			return (IDictionary)inst_object;
		}

		private IList EnsureList()
		{
			if (type == JsonType.Array)
			{
				return (IList)inst_array;
			}
			if (type != 0)
			{
				throw new InvalidOperationException("Instance of JsonData is not a list");
			}
			type = JsonType.Array;
			inst_array = new List<JsonData>();
			return (IList)inst_array;
		}

		private JsonData ToJsonData(object obj)
		{
			if (obj == null)
			{
				return null;
			}
			if (obj is JsonData)
			{
				return (JsonData)obj;
			}
			return new JsonData(obj);
		}

		private static void WriteJson(IJsonWrapper obj, JsonWriter writer)
		{
			if (obj == null)
			{
				writer.Write(null);
			}
			else if (obj.IsString)
			{
				writer.Write(obj.GetString());
			}
			else if (obj.IsBoolean)
			{
				writer.Write(obj.GetBoolean());
			}
			else if (obj.IsDouble)
			{
				writer.Write(obj.GetDouble());
			}
			else if (obj.IsInt)
			{
				writer.Write(obj.GetInt());
			}
			else if (obj.IsLong)
			{
				writer.Write(obj.GetLong());
			}
			else if (obj.IsArray)
			{
				writer.WriteArrayStart();
				foreach (object item in (IEnumerable)obj)
				{
					WriteJson((JsonData)item, writer);
				}
				writer.WriteArrayEnd();
			}
			else
			{
				if (!obj.IsObject)
				{
					return;
				}
				writer.WriteObjectStart();
				foreach (DictionaryEntry item2 in (IDictionary)obj)
				{
					writer.WritePropertyName((string)item2.Key);
					WriteJson((JsonData)item2.Value, writer);
				}
				writer.WriteObjectEnd();
			}
		}

		public int Add(object value)
		{
			JsonData value2 = ToJsonData(value);
			json = null;
			return EnsureList().Add(value2);
		}

		public void Clear()
		{
			if (IsObject)
			{
				((IDictionary)this).Clear();
			}
			else if (IsArray)
			{
				((IList)this).Clear();
			}
		}

		public bool Equals(JsonData x)
		{
			if (x == null)
			{
				return false;
			}
			if (x.type != type)
			{
				return false;
			}
			return type switch
			{
				JsonType.None => true, 
				JsonType.Object => inst_object.Equals(x.inst_object), 
				JsonType.Array => inst_array.Equals(x.inst_array), 
				JsonType.String => inst_string.Equals(x.inst_string), 
				JsonType.Int => inst_int.Equals(x.inst_int), 
				JsonType.Long => inst_long.Equals(x.inst_long), 
				JsonType.Double => inst_double.Equals(x.inst_double), 
				JsonType.Boolean => inst_boolean.Equals(x.inst_boolean), 
				_ => false, 
			};
		}

		public JsonType GetJsonType()
		{
			return type;
		}

		public void SetJsonType(JsonType type)
		{
			if (this.type != type)
			{
				switch (type)
				{
				case JsonType.Object:
					inst_object = new Dictionary<string, JsonData>();
					object_list = new List<KeyValuePair<string, JsonData>>();
					break;
				case JsonType.Array:
					inst_array = new List<JsonData>();
					break;
				case JsonType.String:
					inst_string = null;
					break;
				case JsonType.Int:
					inst_int = 0;
					break;
				case JsonType.Long:
					inst_long = 0L;
					break;
				case JsonType.Double:
					inst_double = 0.0;
					break;
				case JsonType.Boolean:
					inst_boolean = false;
					break;
				}
				this.type = type;
			}
		}

		public string ToJson()
		{
			if (json != null)
			{
				return json;
			}
			StringWriter stringWriter = new StringWriter();
			JsonWriter jsonWriter = new JsonWriter(stringWriter);
			jsonWriter.Validate = false;
			WriteJson(this, jsonWriter);
			json = stringWriter.ToString();
			return json;
		}

		public void ToJson(JsonWriter writer)
		{
			bool validate = writer.Validate;
			writer.Validate = false;
			WriteJson(this, writer);
			writer.Validate = validate;
		}

		public override string ToString()
		{
			return type switch
			{
				JsonType.Array => "JsonData array", 
				JsonType.Boolean => inst_boolean.ToString(), 
				JsonType.Double => inst_double.ToString(), 
				JsonType.Int => inst_int.ToString(), 
				JsonType.Long => inst_long.ToString(), 
				JsonType.Object => "JsonData object", 
				JsonType.String => inst_string, 
				_ => "Uninitialized JsonData", 
			};
		}
	}
	internal class OrderedDictionaryEnumerator : IDictionaryEnumerator, IEnumerator
	{
		private IEnumerator<KeyValuePair<string, JsonData>> list_enumerator;

		public object Current => Entry;

		public DictionaryEntry Entry
		{
			get
			{
				KeyValuePair<string, JsonData> current = list_enumerator.Current;
				return new DictionaryEntry(current.Key, current.Value);
			}
		}

		public object Key => list_enumerator.Current.Key;

		public object Value => list_enumerator.Current.Value;

		public OrderedDictionaryEnumerator(IEnumerator<KeyValuePair<string, JsonData>> enumerator)
		{
			list_enumerator = enumerator;
		}

		public bool MoveNext()
		{
			return list_enumerator.MoveNext();
		}

		public void Reset()
		{
			list_enumerator.Reset();
		}
	}
	internal class JsonException : ApplicationException
	{
		public JsonException()
		{
		}

		internal JsonException(ParserToken token)
			: base($"Invalid token '{token}' in input string")
		{
		}

		internal JsonException(ParserToken token, Exception inner_exception)
			: base($"Invalid token '{token}' in input string", inner_exception)
		{
		}

		internal JsonException(int c)
			: base($"Invalid character '{(char)c}' in input string")
		{
		}

		internal JsonException(int c, Exception inner_exception)
			: base($"Invalid character '{(char)c}' in input string", inner_exception)
		{
		}

		public JsonException(string message)
			: base(message)
		{
		}

		public JsonException(string message, Exception inner_exception)
			: base(message, inner_exception)
		{
		}
	}
	internal struct PropertyMetadata
	{
		public MemberInfo Info;

		public bool IsField;

		public Type Type;
	}
	internal struct ArrayMetadata
	{
		private Type element_type;

		private bool is_array;

		private bool is_list;

		public Type ElementType
		{
			get
			{
				if (element_type == null)
				{
					return typeof(JsonData);
				}
				return element_type;
			}
			set
			{
				element_type = value;
			}
		}

		public bool IsArray
		{
			get
			{
				return is_array;
			}
			set
			{
				is_array = value;
			}
		}

		public bool IsList
		{
			get
			{
				return is_list;
			}
			set
			{
				is_list = value;
			}
		}
	}
	internal struct ObjectMetadata
	{
		private Type element_type;

		private bool is_dictionary;

		private IDictionary<string, PropertyMetadata> properties;

		public Type ElementType
		{
			get
			{
				if (element_type == null)
				{
					return typeof(JsonData);
				}
				return element_type;
			}
			set
			{
				element_type = value;
			}
		}

		public bool IsDictionary
		{
			get
			{
				return is_dictionary;
			}
			set
			{
				is_dictionary = value;
			}
		}

		public IDictionary<string, PropertyMetadata> Properties
		{
			get
			{
				return properties;
			}
			set
			{
				properties = value;
			}
		}
	}
	internal delegate void ExporterFunc(object obj, JsonWriter writer);
	internal delegate void ExporterFunc<T>(T obj, JsonWriter writer);
	internal delegate object ImporterFunc(object input);
	internal delegate TValue ImporterFunc<TJson, TValue>(TJson input);
	internal delegate IJsonWrapper WrapperFactory();
	internal class JsonMapper
	{
		private static int max_nesting_depth;

		private static IFormatProvider datetime_format;

		private static IDictionary<Type, ExporterFunc> base_exporters_table;

		private static IDictionary<Type, ExporterFunc> custom_exporters_table;

		private static IDictionary<Type, IDictionary<Type, ImporterFunc>> base_importers_table;

		private static IDictionary<Type, IDictionary<Type, ImporterFunc>> custom_importers_table;

		private static IDictionary<Type, ArrayMetadata> array_metadata;

		private static readonly object array_metadata_lock;

		private static IDictionary<Type, IDictionary<Type, MethodInfo>> conv_ops;

		private static readonly object conv_ops_lock;

		private static IDictionary<Type, ObjectMetadata> object_metadata;

		private static readonly object object_metadata_lock;

		private static IDictionary<Type, IList<PropertyMetadata>> type_properties;

		private static readonly object type_properties_lock;

		private static JsonWriter static_writer;

		private static readonly object static_writer_lock;

		static JsonMapper()
		{
			array_metadata_lock = new object();
			conv_ops_lock = new object();
			object_metadata_lock = new object();
			type_properties_lock = new object();
			static_writer_lock = new object();
			max_nesting_depth = 100;
			array_metadata = new Dictionary<Type, ArrayMetadata>();
			conv_ops = new Dictionary<Type, IDictionary<Type, MethodInfo>>();
			object_metadata = new Dictionary<Type, ObjectMetadata>();
			type_properties = new Dictionary<Type, IList<PropertyMetadata>>();
			static_writer = new JsonWriter();
			datetime_format = DateTimeFormatInfo.InvariantInfo;
			base_exporters_table = new Dictionary<Type, ExporterFunc>();
			custom_exporters_table = new Dictionary<Type, ExporterFunc>();
			base_importers_table = new Dictionary<Type, IDictionary<Type, ImporterFunc>>();
			custom_importers_table = new Dictionary<Type, IDictionary<Type, ImporterFunc>>();
			RegisterBaseExporters();
			RegisterBaseImporters();
		}

		private static void AddArrayMetadata(Type type)
		{
			if (array_metadata.ContainsKey(type))
			{
				return;
			}
			ArrayMetadata value = default(ArrayMetadata);
			value.IsArray = type.IsArray;
			if (type.GetInterface("System.Collections.IList") != null)
			{
				value.IsList = true;
			}
			PropertyInfo[] properties = type.GetProperties();
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (!(propertyInfo.Name != "Item"))
				{
					ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
					if (indexParameters.Length == 1 && indexParameters[0].ParameterType == typeof(int))
					{
						value.ElementType = propertyInfo.PropertyType;
					}
				}
			}
			lock (array_metadata_lock)
			{
				try
				{
					array_metadata.Add(type, value);
				}
				catch (ArgumentException)
				{
				}
			}
		}

		private static void AddObjectMetadata(Type type)
		{
			if (object_metadata.ContainsKey(type))
			{
				return;
			}
			ObjectMetadata value = default(ObjectMetadata);
			if (type.GetInterface("System.Collections.IDictionary") != null)
			{
				value.IsDictionary = true;
			}
			value.Properties = new Dictionary<string, PropertyMetadata>();
			PropertyInfo[] properties = type.GetProperties();
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.Name == "Item")
				{
					ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
					if (indexParameters.Length == 1 && indexParameters[0].ParameterType == typeof(string))
					{
						value.ElementType = propertyInfo.PropertyType;
					}
				}
				else
				{
					PropertyMetadata value2 = default(PropertyMetadata);
					value2.Info = propertyInfo;
					value2.Type = propertyInfo.PropertyType;
					value.Properties.Add(propertyInfo.Name, value2);
				}
			}
			FieldInfo[] fields = type.GetFields();
			foreach (FieldInfo fieldInfo in fields)
			{
				PropertyMetadata value3 = default(PropertyMetadata);
				value3.Info = fieldInfo;
				value3.IsField = true;
				value3.Type = fieldInfo.FieldType;
				value.Properties.Add(fieldInfo.Name, value3);
			}
			lock (object_metadata_lock)
			{
				try
				{
					object_metadata.Add(type, value);
				}
				catch (ArgumentException)
				{
				}
			}
		}

		private static void AddTypeProperties(Type type)
		{
			if (type_properties.ContainsKey(type))
			{
				return;
			}
			IList<PropertyMetadata> list = new List<PropertyMetadata>();
			PropertyInfo[] properties = type.GetProperties();
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (!(propertyInfo.Name == "Item"))
				{
					PropertyMetadata item = default(PropertyMetadata);
					item.Info = propertyInfo;
					item.IsField = false;
					list.Add(item);
				}
			}
			FieldInfo[] fields = type.GetFields();
			foreach (FieldInfo info in fields)
			{
				PropertyMetadata item2 = default(PropertyMetadata);
				item2.Info = info;
				item2.IsField = true;
				list.Add(item2);
			}
			lock (type_properties_lock)
			{
				try
				{
					type_properties.Add(type, list);
				}
				catch (ArgumentException)
				{
				}
			}
		}

		private static MethodInfo GetConvOp(Type t1, Type t2)
		{
			lock (conv_ops_lock)
			{
				if (!conv_ops.ContainsKey(t1))
				{
					conv_ops.Add(t1, new Dictionary<Type, MethodInfo>());
				}
			}
			if (conv_ops[t1].ContainsKey(t2))
			{
				return conv_ops[t1][t2];
			}
			MethodInfo method = t1.GetMethod("op_Implicit", new Type[1] { t2 });
			lock (conv_ops_lock)
			{
				try
				{
					conv_ops[t1].Add(t2, method);
					return method;
				}
				catch (ArgumentException)
				{
					return conv_ops[t1][t2];
				}
			}
		}

		private static object ReadValue(Type inst_type, JsonReader reader)
		{
			reader.Read();
			if (reader.Token == JsonToken.ArrayEnd)
			{
				return null;
			}
			Type underlyingType = Nullable.GetUnderlyingType(inst_type);
			Type type = underlyingType ?? inst_type;
			if (reader.Token == JsonToken.Null)
			{
				if (inst_type.IsClass || underlyingType != null)
				{
					return null;
				}
				throw new JsonException($"Can't assign null to an instance of type {inst_type}");
			}
			if (reader.Token == JsonToken.Double || reader.Token == JsonToken.Int || reader.Token == JsonToken.Long || reader.Token == JsonToken.String || reader.Token == JsonToken.Boolean)
			{
				Type type2 = reader.Value.GetType();
				if (type.IsAssignableFrom(type2))
				{
					return reader.Value;
				}
				if (custom_importers_table.ContainsKey(type2) && custom_importers_table[type2].ContainsKey(type))
				{
					ImporterFunc importerFunc = custom_importers_table[type2][type];
					return importerFunc(reader.Value);
				}
				if (base_importers_table.ContainsKey(type2) && base_importers_table[type2].ContainsKey(type))
				{
					ImporterFunc importerFunc2 = base_importers_table[type2][type];
					return importerFunc2(reader.Value);
				}
				if (type.IsEnum)
				{
					return Enum.ToObject(type, reader.Value);
				}
				MethodInfo convOp = GetConvOp(type, type2);
				if (convOp != null)
				{
					return convOp.Invoke(null, new object[1] { reader.Value });
				}
				throw new JsonException($"Can't assign value '{reader.Value}' (type {type2}) to type {inst_type}");
			}
			object obj = null;
			if (reader.Token == JsonToken.ArrayStart)
			{
				AddArrayMetadata(inst_type);
				ArrayMetadata arrayMetadata = array_metadata[inst_type];
				if (!arrayMetadata.IsArray && !arrayMetadata.IsList)
				{
					throw new JsonException($"Type {inst_type} can't act as an array");
				}
				IList list;
				Type elementType;
				if (!arrayMetadata.IsArray)
				{
					list = (IList)Activator.CreateInstance(inst_type);
					elementType = arrayMetadata.ElementType;
				}
				else
				{
					list = new ArrayList();
					elementType = inst_type.GetElementType();
				}
				while (true)
				{
					object obj2 = ReadValue(elementType, reader);
					if (obj2 == null && reader.Token == JsonToken.ArrayEnd)
					{
						break;
					}
					list.Add(obj2);
				}
				if (arrayMetadata.IsArray)
				{
					int count = list.Count;
					obj = Array.CreateInstance(elementType, count);
					for (int i = 0; i < count; i++)
					{
						((Array)obj).SetValue(list[i], i);
					}
				}
				else
				{
					obj = list;
				}
			}
			else if (reader.Token == JsonToken.ObjectStart)
			{
				AddObjectMetadata(type);
				ObjectMetadata objectMetadata = object_metadata[type];
				obj = Activator.CreateInstance(type);
				while (true)
				{
					reader.Read();
					if (reader.Token == JsonToken.ObjectEnd)
					{
						break;
					}
					string text = (string)reader.Value;
					if (objectMetadata.Properties.ContainsKey(text))
					{
						PropertyMetadata propertyMetadata = objectMetadata.Properties[text];
						if (propertyMetadata.IsField)
						{
							((FieldInfo)propertyMetadata.Info).SetValue(obj, ReadValue(propertyMetadata.Type, reader));
							continue;
						}
						PropertyInfo propertyInfo = (PropertyInfo)propertyMetadata.Info;
						if (propertyInfo.CanWrite)
						{
							propertyInfo.SetValue(obj, ReadValue(propertyMetadata.Type, reader), null);
						}
						else
						{
							ReadValue(propertyMetadata.Type, reader);
						}
					}
					else if (!objectMetadata.IsDictionary)
					{
						if (!reader.SkipNonMembers)
						{
							throw new JsonException($"The type {inst_type} doesn't have the property '{text}'");
						}
						ReadSkip(reader);
					}
					el