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.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BalrondNature.WorldEdit;
using BalrondNature.WorldEdit.Vegetation;
using BepInEx;
using BepInEx.Bootstrap;
using HarmonyLib;
using LitJson2;
using SoftReferenceableAssets;
using UnityEngine;
using UnityEngine.Events;
using UpgradeWorld;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("BalrondNature")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BalrondNature")]
[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 OfferingStation : MonoBehaviour, Hoverable, Interactable
{
	public string m_name = "Offer station";

	public string m_useItemText = "Use";

	public ItemDrop m_requiredItem;

	public int m_requiredItemAmount = 1;

	public string m_statusEffectName = "";

	public bool m_spawnStatusEffect = true;

	public GameObject m_aoePrefab;

	public GameObject m_spawnPoint = null;

	public bool m_spawnItem = false;

	public ItemDrop m_itemPrefab;

	public Transform m_itemSpawnPoint;

	public string m_setGlobalKey = "";

	public float m_SpawnDelay = 2f;

	public float m_spawnOffset = 0f;

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

	public EffectList m_spawnStartEffects = new EffectList();

	public EffectList m_spawnFinishEffects = new EffectList();

	public GameObject m_enabledObject;

	public GameObject m_disabledObject;

	public GameObject m_haveFuelObject;

	public Transform m_roofCheckPoint;

	public bool m_requiresRoof = false;

	public bool m_canBeOutside = true;

	public Switch m_addWoodSwitch;

	public bool m_useFuel = false;

	public ItemDrop m_fuelItem;

	public int m_maxFuel = 0;

	public float m_secPerFuel = 2000f;

	public bool m_requireFire = false;

	public Transform[] m_fireCheckPoints;

	public float m_fireCheckRadius = 0.25f;

	private bool m_blockedSmoke;

	public SmokeSpawner m_smokeSpawner;

	public Animator[] m_animators;

	private ZNetView m_nview;

	private string m_requiredItemName;

	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");
			return;
		}
		validateAoe();
		m_requiredItemName = m_requiredItem.m_itemData.m_shared.m_name;
		if (Object.op_Implicit((Object)(object)m_addWoodSwitch))
		{
		}
		((MonoBehaviour)this).InvokeRepeating("UpdateOfferingStation", 1f, 1f);
	}

	private bool validateAoe()
	{
		if ((Object)(object)m_aoePrefab.GetComponent<Aoe>() == (Object)null)
		{
			ZLog.Log((object)"m_aoePrefab Missing Aoe Component");
			return false;
		}
		return true;
	}

	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) + " amount: " + m_requiredItemAmount;
	}

	public string GetHoverName()
	{
		return m_name;
	}

	public bool Interact(Humanoid user, bool hold, bool alt)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		if (hold || IsSpawnQueued())
		{
			return false;
		}
		if (!PrivateArea.CheckAccess(((Component)this).transform.position, 0f, true, false))
		{
			return true;
		}
		if (m_blockedSmoke)
		{
			((Character)user).Message((MessageType)2, "Smoke blocked", 0, (Sprite)null);
			return false;
		}
		if (!IsActive())
		{
			return false;
		}
		if (Spawn(GetSpawnPosition()))
		{
			((Character)user).Message((MessageType)2, "$msg_offerdone", 0, (Sprite)null);
			if (Object.op_Implicit((Object)(object)m_itemSpawnPoint))
			{
				m_fuelAddedEffects.Create(m_itemSpawnPoint.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
			}
		}
		return true;
	}

	public bool UseItem(Humanoid user, ItemData item)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0245: Unknown result type (might be due to invalid IL or missing references)
		//IL_0250: Unknown result type (might be due to invalid IL or missing references)
		if (IsSpawnQueued())
		{
			return true;
		}
		if (!PrivateArea.CheckAccess(((Component)this).transform.position, 0f, true, false))
		{
			return true;
		}
		if (m_blockedSmoke)
		{
			((Character)user).Message((MessageType)2, "Smoke blocked", 0, (Sprite)null);
			return false;
		}
		if (!IsActive())
		{
			return false;
		}
		if ((Object)(object)m_requiredItem == (Object)null)
		{
			return false;
		}
		if (item.m_shared.m_name == m_requiredItemName)
		{
			int num = user.GetInventory().CountItems(m_requiredItemName, -1, true);
			if (num < m_requiredItemAmount)
			{
				((Character)user).Message((MessageType)2, "$msg_incompleteoffering: " + Localization.instance.Localize(m_requiredItemName) + " " + num + " / " + m_requiredItemAmount, 0, (Sprite)null);
				return true;
			}
			if (m_spawnStatusEffect && (Object)(object)m_aoePrefab == (Object)null)
			{
				Debug.LogWarning((object)"Missing Status Effect Prefab[AoE]");
				return true;
			}
			if (m_spawnItem && (Object)(object)m_itemPrefab == (Object)null)
			{
				Debug.LogWarning((object)"Missing ItemDrop Prefab");
				return true;
			}
			bool flag = false;
			if (((Object)(object)m_aoePrefab != (Object)null && m_spawnStatusEffect) || ((Object)(object)m_itemPrefab != (Object)null && m_spawnItem))
			{
				flag = Spawn(GetSpawnPosition());
			}
			if (flag)
			{
				user.GetInventory().RemoveItem(item.m_shared.m_name, m_requiredItemAmount, -1, true);
				((Character)user).ShowRemovedMessage(m_requiredItem.m_itemData, m_requiredItemAmount);
				((Character)user).Message((MessageType)2, "$msg_offerdone", 0, (Sprite)null);
				if (Object.op_Implicit((Object)(object)m_itemSpawnPoint))
				{
					m_fuelAddedEffects.Create(m_itemSpawnPoint.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
				}
				if (!string.IsNullOrEmpty(m_setGlobalKey))
				{
					ZoneSystem.instance.SetGlobalKey(m_setGlobalKey);
				}
			}
			return flag;
		}
		((Character)user).Message((MessageType)2, "$msg_offerwrong", 0, (Sprite)null);
		return true;
	}

	public bool IsActive()
	{
		return (m_maxFuel == 0 || (double)GetFuel() > 0.0) && !m_blockedSmoke;
	}

	private void UpdateGameObjectState()
	{
		bool flag = IsActive();
		m_enabledObject.SetActive(flag);
		if (Object.op_Implicit((Object)(object)m_disabledObject))
		{
			m_disabledObject.SetActive(!flag);
		}
		if (Object.op_Implicit((Object)(object)m_haveFuelObject))
		{
			m_haveFuelObject.SetActive((double)GetFuel() > 0.0);
		}
		SetAnimation(flag);
	}

	private void SetAnimation(bool active)
	{
		Animator[] animators = m_animators;
		foreach (Animator val in animators)
		{
			if (((Component)val).gameObject.activeInHierarchy)
			{
				val.SetBool("active", active);
				val.SetFloat("activef", active ? 1f : 0f);
			}
		}
	}

	private float GetDeltaTime()
	{
		DateTime time = ZNet.instance.GetTime();
		DateTime dateTime = new DateTime(m_nview.GetZDO().GetLong("StartTime", time.Ticks));
		double totalSeconds = (time - dateTime).TotalSeconds;
		m_nview.GetZDO().Set("StartTime", time.Ticks);
		return (float)totalSeconds;
	}

	private void UpdateFuel(float dt)
	{
		if (m_useFuel)
		{
			float num = dt / m_secPerFuel;
			float num2 = GetFuel() - num;
			if ((double)num2 < 0.0)
			{
				num2 = 0f;
			}
			SetFuel(num2);
		}
	}

	private void RPC_AddFuel(long sender)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		if (m_nview.IsOwner())
		{
			SetFuel(GetFuel() + 1f);
			m_fuelAddedEffects.Create(((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform, 1f, -1);
		}
	}

	private void UpdateOfferingStation()
	{
		if (m_nview.IsValid())
		{
		}
	}

	private Vector3 GetSpawnPosition()
	{
		//IL_0026: 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_spawnPoint != (Object)null) ? m_spawnPoint.transform.position : ((Component)this).transform.position;
	}

	private bool Spawn(Vector3 point)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		m_spawnStartEffects.Create(point, Quaternion.identity, (Transform)null, 1f, -1);
		((MonoBehaviour)this).Invoke("DelayedSpawn", m_SpawnDelay);
		return true;
	}

	private void UpdateSmoke()
	{
		if ((Object)(object)m_smokeSpawner != (Object)null)
		{
			m_blockedSmoke = m_smokeSpawner.IsBlocked();
		}
		else
		{
			m_blockedSmoke = false;
		}
	}

	private float GetFuel()
	{
		return m_nview.GetZDO().GetFloat("fuel", 0f);
	}

	private void SetFuel(float fuel)
	{
		m_nview.GetZDO().Set("fuel", fuel);
	}

	private bool OnAddFuel(Switch sw, Humanoid user, ItemData item)
	{
		if (!m_useFuel)
		{
			((Character)user).Message((MessageType)2, "No fuel required", 0, (Sprite)null);
			return false;
		}
		if (item != null && item.m_shared.m_name != m_fuelItem.m_itemData.m_shared.m_name)
		{
			((Character)user).Message((MessageType)2, "$msg_wrongitem", 0, (Sprite)null);
			return false;
		}
		if (!user.GetInventory().HaveItem(m_fuelItem.m_itemData.m_shared.m_name, true))
		{
			((Character)user).Message((MessageType)2, "$msg_donthaveany " + m_fuelItem.m_itemData.m_shared.m_name, 0, (Sprite)null);
			return false;
		}
		((Character)user).Message((MessageType)2, "$msg_added " + m_fuelItem.m_itemData.m_shared.m_name, 0, (Sprite)null);
		user.GetInventory().RemoveItem(m_fuelItem.m_itemData.m_shared.m_name, 1, -1, true);
		m_nview.InvokeRPC("AddFuel", Array.Empty<object>());
		return true;
	}

	private bool IsSpawnQueued()
	{
		return ((MonoBehaviour)this).IsInvoking("DelayedSpawn");
	}

	private void DelayedSpawn()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		if (m_spawnStatusEffect)
		{
			Aoe component = Object.Instantiate<GameObject>(m_aoePrefab, GetSpawnPosition(), Quaternion.identity).GetComponent<Aoe>();
			component.m_statusEffect = m_statusEffectName;
		}
		if (m_spawnItem)
		{
			Object.Instantiate<GameObject>(((Component)m_itemPrefab).gameObject, GetSpawnPosition(), Quaternion.identity);
		}
		m_spawnFinishEffects.Create(GetSpawnPosition(), Quaternion.identity, (Transform)null, 1f, -1);
	}
}
namespace UpgradeWorld
{
	public class CommandRegistration
	{
		public string name = "";

		public string description = "";

		public string[] commands = new string[0];

		public void AddCommand()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			new ConsoleCommand(name, description, (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				string[] array = commands;
				foreach (string text in array)
				{
					args.Context.TryRunCommand(text, false, false);
				}
			}, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}
	}
	[HarmonyPatch(typeof(Terminal), "InitTerminal")]
	public static class Upgrade
	{
		private static List<CommandRegistration> registrations = new List<CommandRegistration>();

		public const string GUID = "upgrade_world";

		public static void Register(string name, string description, params string[] commands)
		{
			if (Chainloader.PluginInfos.ContainsKey("upgrade_world"))
			{
				registrations.Add(new CommandRegistration
				{
					name = name,
					description = description,
					commands = commands
				});
			}
		}

		private static void Postfix()
		{
			foreach (CommandRegistration registration in registrations)
			{
				registration.AddCommand();
			}
		}
	}
}
namespace BalrondNature
{
	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)
		{
			if (string.IsNullOrEmpty(language))
			{
				return null;
			}
			if (translations.TryGetValue(language, out var value))
			{
				return value;
			}
			return null;
		}
	}
	public static class BoonManager
	{
		public static readonly List<BoonObject> boons = new List<BoonObject>();

		private static Dictionary<string, GameObject> _itemCache = new Dictionary<string, GameObject>();

		private const string BoonDataKey = "BalrondAnimalBoon";

		public static void setup()
		{
			boons.Clear();
			createboons();
		}

		public static StatusEffect getStatusForBoon(string boonName)
		{
			return FindBoon(boonName)?.status;
		}

		public static string getMsgForBoon(string boonName)
		{
			BoonObject boonObject = FindBoon(boonName);
			return (boonObject != null) ? boonObject.msg : "Behold the Power";
		}

		public static EffectList getVfxForBoon(string boonName)
		{
			return FindBoon(boonName)?.boonEffects;
		}

		public static GameObject getBoonItem(string boonName)
		{
			return FindBoon(boonName)?.item;
		}

		public static void SetBoon(string boonName)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				RemoveBoon(localPlayer.m_customData["BalrondAnimalBoon"]);
				localPlayer.m_customData["BalrondAnimalBoon"] = boonName;
				Loadboonstatus();
			}
		}

		public static void Loadboonstatus()
		{
			Player localPlayer = Player.m_localPlayer;
			if (HasBoon(localPlayer))
			{
				string boonName = localPlayer.m_customData["BalrondAnimalBoon"];
				StatusEffect statusForBoon = getStatusForBoon(boonName);
				if ((Object)(object)statusForBoon != (Object)null && (Object)(object)((Character)localPlayer).GetSEMan().GetStatusEffect(((object)statusForBoon).GetHashCode()) == (Object)null)
				{
					((Character)localPlayer).GetSEMan().AddStatusEffect(statusForBoon, false, 0, 0f);
				}
			}
		}

		public static bool HasBoon(Player player)
		{
			if ((Object)(object)player == (Object)null || !player.m_customData.ContainsKey("BalrondAnimalBoon"))
			{
				Debug.Log((object)"Player has no boon assigned");
				return false;
			}
			return true;
		}

		public static void RemoveBoon(string boonName)
		{
			Player localPlayer = Player.m_localPlayer;
			if (HasBoon(localPlayer))
			{
				((Character)localPlayer).GetSEMan().RemoveStatusEffect(boonName.GetHashCode(), false);
			}
		}

		private static void createboons()
		{
			AddBoon("Serpent", "TrophySerpent", "BuffSerpent_bal", "sfx_serpentBoonCall_bal", "$tag_clanserpent_bal_status");
			AddBoon("Drake", "TrophyHatchling", "BuffDrake_bal", "sfx_drakeBoonCall_bal", "$tag_clandrake_bal_status");
			AddBoon("Stag", "TrophyDeer", "BuffDeer_bal", "sfx_deerBoonCall_bal", "$tag_clandeer_bal_status");
			AddBoon("Wolf", "TrophyWolf", "BuffWolf_bal", "sfx_wolfBoonCall_bal", "$tag_clanwolf_bal_status");
			AddBoon("Lox", "TrophyLox", "BuffLox_bal", "sfx_loxBoonCall_bal", "$tag_clanlox_bal_status");
			AddBoon("Leech", "TrophyLeech", "BuffLeech_bal", "sfx_leechBoonCall_bal", "$tag_clanleech_bal_status");
			AddBoon("Crow", "TrophyCrow_bal", "BuffCrow_bal", "sfx_crowBoonCall_bal", "$tag_clancrow_bal_status");
			AddBoon("Fox", "TrophyFox_bal", "BuffFox_bal", "sfx_foxBoonCall_bal", "$tag_clanfox_bal_status");
			AddBoon("Bear", "TrophyBear_bal", "BuffBear_bal", "sfx_bearBoonCall_bal", "$tag_clanbear_bal_status");
			AddBoon("Boar", "TrophyBoar", "BuffBoar_bal", "sfx_boarBoonCall_bal", "$tag_clanboar_bal_status");
		}

		private static void AddBoon(string name, string itemName, string statusname, string effectName = "", string message = "Blessed by the Gods")
		{
			GameObject sfx = Launch.modResourceLoader.vfxPrefabs.Find((GameObject x) => ((Object)x).name == effectName);
			BoonObject item = new BoonObject
			{
				boonName = name,
				item = FindItem(itemName),
				status = FindStatus(statusname),
				sfx = sfx,
				msg = message
			};
			boons.Add(item);
		}

		private static StatusEffect FindStatus(string name)
		{
			StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect(name.GetHashCode());
			if ((Object)(object)statusEffect == (Object)null)
			{
				Debug.LogWarning((object)("FindStatus: \"" + name + "\" not found, using fallback \"Wet\""));
				statusEffect = ObjectDB.instance.GetStatusEffect("Wet".GetHashCode());
			}
			return statusEffect;
		}

		private static GameObject FindItem(string name)
		{
			if (_itemCache.TryGetValue(name, out var value))
			{
				return value;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(name);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				Debug.LogWarning((object)("FindItem: \"" + name + "\" not found, using fallback \"Wood\""));
				itemPrefab = ObjectDB.instance.GetItemPrefab("Wood");
			}
			if ((Object)(object)itemPrefab != (Object)null)
			{
				_itemCache[name] = itemPrefab;
			}
			return itemPrefab;
		}

		private static BoonObject FindBoon(string name)
		{
			return boons.Find((BoonObject x) => x.boonName == name);
		}

		private static EffectList createEffectListFromObject(GameObject gameObject)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			EffectList val = new EffectList();
			List<EffectData> list = new List<EffectData>
			{
				new EffectData
				{
					m_prefab = gameObject
				}
			};
			val.m_effectPrefabs = list.ToArray();
			return val;
		}
	}
	public class BoonObject
	{
		public string boonName;

		public string msg;

		public StatusEffect status;

		public GameObject item;

		public GameObject sfx;

		public EffectList boonEffects = new EffectList();
	}
	public class BoonTotem : MonoBehaviour, Interactable, Hoverable
	{
		private ZNetView m_nview;

		private string chosenBoon = string.Empty;

		private string m_name = "$tag_boon_totem_bal";

		public MeshRenderer m_mesh;

		public Transform m_transformAttach;

		public int m_emissiveMaterialIndex;

		public Color m_activeEmissiveColor = Color.white;

		private bool m_active;

		public string m_completedMessage = "";

		public List<ItemType> m_supportedTypes = new List<ItemType>();

		public GameObject m_activeEffect;

		public EffectList m_activateStep1 = new EffectList();

		public EffectList m_activateStep2 = new EffectList();

		public EffectList m_activateStep3 = new EffectList();

		private void Awake()
		{
			m_nview = ((Component)this).GetComponent<ZNetView>();
			if (!((Object)(object)m_nview == (Object)null) && m_nview.IsValid())
			{
				WearNTear component = ((Component)this).GetComponent<WearNTear>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.m_onDestroyed = (Action)Delegate.Combine(component.m_onDestroyed, new Action(OnDestroyed));
				}
				m_supportedTypes.Clear();
				m_supportedTypes.Add((ItemType)13);
				m_nview.Register<string>("UseBuffTotem", (Action<long, string>)UseBuffTotem);
				chosenBoon = m_nview.m_zdo.GetString("Boon", "");
				SetVisuals(chosenBoon);
			}
		}

		private void OnDestroyed()
		{
			if (m_nview.IsOwner())
			{
			}
		}

		private void Start()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (((Renderer)m_mesh).materials[m_emissiveMaterialIndex].HasProperty("_EmissionColor"))
			{
				((Renderer)m_mesh).materials[m_emissiveMaterialIndex].SetColor("_EmissionColor", Color.black);
			}
			if (Object.op_Implicit((Object)(object)m_activeEffect))
			{
				m_activeEffect.SetActive(false);
			}
			SetActivated(!string.IsNullOrEmpty(chosenBoon), triggerEffect: false);
			((MonoBehaviour)this).InvokeRepeating("UpdateVisual", 1f, 2f);
		}

		private void SetActivated(bool active, bool triggerEffect)
		{
			if (active == m_active)
			{
				return;
			}
			m_active = active;
			if (triggerEffect && active)
			{
				((MonoBehaviour)this).Invoke("DelayedAttachEffects_Step1", 1f);
				((MonoBehaviour)this).Invoke("DelayedAttachEffects_Step2", 5f);
				((MonoBehaviour)this).Invoke("DelayedAttachEffects_Step3", 11f);
				return;
			}
			if (Object.op_Implicit((Object)(object)m_activeEffect))
			{
				m_activeEffect.SetActive(active);
			}
			((MonoBehaviour)this).StopCoroutine("FadeEmission");
			((MonoBehaviour)this).StartCoroutine("FadeEmission");
		}

		private void DelayedAttachEffects_Step1()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			m_activateStep1.Create(m_transformAttach.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
		}

		private void DelayedAttachEffects_Step2()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			m_activateStep2.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
		}

		private void DelayedAttachEffects_Step3()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)m_activeEffect))
			{
				m_activeEffect.SetActive(true);
			}
			m_activateStep3.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
			((MonoBehaviour)this).StopCoroutine("FadeEmission");
			((MonoBehaviour)this).StartCoroutine("FadeEmission");
			Player.MessageAllInRange(((Component)this).transform.position, 20f, (MessageType)2, m_completedMessage, (Sprite)null);
		}

		private IEnumerator FadeEmission()
		{
			if (Object.op_Implicit((Object)(object)m_mesh) && ((Renderer)m_mesh).materials[m_emissiveMaterialIndex].HasProperty("_EmissionColor"))
			{
				Color startColor = ((Renderer)m_mesh).materials[m_emissiveMaterialIndex].GetColor("_EmissionColor");
				Color targetColor = (m_active ? m_activeEmissiveColor : Color.black);
				for (float t = 0f; (double)t < 1.0; t += Time.deltaTime)
				{
					((Renderer)m_mesh).materials[m_emissiveMaterialIndex].SetColor("_EmissionColor", Color.Lerp(startColor, targetColor, t / 1f));
					yield return null;
				}
			}
			ZLog.Log((object)"Done fading color");
		}

		public bool IsActivated()
		{
			return m_active;
		}

		private void UseBuffTotem(long sender, string boonName)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (!m_nview.IsOwner())
			{
				SetVisuals(boonName);
				return;
			}
			Debug.Log((object)("Chosen boon: " + boonName));
			chosenBoon = boonName;
			m_nview.m_zdo.Set("Boon", boonName);
			EffectList vfxForBoon = BoonManager.getVfxForBoon(boonName);
			if (vfxForBoon != null)
			{
				vfxForBoon.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
			}
			SetVisuals(boonName);
		}

		private void SetVisuals(string boon)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			if (string.IsNullOrEmpty(boon))
			{
				return;
			}
			Transform val = ((Component)this).transform.Find("Items");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			foreach (Transform item in val)
			{
				Transform val2 = item;
				((Component)val2).gameObject.SetActive(false);
			}
			Transform val3 = val.Find(boon);
			if ((Object)(object)val3 != (Object)null)
			{
				((Component)val3).gameObject.SetActive(true);
			}
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(chosenBoon))
			{
				chosenBoon = m_nview.m_zdo.GetString("Boon", "");
			}
			if (!string.IsNullOrEmpty(chosenBoon))
			{
				if (!m_nview.IsOwner())
				{
					m_nview.InvokeRPC("RequestOwn", Array.Empty<object>());
				}
				string msgForBoon = BoonManager.getMsgForBoon(chosenBoon);
				MessageHud.instance.ShowMessage((MessageType)2, Localization.instance.Localize(msgForBoon), 0, (Sprite)null, false);
				BoonManager.SetBoon(chosenBoon);
				EffectList vfxForBoon = BoonManager.getVfxForBoon(chosenBoon);
				if (vfxForBoon != null)
				{
					vfxForBoon.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
				}
				return true;
			}
			MessageHud.instance.ShowMessage((MessageType)2, Localization.instance.Localize("$tag_totemnodiety_bal"), 0, (Sprite)null, false);
			return false;
		}

		private void RPC_RequestOwn(long sender)
		{
			if (m_nview.IsOwner())
			{
				m_nview.GetZDO().SetOwner(sender);
			}
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			if (string.IsNullOrEmpty(chosenBoon))
			{
				chosenBoon = m_nview.m_zdo.GetString("Boon", "");
			}
			if (!string.IsNullOrEmpty(chosenBoon))
			{
				return false;
			}
			if (!Player.m_debugMode && !Terminal.m_cheat)
			{
				return false;
			}
			if (!m_nview.IsOwner())
			{
				m_nview.InvokeRPC("RequestOwn", Array.Empty<object>());
			}
			foreach (BoonObject boon in BoonManager.boons)
			{
				if (boon == null || (Object)(object)boon.item == (Object)null || item == null || (Object)(object)item.m_dropPrefab == (Object)null || !(((Object)boon.item).name == ((Object)item.m_dropPrefab).name))
				{
					continue;
				}
				Debug.Log((object)("Found Boon: " + boon.boonName));
				m_nview.InvokeRPC(ZNetView.Everybody, "UseBuffTotem", new object[1] { boon.boonName });
				user.m_inventory.RemoveOneItem(item);
				return true;
			}
			return false;
		}

		public string GetHoverText()
		{
			string text = ((!string.IsNullOrEmpty(m_nview.m_zdo.GetString("Boon", ""))) ? "\n[<color=yellow><b>$KEY_Use</b></color>] $tag_usetotem_bal" : string.Empty);
			return Localization.instance.Localize("[<color=yellow><b>1-8</b></color>] $tag_setboon_bal") + text;
		}

		public string GetHoverName()
		{
			return Localization.instance.Localize(m_name + " [" + chosenBoon + "]");
		}
	}
	internal class ClutterList
	{
		public static string[] clutter = new string[104]
		{
			"RedSeaweed1", "RedSeaweed2", "RedSeaweed3", "redGrass_bal", "small_rock1_deepnorth_bal", "small_rock2_deepnorth_bal", "small_rock1_bal", "small_rock2_bal", "ormbunke_bal", "magicGrass1",
			"magicGrass2", "DesertPlant6_1", "DesertPlant6_2", "DesertPlant6_3", "StalagmiteFloor_1", "StalagmiteFloor_2", "StalagmiteFloor_3", "StalagmiteFloor_4", "Mushroom_52", "Mushroom_51",
			"iceweed1", "iceweed2", "iceweed3", "iceweed4", "Mushroom_6G3", "Mushroom_6G2", "Mushroom_3G1", "Mushroom_3G2", "Mushroom_3G3", "Mushroom_31",
			"Mushroom_32", "Mushroom_33", "Mushroom_34", "Mushroom_35", "IvyLowerF1", "IvyLowerF2", "IvyLowerF3", "mistlandsBush6", "PlantG6", "PlantG7",
			"PlantG8", "seaBush10", "seaBush11", "seaBush6", "seaBush8", "seaBush9", "Seaweed2_1", "Seaweed2_2", "Seaweed2_3", "AshGrass1",
			"AshGrass2", "AshGrass3", "DeepNorthGrass", "DesertPlantsGrassCurl_1", "DesertPlantsGrassCurl_2", "DesertPlantsGrassCurl_3", "Coral1_Bowl_1", "Coral1_Bowl_2", "CoralTussocks1_1", "CoralTussocks1_2",
			"CoralTussocks1_G1", "SeaweedAshlands1", "SeaweedAshlands2", "SeaweedAshlands3", "Tentacles1", "Tentacles2", "Tentacles3", "plant_dn1", "plant_dn2", "plant_dn3",
			"plant_dn4", "plant_dn5", "plant_dn6", "Coral4_G1", "Coral4_G2", "Coral_dn1", "Coral_dn2", "Coral_dn3", "Coral_dn4", "PlantG17_1",
			"PlantG17_1_F", "PlantG17_2", "PlantG17_2_F", "PlantG_19", "PlantGS4_1", "PlantFlowerF7_1", "PlantFlowerF7_2", "PlantFlowerF7_3", "PlantFlowerS8_1", "PlantFlower2_1",
			"PlantFlower2_2", "PlantFlower2_3", "Swampy1", "Swampy2", "Swampy3", "Swampy4", "Swampy5", "Swampy6", "Swampy7", "Swampy8",
			"Swampy9", "Swampy10", "Swampy11", "Swampy12"
		};
	}
	public class ConversionChanges
	{
		private enum ConversionType
		{
			smelter,
			fermenter,
			cooking,
			balrondConverter
		}

		private List<GameObject> buildPieces = new List<GameObject>();

		private List<GameObject> items = new List<GameObject>();

		public static List<TutorialText> m_texts = new List<TutorialText>();

		private static readonly string[] buildPieceNames = new string[18]
		{
			"portal_wood", "piece_workbench", "forge", "blackforge", "piece_magetable", "piece_artisanstation", "piece_stonecutter", "piece_banner01", "piece_banner02", "piece_banner03",
			"piece_banner04", "piece_banner05", "piece_banner06", "piece_banner07", "piece_banner08", "piece_banner09", "piece_banner10", "piece_banner11"
		};

		private string[] convertToBits = new string[41]
		{
			"WillowSeeds_bal", "WillowBark_bal", "YewBark_bal", "WoodNails_bal", "WaterLilySeeds_bal", "SwampTreeSeeds_bal", "Straw_bal", "StrawSeeds_bal", "Snowleaf_bal", "StrawThread_bal",
			"RedwoodSeeds_bal", "Plantain_bal", "PoplarSeeds_bal", "Peningar_bal", "Sage_bal", "Lavender_bal", "Mint_bal", "OilBase_bal", "Oil_bal", "Nettle_bal",
			"Moss_bal", "Mugwort_bal", "MushroomIcecap_bal", "MushroomInkcap_bal", "Iceberry_bal", "Ignicap_bal", "GarlicSeeds_bal", "Garlic_bal", "CypressSeeds_bal", "CabbageLeaf_bal",
			"CabbageSeeds_bal", "Cabbage_bal", "BirdFeed_bal", "Blackberries_bal", "AppleSeeds_bal", "BasicSeed_bal", "AcaiSeeds_bal", "MapleSeeds_bal", "WaterLily_bal", "Yarrow_bal",
			"MeatScrap_bal"
		};

		private string[] convertToCoal = new string[204]
		{
			"ClayBrickMold_bal", "AcidSludge_bal", "AncientRelic_bal", "AppleVinegar_bal", "Apple_bal", "BatWingCooked_bal", "BatWing_bal", "BearFur_bal", "BeltForester_bal", "BeltMountaineer_bal",
			"BeltSailor_bal", "BlackMetalCultivator_bal", "BlackMetalHoe_bal", "BlackSkin_bal", "BlackTissue_bal", "Bloodfruit_bal", "Bloodshard_bal", "BoarHide_bal", "BoraxCrystal_bal", "BundleBaseItem_bal",
			"BundleHut_bal", "CarvedCarcass_bal", "CarvedDeerSkull_bal", "CeramicMold_bal", "Cheese_bal", "CabbageSoup_bal", "ClamMeat_bal", "ClayBrick_bal", "ClayPot_bal", "Clay_bal",
			"CoalPowder_bal", "CookedCrowMeat_bal", "CookedDragonRibs_bal", "CorruptedEitr_bal", "CrabLegsCooked_bal", "CrabLegs_bal", "CrystalWood_bal", "CultInsignia_bal", "CursedBone_bal", "Darkbul_bal",
			"DeadEgo_bal", "DragonSoul_bal", "DrakeMeatCooked_bal", "DrakeMeat_bal", "DrakeSkin_bal", "DyeKit_bal", "EmberWood_bal", "EnrichedEitr_bal", "EnrichedSoil_bal", "FenringInsygnia_bal",
			"FenringMeatCooked_bal", "FenringMeat_bal", "FireGland_bal", "FishWrapsUncooked_bal", "ForsakenHeart_bal", "FoxFur_bal", "CarvedWood_bal", "WispCore_bal", "GoatMeatCooked_bal", "GoatMeat_bal",
			"GrayMushroom_bal", "GrilledCheese_bal", "HammerBlackmetal_bal", "HammerDverger_bal", "HammerIron_bal", "HammerMythic_bal", "HardWood_bal", "HelmetCrown_bal", "InfusedCarapace_bal", "JotunFinger_bal",
			"JuteThread_bal", "KingMug_bal", "MagmaStone_bal", "MeadBase_bal", "MedPack_bal", "MincedMeat_bal", "NeckSkin_bal", "NorthernFur_bal", "NumbMeal_bal", "PatchworkAsk_bal",
			"PatchworkBoar_bal", "PatchworkDeer_bal", "PatchworkLox_bal", "PatchworkTroll_bal", "PatchworkWolf_bal", "PickaxeFlametal_bal", "RawCrowMeat_bal", "RawDragonRibs_bal", "RawSilkScrap_bal", "RawSilk_bal",
			"RawSteak_bal", "RedKelp_bal", "RefinedOil_bal", "Sapphire_bal", "SawBlade_bal", "Seaberries_bal", "SeekerBrain_bal", "SerpentEgg_bal", "SharkMeatCooked_bal", "SharkMeat_bal",
			"SilkReinforcedThread_bal", "SmallBloodSack_bal", "SoulCore_bal", "SpiceSet_bal", "SpiritShard_bal", "SteakCooked_bal", "StormScale_bal", "TarBase_bal", "ThornHeart_bal", "ThunderGland_bal",
			"TormentedSoul_bal", "TrollMeatCooked_bal", "TrollMeat_bal", "WatcherHeart_bal", "SurtlingCoreCasing_bal", "ApplePieUncooked_bal", "ApplePie_bal", "AshlandCurry_bal", "BlackBerryJuice_bal", "BloodfruitSoup_bal",
			"BloodyBearJerky_bal", "BloodyCreamPie_bal", "BloodyVial_bal", "BlueberryPieUncooked_bal", "BlueberryPie_bal", "Breakfast_bal", "Burger_bal", "ChickenMarsala_bal", "ChickenNuggets_bal", "DragonfireBarbecue_bal",
			"FishSkewer_bal", "FruitPunch_bal", "FruitSalad_bal", "GrilledShrooms_bal", "HappyMeal_bal", "HoneyGlazedApple_bal", "IceBerryPancake_bal", "KingsJam_bal", "Liverwurst_bal", "MagmaCoctail_bal",
			"MeadBaseWhiteCheese_bal", "SeaFoodPlatter_bal", "SpicyBurger_bal", "SpiecedDrakeChop_bal", "SurstrommingBase_bal", "Surstromming_bal", "SwampSkause_bal", "VegetablePuree_bal", "VegetableSoup_bal", "WhiteCheese_bal",
			"WinterStew_bal", "CarrotFries_bal", "PowderedSalt_bal", "PowderedPepper_bal", "BundlePortal_bal", "BundlePortalStone_bal", "HelmetLeatherCap_bal", "HelmetBronzeHorned_bal", "BlackBerryJuiceBase_bal", "MagmaCoctailBase_bal",
			"FruitPunchBase_bal", "VineBerryJuice_bal", "VineBerryJuiceBase_bal", "RostedTrollBits_bal", "RoastedFish_bal", "CabbageWrapDrake_bal", "Cotlet_bal", "RedStew_bal", "GoatStew_bal", "CrustedMeat_bal",
			"MeatBalls_bal", "MeatRoll_bal", "MagnaTarta_bal", "ShrededMeat_bal", "MincedFenringStew_bal", "CarrotCrowSalad_bal", "Bulion_bal", "CookedMeatScrap_bal", "WoodBucket_bal", "BeltVidar_bal",
			"BeltAssasin_bal", "TrophyBattleHog_bal", "TrophyBear_bal", "TrophyGoat_bal", "TrophyNeckBrute_bal", "TrophyObsidianCrab_bal", "TrophyShark_bal", "TrophySouling_bal", "TrophyCorpseCollector_bal", "TrophyForsaken_bal",
			"TrophyGreywatcher_bal", "TrophyHaugbui_bal", "TrophySpectre_bal", "TrophyStormdrake_bal", "TrophyTrollAshlands_bal", "TrophyTrollSkeleton_bal", "TrophyStag_bal", "TrophyPolarBear_bal", "TrophyLeechPrimal_bal", "TrophyStagGhost_bal",
			"Larva_bal", "WaterJugEmpty_bal", "SwordFakeSilver_Bal", "MaceFakeSilver_bal"
		};

		private string[] arrowsNbolts = new string[10] { "BoltBlunt_bal", "BoltChitin_bal", "BoltFire_bal", "BoltSilver_bal", "BoltThunder_bal", "ArrowBlizzard_bal", "ArrowBlunt_bal", "ArrowBone_bal", "ArrowChitin_bal", "ArrowFlametal_bal" };

		public void editBuidlPieces(List<GameObject> allPrefabs)
		{
			buildPieces = allPrefabs;
			items = allPrefabs;
			editFermenter();
			editOven();
			editKiln();
			editWHeel();
			editSap();
			editBeehive();
			editSmelter();
			editPress();
			editComposter();
			editFurnace();
			editRefinery();
			editCooking();
			editIronCooking();
			editIncinerator();
			EditRecipes();
		}

		private void EditRecipes()
		{
			string[] array = buildPieceNames;
			foreach (string name in array)
			{
				GameObject val = FindBuildPiece(name);
				if ((Object)(object)val != (Object)null)
				{
					ModifyBuildPiece(val);
				}
			}
		}

		private void ModifyBuildPiece(GameObject piece)
		{
			string name = ((Object)piece).name;
			string text = name;
			switch (text)
			{
			case "forge":
			case "piece_workbench":
			case "blackforge":
			case "piece_magetable":
			case "piece_artisanstation":
			case "piece_stonecutter":
				SetCraftingStationRequiresRoof(piece, requireRoof: false);
				return;
			}
			if (text.StartsWith("piece_banner"))
			{
				SetBannerRecipe(piece);
			}
		}

		private void SetCraftingStationRequiresRoof(GameObject piece, bool requireRoof)
		{
			CraftingStation component = piece.GetComponent<CraftingStation>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_craftRequireRoof = requireRoof;
			}
		}

		private void SetBannerRecipe(GameObject piece)
		{
			Piece component = piece.GetComponent<Piece>();
			component.m_resources = (Requirement[])(object)new Requirement[4]
			{
				CreateRequirement("DyeKit_bal", 1),
				CreateRequirement("FineWood", 2),
				CreateRequirement("LeatherScraps", 3),
				CreateRequirement("StrawThread_bal", 3)
			};
		}

		private Requirement CreateRequirement(string itemName, int amount)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			return new Requirement
			{
				m_resItem = FindItem(itemName).GetComponent<ItemDrop>(),
				m_amount = amount,
				m_amountPerLevel = 0,
				m_recover = true
			};
		}

		private GameObject FindBuildPiece(string name)
		{
			return ((IEnumerable<GameObject>)buildPieces).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name == name));
		}

		private GameObject FindItem(string name)
		{
			if (items == null)
			{
				items = ZNetScene.instance.m_prefabs;
			}
			GameObject val = ((IEnumerable<GameObject>)items).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name == name));
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Debug.LogWarning((object)("Item Not Found - " + name + ", Replaced With Wood"));
			return ((IEnumerable<GameObject>)items).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name == "Wood"));
		}

		private void removeConversionFromSmelter(string fromItem, List<ItemConversion> list)
		{
			if (list.Count != 0)
			{
				list.RemoveAll((ItemConversion x) => x == null);
				list.RemoveAll((ItemConversion x) => (Object)(object)x.m_from == (Object)null);
				list.RemoveAll((ItemConversion x) => x.m_from.m_itemData == null);
				list.RemoveAll((ItemConversion x) => (Object)(object)x.m_from.m_itemData.m_dropPrefab == (Object)null);
				list.RemoveAll((ItemConversion x) => ((Object)x.m_from.m_itemData.m_dropPrefab).name == fromItem);
			}
		}

		private Requirement createReq(string name, int amount, int amountPerLevel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			Requirement val = new Requirement();
			val.m_recover = true;
			ItemDrop component = FindItem(name).GetComponent<ItemDrop>();
			val.m_resItem = component;
			val.m_amount = amount;
			val.m_amountPerLevel = amountPerLevel;
			return val;
		}

		public void editLeatherRack(BalrondConverter leatherRack = null)
		{
			if (buildPieces != null && (Object)(object)leatherRack == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_leatherRack_bal");
				leatherRack = val.GetComponent<BalrondConverter>();
			}
			leatherRack.m_conversion.Clear();
			leatherRack.m_conversion = new List<BalrondConverter.ItemConversion>();
			addConversion(((Component)leatherRack).gameObject, "PatchworkDeer_bal", "DeerHide", ConversionType.balrondConverter, 30, 2);
			addConversion(((Component)leatherRack).gameObject, "PatchworkBoar_bal", "BoarHide_bal", ConversionType.balrondConverter, 30, 2);
			addConversion(((Component)leatherRack).gameObject, "PatchworkTroll_bal", "TrollHide", ConversionType.balrondConverter, 30, 2);
			addConversion(((Component)leatherRack).gameObject, "PatchworkWolf_bal", "WolfPelt", ConversionType.balrondConverter, 30, 2);
			addConversion(((Component)leatherRack).gameObject, "PatchworkLox_bal", "LoxPelt", ConversionType.balrondConverter, 30, 2);
			addConversion(((Component)leatherRack).gameObject, "PatchworkAsk_bal", "AskHide", ConversionType.balrondConverter, 30, 2);
		}

		public void editRefinery(Smelter refinery = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)refinery == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "eitrrefinery");
				refinery = val.GetComponent<Smelter>();
			}
			if (refinery.m_maxFuel == 20)
			{
				refinery.m_maxFuel = 60;
			}
			if (refinery.m_maxOre == 20)
			{
				refinery.m_maxOre = 60;
			}
			if (refinery.m_secPerProduct == 40f)
			{
				refinery.m_secPerProduct = 60f;
			}
			text += addConversion(((Component)refinery).gameObject, "Oil_bal", "RefinedOil_bal", ConversionType.smelter);
			text += addConversion(((Component)refinery).gameObject, "BlackTissue_bal", "CorruptedEitr_bal", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)refinery).gameObject, text);
		}

		public void editComposter(Smelter composter = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)composter == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "composter_bal");
				composter = val.GetComponent<Smelter>();
			}
			if (composter.m_conversion == null)
			{
				composter.m_conversion = new List<ItemConversion>();
			}
			addConversion(((Component)composter).gameObject, "TrophyFox_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyHabrok_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyHabrokBirb_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyCrow_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGreywatcher_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySouling_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyCorpseCollector_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBear_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyForsaken_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoat_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyHaugbui_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyNeckBrute_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyObsidianCrab_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySpectre_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyStormdrake_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyShark_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyAbomination", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBlob", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBoar", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBonemass", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyCultist", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDeathsquito", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDeer", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDragonQueen", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDraugr", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDraugrElite", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDvergr", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyEikthyr", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyFenring", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyFrostTroll", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGjall", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoblin", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoblinBrute", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoblinKing", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoblinShaman", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGreydwarf", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGreydwarfBrute", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGreydwarfShaman", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGrowth", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyHare", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyHatchling", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyLeech", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyLox", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyNeck", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySeeker", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySeekerBrute", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySeekerQueen", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySerpent", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySGolem", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySkeleton", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySkeletonPoison", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySurtling", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyTheElder", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyTick", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyUlv", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyWolf", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyWraith", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyTrollSkeleton_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyTrollAshlands_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyStag_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyPolarBear_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyLeechPrimal_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyStagGhost_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += "\n $tag_rottenvegetable_bal_description";
			text += addConversion(((Component)composter).gameObject, "RottenMeat", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "RottenVegetable_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Pukeberries", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "StrawBundle_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Cabbage_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Turnip", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Carrot", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Onion", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Garlic_bal", "EnrichedSoil_bal", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)composter).gameObject, text);
		}

		public void editSmelter(Smelter smelter = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)smelter == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "smelter");
				smelter = val.GetComponent<Smelter>();
			}
			if (smelter.m_maxFuel == 20)
			{
				smelter.m_maxFuel = 45;
			}
			if (smelter.m_maxOre == 10)
			{
				smelter.m_maxOre = 15;
			}
			if (smelter.m_secPerProduct == 30f)
			{
				smelter.m_secPerProduct = 40f;
			}
			if (smelter.m_fuelPerProduct == 2)
			{
				smelter.m_fuelPerProduct = 3;
			}
			if (smelter.m_conversion == null)
			{
				smelter.m_conversion = new List<ItemConversion>();
			}
			removeConversionFromSmelter("IronScrap", smelter.m_conversion);
			removeConversionFromSmelter("CopperScrap", smelter.m_conversion);
			removeConversionFromSmelter("BronzeScrap", smelter.m_conversion);
			text += "\n Scrap does not go into Furnace/Smelter.  Can be only converted on Forge/Ironworks/Artisan/Blackforge";
			text += addConversion(((Component)smelter).gameObject, "SurtlingCoreCasing_bal", "SurtlingCore", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "CopperOre", "Copper", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "TinOre", "Tin", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "NickelOre_bal", "Nickel_bal", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "IronOre", "Iron", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "SilverOre", "Silver", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "GoldOre_bal", "GoldBar_bal", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)smelter).gameObject, text, "smelter");
		}

		public void editFurnace(Smelter furnace = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)furnace == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "blastfurnace");
				furnace = val.GetComponent<Smelter>();
			}
			if (furnace.m_maxFuel == 20)
			{
				furnace.m_maxFuel = 60;
			}
			if (furnace.m_maxOre == 10)
			{
				furnace.m_maxOre = 30;
			}
			if (furnace.m_secPerProduct == 30f)
			{
				furnace.m_secPerProduct = 20f;
			}
			if (furnace.m_conversion == null)
			{
				furnace.m_conversion = new List<ItemConversion>();
			}
			removeConversionFromSmelter("BlackMetalScrap", furnace.m_conversion);
			text += "\n Scrap does not go into Furnace/Smelter.  Can be only converted on Forge/Ironworks/Artisan/Blackforge";
			text += addConversion(((Component)furnace).gameObject, "SurtlingCoreCasing_bal", "SurtlingCore", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "CopperOre", "Copper", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "TinOre", "Tin", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "NickelOre_bal", "Nickel_bal", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "IronOre", "Iron", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "SilverOre", "Silver", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "GoldOre_bal", "GoldBar_bal", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "BlackMetalOre_bal", "BlackMetal", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "DarkIron_bal", "DarkSteel_bal", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "CobaltOre_bal", "Cobalt_bal", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "FlametalOre", "Flametal", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "FlametalOreNew", "FlametalNew", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)furnace).gameObject, text, "smelter");
		}

		public void editSawMill(BalrondConverter sawmill = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)sawmill == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_sawmill_bal");
				sawmill = val.GetComponent<BalrondConverter>();
			}
			sawmill.m_conversion.Clear();
			sawmill.m_conversion = new List<BalrondConverter.ItemConversion>();
			text += addConversion(((Component)sawmill).gameObject, "RoundLog", "Wood", ConversionType.balrondConverter, 30, 3);
			text += addConversion(((Component)sawmill).gameObject, "FineWood", "Wood", ConversionType.balrondConverter, 30, 4);
			text += addConversion(((Component)sawmill).gameObject, "ElderBark", "Wood", ConversionType.balrondConverter, 25, 2);
			text += addConversion(((Component)sawmill).gameObject, "YewBark_bal", "Wood", ConversionType.balrondConverter, 25, 2);
			text += addConversion(((Component)sawmill).gameObject, "WillowBark_bal", "Wood", ConversionType.balrondConverter, 25, 2);
			text += addConversion(((Component)sawmill).gameObject, "HardWood_bal", "FineWood", ConversionType.balrondConverter, 35, 3);
			text += addConversion(((Component)sawmill).gameObject, "SoftWood_bal", "FineWood", ConversionType.balrondConverter, 35, 2);
			text += addConversion(((Component)sawmill).gameObject, "YggdrasilWood", "SoftWood_bal", ConversionType.balrondConverter, 35, 3);
			text += addConversion(((Component)sawmill).gameObject, "Blackwood", "FineWood", ConversionType.balrondConverter, 35, 4);
			text += addConversion(((Component)sawmill).gameObject, "EmberWood_bal", "YggdrasilWood", ConversionType.balrondConverter, 40, 2);
			text += addConversion(((Component)sawmill).gameObject, "CrystalWood_bal", "HardWood_bal", ConversionType.balrondConverter, 40, 2);
			buildConversionStationTutorialTag(((Component)sawmill).gameObject, text);
		}

		public void editFermenter(Fermenter fermenter = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)fermenter == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "fermenter");
				fermenter = val.GetComponent<Fermenter>();
			}
			fermenter.m_fermentationDuration = 2000f;
			text += addConversion(((Component)fermenter).gameObject, "MeadBaseWhiteCheese_bal", "WhiteCheese_bal", ConversionType.fermenter, 2);
			text += addConversion(((Component)fermenter).gameObject, "SurstrommingBase_bal", "Surstromming_bal", ConversionType.fermenter, 2);
			buildConversionStationTutorialTag(((Component)fermenter).gameObject, text);
		}

		public void editOven(CookingStation oven = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)oven == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_oven");
				oven = val.GetComponent<CookingStation>();
			}
			if (oven.m_conversion == null)
			{
				oven.m_conversion = new List<ItemConversion>();
			}
			text += addConversion(((Component)oven).gameObject, "FishWrapsUncooked_bal", "FishWraps", ConversionType.cooking, 50);
			text += addConversion(((Component)oven).gameObject, "ApplePieUncooked_bal", "ApplePie_bal", ConversionType.cooking, 50);
			text += addConversion(((Component)oven).gameObject, "BlueberryPieUncooked_bal", "BlueberryPie_bal", ConversionType.cooking, 50);
			buildConversionStationTutorialTag(((Component)oven).gameObject, text);
		}

		public void editCooking(CookingStation cookingStation = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)cookingStation == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_cookingstation");
				cookingStation = val.GetComponent<CookingStation>();
			}
			text += addConversion(((Component)cookingStation).gameObject, "BatWing_bal", "BatWingCooked_bal", ConversionType.cooking, 25);
			text += addConversion(((Component)cookingStation).gameObject, "GoatMeat_bal", "GoatMeatCooked_bal", ConversionType.cooking, 40);
			text += addConversion(((Component)cookingStation).gameObject, "RawCrowMeat_bal", "CookedCrowMeat_bal", ConversionType.cooking);
			text += addConversion(((Component)cookingStation).gameObject, "RawSteak_bal", "SteakCooked_bal", ConversionType.cooking);
			text += addConversion(((Component)cookingStation).gameObject, "SharkMeat_bal", "SharkMeatCooked_bal", ConversionType.cooking, 35);
			text += addConversion(((Component)cookingStation).gameObject, "CrabLegs_bal", "CrabLegsCooked_bal", ConversionType.cooking);
			text += addConversion(((Component)cookingStation).gameObject, "TrollMeat_bal", "TrollMeatCooked_bal", ConversionType.cooking, 60);
			buildConversionStationTutorialTag(((Component)cookingStation).gameObject, text);
		}

		public void editIronCooking(CookingStation cookingStation = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)cookingStation == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_cookingstation_iron");
				cookingStation = val.GetComponent<CookingStation>();
			}
			text += addConversion(((Component)cookingStation).gameObject, "CrabLegs_bal", "CrabLegsCooked_bal", ConversionType.cooking, 25);
			text += addConversion(((Component)cookingStation).gameObject, "SharkMeat_bal", "SharkMeatCooked_bal", ConversionType.cooking);
			text += addConversion(((Component)cookingStation).gameObject, "FenringMeat_bal", "FenringMeatCooked_bal", ConversionType.cooking, 60);
			text += addConversion(((Component)cookingStation).gameObject, "RawCrowMeat_bal", "CookedCrowMeat_bal", ConversionType.cooking);
			text += addConversion(((Component)cookingStation).gameObject, "RawSteak_bal", "SteakCooked_bal", ConversionType.cooking, 20);
			text += addConversion(((Component)cookingStation).gameObject, "BatWing_bal", "BatWingCooked_bal", ConversionType.cooking, 20);
			text += addConversion(((Component)cookingStation).gameObject, "GoatMeat_bal", "GoatMeatCooked_bal", ConversionType.cooking, 35);
			text += addConversion(((Component)cookingStation).gameObject, "DrakeMeat_bal", "DrakeMeatCooked_bal", ConversionType.cooking);
			text += addConversion(((Component)cookingStation).gameObject, "TrollMeat_bal", "TrollMeatCooked_bal", ConversionType.cooking, 60);
			buildConversionStationTutorialTag(((Component)cookingStation).gameObject, text);
		}

		public void editWHeel(Smelter wheel = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)wheel == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_spinningwheel");
				wheel = val.GetComponent<Smelter>();
			}
			if (wheel.m_maxOre == 40)
			{
				wheel.m_maxOre = 80;
			}
			if (wheel.m_secPerProduct == 30f)
			{
				wheel.m_secPerProduct = 25f;
			}
			text += addConversion(((Component)wheel).gameObject, "Straw_bal", "StrawThread_bal", ConversionType.smelter);
			text += addConversion(((Component)wheel).gameObject, "RawSilk_bal", "SilkReinforcedThread_bal", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)wheel).gameObject, text);
		}

		public void editSap(SapCollector sap = null)
		{
			if (buildPieces != null && (Object)(object)sap == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_sapcollector");
				sap = val.GetComponent<SapCollector>();
			}
			if (sap.m_secPerUnit == 60f)
			{
				sap.m_secPerUnit = 90f;
			}
			if (sap.m_maxLevel == 10)
			{
				sap.m_maxLevel = 30;
			}
		}

		public void editWIndMIll(Smelter windmill = null)
		{
			string text = "";
			if (buildPieces != null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "windmill");
				windmill = val.GetComponent<Smelter>();
			}
			if (windmill.m_maxOre == 50)
			{
				windmill.m_maxOre = 60;
			}
			if (windmill.m_secPerProduct == 10f)
			{
				windmill.m_secPerProduct = 15f;
			}
		}

		public void editKiln(Smelter kiln = null)
		{
			string text = "";
			if (buildPieces != null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "charcoal_kiln");
				kiln = val.GetComponent<Smelter>();
			}
			if (kiln.m_maxOre == 25)
			{
				kiln.m_maxOre = 50;
			}
			if (kiln.m_secPerProduct == 15f)
			{
				kiln.m_secPerProduct = 10f;
			}
			kiln.m_addOreTooltip = "$piece_smelter_add";
			text += addConversion(((Component)kiln).gameObject, "TarBase_bal", "Tar", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "Moss_bal", "CoalPowder_bal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "ElderBark", "CoalPowder_bal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "YewBark_bal", "CoalPowder_bal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "WillowBark_bal", "CoalPowder_bal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "HardWood_bal", "Coal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "SoftWood_bal", "Coal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "YggdrasilWood", "Coal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "Blackwood", "Coal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "ClayBrickMold_bal", "ClayBrick_bal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "CeramicMold_bal", "CeramicPlate", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)kiln).gameObject, text);
		}

		public void editPress(Smelter press = null)
		{
			string text = "";
			if (buildPieces != null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "oilpress_bal");
				press = val.GetComponent<Smelter>();
			}
			text += addConversion(((Component)press).gameObject, "OilBase_bal", "Oil_bal", ConversionType.smelter);
			text += addConversion(((Component)press).gameObject, "BlackBerryJuiceBase_bal", "BlackBerryJuice_bal", ConversionType.smelter);
			text += addConversion(((Component)press).gameObject, "FruitPunchBase_bal", "FruitPunch_bal", ConversionType.smelter);
			text += addConversion(((Component)press).gameObject, "VineBerryJuiceBase_bal", "VineBerryJuice_bal", ConversionType.smelter);
			text += addConversion(((Component)press).gameObject, "MagmaCoctailBase_bal", "MagmaCoctail_bal", ConversionType.smelter);
			text += addConversion(((Component)press).gameObject, "PaintBucket_bal", "DyeKit_bal", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)press).gameObject, text);
		}

		private void editBeehive()
		{
			GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_beehive");
			Beehive component = val.GetComponent<Beehive>();
			component.m_maxHoney = 20;
		}

		private void editIncinerator(Incinerator incinerator = null)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			if (buildPieces != null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "incinerator");
				incinerator = val.GetComponent<Incinerator>();
			}
			IncineratorConversion val2 = new IncineratorConversion();
			val2.m_requireOnlyOneIngredient = true;
			val2.m_priority = 2;
			val2.m_requirements = new List<Requirement>();
			string[] array = convertToBits;
			foreach (string name in array)
			{
				val2.m_requirements.Add(new Requirement
				{
					m_amount = 1,
					m_resItem = FindItem(name).GetComponent<ItemDrop>()
				});
			}
			val2.m_result = FindItem("CoalPowder_bal").GetComponent<ItemDrop>();
			incinerator.m_conversions.Add(val2);
			IncineratorConversion val3 = new IncineratorConversion();
			val3.m_requireOnlyOneIngredient = true;
			val3.m_requirements = new List<Requirement>();
			string[] array2 = convertToCoal;
			foreach (string name2 in array2)
			{
				val3.m_requirements.Add(new Requirement
				{
					m_amount = 1,
					m_resItem = FindItem(name2).GetComponent<ItemDrop>()
				});
			}
			val3.m_result = FindItem("Coal").GetComponent<ItemDrop>();
			incinerator.m_conversions.Add(val3);
			IncineratorConversion val4 = new IncineratorConversion();
			val4.m_requireOnlyOneIngredient = true;
			val4.m_priority = 1;
			val4.m_requirements = new List<Requirement>();
			string[] array3 = arrowsNbolts;
			foreach (string name3 in array3)
			{
				val4.m_requirements.Add(new Requirement
				{
					m_amount = 20,
					m_resItem = FindItem(name3).GetComponent<ItemDrop>()
				});
			}
			val4.m_result = FindItem("Coal").GetComponent<ItemDrop>();
			incinerator.m_conversions.Add(val4);
		}

		private string addConversion(GameObject source, string nameIn, string nameOut, ConversionType type, int time = 30, int amount = 5)
		{
			string result = "";
			switch (type)
			{
			case ConversionType.smelter:
				result = SmelterConversion(source, nameIn, nameOut);
				break;
			case ConversionType.fermenter:
				result = FermenterConversion(source, nameIn, nameOut, amount);
				break;
			case ConversionType.cooking:
				result = CookingConversion(source, nameIn, nameOut, time);
				break;
			case ConversionType.balrondConverter:
				result = BalrondConversion(source, nameIn, nameOut, amount);
				break;
			}
			return result;
		}

		private void buildConversionStationTutorialTag(GameObject gameObject, string tutorialExtra, string tag = "workbench")
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			string text = "\n  <color=orange>BALROND AMAZING NATURE: </color>";
			TutorialText val = new TutorialText();
			val.m_name = "BAN conversions:" + ((Object)gameObject).name;
			val.m_globalKeyTrigger = "AmazingNature" + ((Object)gameObject).name;
			val.m_tutorialTrigger = tag;
			val.m_topic = "BAN-" + ((Object)gameObject).name;
			val.m_label = "BAN-" + ((Object)gameObject).name;
			val.m_isMunin = true;
			val.m_text = text + tutorialExtra;
			m_texts.Add(val);
		}

		private string createConversionSingleLine(ItemDrop m_from, ItemDrop m_to, int time = 0, int amount = 0)
		{
			string text = "\n $tag_convers_bal ";
			if (time > 0 && amount == 0)
			{
				return text + m_from.m_itemData.m_shared.m_name + " $tag_to_bal " + m_to.m_itemData.m_shared.m_name + " $tag_in_bal " + time + " $tag_seconds_bal";
			}
			if (time == 0 && amount > 0)
			{
				return text + m_from.m_itemData.m_shared.m_name + " $tag_to_bal " + amount + " " + m_to.m_itemData.m_shared.m_name;
			}
			if (time > 0 && amount > 0)
			{
				return text + m_from.m_itemData.m_shared.m_name + " $tag_to_bal " + amount + " " + m_to.m_itemData.m_shared.m_name + " $tag_in_bal " + time + " $tag_seconds_bal";
			}
			return text + m_from.m_itemData.m_shared.m_name + " $tag_to_bal " + m_to.m_itemData.m_shared.m_name;
		}

		private string BalrondConversion(GameObject source, string nameIn, string nameOut, int amount = 1, List<GameObject> list = null)
		{
			BalrondConverter component = source.GetComponent<BalrondConverter>();
			string result = "";
			List<BalrondConverter.ItemConversion> source2 = new List<BalrondConverter.ItemConversion>();
			if (component.m_conversion.Count() != 0)
			{
				List<BalrondConverter.ItemConversion> list2 = component.m_conversion.FindAll((BalrondConverter.ItemConversion x) => (Object)(object)x.m_from != (Object)null);
				List<BalrondConverter.ItemConversion> list3 = list2.FindAll((BalrondConverter.ItemConversion x) => x.m_from.m_itemData != null);
				List<BalrondConverter.ItemConversion> list4 = list3.FindAll((BalrondConverter.ItemConversion x) => (Object)(object)x.m_from.m_itemData.m_dropPrefab != (Object)null);
				source2 = list4.FindAll((BalrondConverter.ItemConversion x) => ((Object)x.m_from.m_itemData.m_dropPrefab).name != nameIn);
			}
			if (source2.Count() == 0)
			{
				BalrondConverter.ItemConversion itemConversion = new BalrondConverter.ItemConversion();
				itemConversion.m_from = FindItem(nameIn).GetComponent<ItemDrop>();
				itemConversion.m_to = FindItem(nameOut).GetComponent<ItemDrop>();
				result = createConversionSingleLine(itemConversion.m_from, itemConversion.m_to, 0, amount);
				itemConversion.m_count = amount;
				component.m_conversion.Add(itemConversion);
			}
			return result;
		}

		private string SmelterConversion(GameObject source, string nameIn, string nameOut)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			Smelter component = source.GetComponent<Smelter>();
			if ((Object)(object)component == (Object)null)
			{
				return "";
			}
			if (component.m_conversion == null)
			{
				component.m_conversion = new List<ItemConversion>();
			}
			bool flag = false;
			foreach (ItemConversion item2 in component.m_conversion)
			{
				if (item2 != null && (Object)(object)item2.m_from != (Object)null && item2.m_from.m_itemData != null && (Object)(object)item2.m_from.m_itemData.m_dropPrefab != (Object)null && ((Object)item2.m_from.m_itemData.m_dropPrefab).name == nameIn)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				ItemDrop component2 = FindItem(nameIn).GetComponent<ItemDrop>();
				ItemDrop component3 = FindItem(nameOut).GetComponent<ItemDrop>();
				ItemConversion item = new ItemConversion
				{
					m_from = component2,
					m_to = component3
				};
				component.m_conversion.Add(item);
				return createConversionSingleLine(component2, component3);
			}
			return "";
		}

		private string FermenterConversion(GameObject source, string nameIn, string nameOut, int amount = 1)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			Fermenter component = source.GetComponent<Fermenter>();
			if ((Object)(object)component == (Object)null)
			{
				return "";
			}
			if (component.m_conversion == null)
			{
				component.m_conversion = new List<ItemConversion>();
			}
			bool flag = false;
			foreach (ItemConversion item2 in component.m_conversion)
			{
				if (item2 != null && (Object)(object)item2.m_from != (Object)null && item2.m_from.m_itemData != null && (Object)(object)item2.m_from.m_itemData.m_dropPrefab != (Object)null && ((Object)item2.m_from.m_itemData.m_dropPrefab).name == nameIn)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				ItemDrop component2 = FindItem(nameIn).GetComponent<ItemDrop>();
				ItemDrop component3 = FindItem(nameOut).GetComponent<ItemDrop>();
				ItemConversion item = new ItemConversion
				{
					m_from = component2,
					m_to = component3,
					m_producedItems = amount
				};
				component.m_conversion.Add(item);
				return createConversionSingleLine(component2, component3, 0, amount);
			}
			return "";
		}

		private string CookingConversion(GameObject source, string nameIn, string nameOut, int time = 25)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			CookingStation component = source.GetComponent<CookingStation>();
			if ((Object)(object)component == (Object)null)
			{
				return "";
			}
			if (component.m_conversion == null)
			{
				component.m_conversion = new List<ItemConversion>();
			}
			bool flag = false;
			foreach (ItemConversion item2 in component.m_conversion)
			{
				if (item2 != null && (Object)(object)item2.m_from != (Object)null && item2.m_from.m_itemData != null && (Object)(object)item2.m_from.m_itemData.m_dropPrefab != (Object)null && ((Object)item2.m_from.m_itemData.m_dropPrefab).name == nameIn)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				ItemDrop component2 = FindItem(nameIn).GetComponent<ItemDrop>();
				ItemDrop component3 = FindItem(nameOut).GetComponent<ItemDrop>();
				ItemConversion item = new ItemConversion
				{
					m_from = component2,
					m_to = component3,
					m_cookTime = time
				};
				component.m_conversion.Add(item);
				return createConversionSingleLine(component2, component3, time);
			}
			return "";
		}
	}
	public class BalrondMonsterLoot : MonoBehaviour
	{
		public Character m_character;

		public string m_name;

		public int m_level;

		public bool isBoss;

		private void Awake()
		{
			m_character = ((Component)this).GetComponent<Character>();
			m_name = ((Object)this).name;
			if ((Object)(object)m_character != (Object)null)
			{
				isBoss = m_character.IsBoss();
				m_level = m_character.GetLevel();
			}
			else
			{
				Debug.Log((object)"Character not found");
			}
		}
	}
	[Serializable]
	public class BalrondConverter : MonoBehaviour
	{
		[Serializable]
		public class ItemConversion
		{
			public ItemDrop m_from;

			public ItemDrop m_to;

			public int m_count;
		}

		public string m_name = "BalrondConverter";

		public string prefabName = null;

		public string m_addOreTooltip = "$tag_sawmill_addWood";

		public string m_emptyOreTooltip = "$tag_sawmill_pickupWood";

		public Switch m_addWoodSwitch;

		public Switch m_addOreSwitch;

		public Switch m_emptyOreSwitch;

		public Transform m_outputPoint;

		public Transform m_roofCheckPoint;

		public GameObject m_enabledObject;

		public GameObject m_disabledObject;

		public GameObject m_haveFuelObject;

		public GameObject m_haveOreObject;

		public GameObject m_noOreObject;

		public Animator[] m_animators;

		public ItemDrop m_fuelItem;

		public int m_maxOre = 1;

		public int m_maxFuel = 1;

		public float m_fuelPerProduct = 0f;

		public float m_secPerProduct = 30f;

		public bool m_spawnStack = true;

		public bool m_requiresRoof = false;

		public Windmill m_windmill;

		public SmokeSpawner m_smokeSpawner;

		public float m_addOreAnimationDuration;

		public List<ItemConversion> m_conversion = new List<ItemConversion>();

		public EffectList m_oreAddedEffects = new EffectList();

		public EffectList m_fuelAddedEffects = new EffectList();

		public EffectList m_produceEffects = new EffectList();

		private ZNetView m_nview;

		private bool m_haveRoof;

		private bool m_blockedSmoke;

		private float m_addedOreTime = -1000f;

		private StringBuilder m_sb = new StringBuilder();

		private void Awake()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			m_nview = ((Component)this).GetComponent<ZNetView>();
			if (!((Object)(object)m_nview == (Object)null) && m_nview.GetZDO() != null)
			{
				if (Object.op_Implicit((Object)(object)m_addOreSwitch))
				{
					Switch addOreSwitch = m_addOreSwitch;
					addOreSwitch.m_onUse = (Callback)Delegate.Combine((Delegate?)(object)addOreSwitch.m_onUse, (Delegate?)new Callback(OnAddWood));
					m_addOreSwitch.m_onHover = new TooltipCallback(OnHoverAddWood);
				}
				if (Object.op_Implicit((Object)(object)m_addWoodSwitch))
				{
					Switch addWoodSwitch = m_addWoodSwitch;
					addWoodSwitch.m_onUse = (Callback)Delegate.Combine((Delegate?)(object)addWoodSwitch.m_onUse, (Delegate?)new Callback(OnAddPowerSource));
					m_addWoodSwitch.m_onHover = new TooltipCallback(OnHoverAddPowerSource);
				}
				if (Object.op_Implicit((Object)(object)m_emptyOreSwitch))
				{
					Switch emptyOreSwitch = m_emptyOreSwitch;
					emptyOreSwitch.m_onUse = (Callback)Delegate.Combine((Delegate?)(object)emptyOreSwitch.m_onUse, (Delegate?)new Callback(OnEmpty));
					Switch emptyOreSwitch2 = m_emptyOreSwitch;
					emptyOreSwitch2.m_onHover = (TooltipCallback)Delegate.Combine((Delegate?)(object)emptyOreSwitch2.m_onHover, (Delegate?)new TooltipCallback(OnHoverEmptyOre));
				}
				m_nview.Register<string>("AddWood", (Action<long, string>)RPC_AddWood);
				m_nview.Register("AddPowerSource", (Action<long>)RPC_AddPowerSource);
				m_nview.Register("ConverterEmptyProcessed", (Action<long>)RPC_ConverterEmptyProcessed);
				WearNTear component = ((Component)this).GetComponent<WearNTear>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.m_onDestroyed = (Action)Delegate.Combine(component.m_onDestroyed, new Action(OnDestroyed));
				}
				((MonoBehaviour)this).InvokeRepeating("UpdateBalrondConverter", 1f, 1f);
			}
		}

		private void DropAllItems()
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			SpawnProcessed();
			if ((Object)(object)m_fuelItem != (Object)null)
			{
				float @float = m_nview.GetZDO().GetFloat(ZDOVars.s_fuel, 0f);
				if (@float > 1f)
				{
					for (int i = 0; i < (int)@float; i++)
					{
						Object.Instantiate<GameObject>(((Component)m_fuelItem).gameObject, ((Component)this).transform.position + Vector3.up + Random.insideUnitSphere * 0.3f, Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f));
					}
				}
			}
			while (GetQueueSize() > 0)
			{
				string queuedOre = GetQueuedOre();
				RemoveOneOre();
				ItemConversion itemConversion = GetItemConversion(queuedOre);
				if (itemConversion != null)
				{
					Vector3 val = ((Component)this).transform.position + Vector3.up + Random.insideUnitSphere * 0.3f;
					Quaternion val2 = Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f);
					Object.Instantiate<GameObject>(((Component)itemConversion.m_from).gameObject, val, val2);
				}
			}
		}

		private void OnDestroyed()
		{
			if (m_nview.IsOwner())
			{
				DropAllItems();
			}
		}

		private bool IsItemAllowed(ItemData item)
		{
			return IsItemAllowed(((Object)item.m_dropPrefab).name);
		}

		private bool IsItemAllowed(string itemName)
		{
			foreach (ItemConversion item in m_conversion)
			{
				if (((Object)((Component)item.m_from).gameObject).name == itemName)
				{
					return true;
				}
			}
			return false;
		}

		private ItemData FindCookableItem(Inventory inventory)
		{
			foreach (ItemConversion item2 in m_conversion)
			{
				ItemData item = inventory.GetItem(((Object)((Component)item2.m_from).gameObject).name, -1, true);
				if (item != null)
				{
					return item;
				}
			}
			return null;
		}

		private bool OnAddWood(Switch sw, Humanoid user, ItemData item)
		{
			if (item == null)
			{
				item = FindCookableItem(user.GetInventory());
				if (item == null)
				{
					((Character)user).Message((MessageType)2, "$msg_noprocessableitems", 0, (Sprite)null);
					return false;
				}
			}
			if (!IsItemAllowed(((Object)item.m_dropPrefab).name))
			{
				((Character)user).Message((MessageType)2, "$msg_wontwork", 0, (Sprite)null);
				return false;
			}
			ZLog.Log((object)("trying to add " + item.m_shared.m_name));
			if (GetQueueSize() >= m_maxOre)
			{
				((Character)user).Message((MessageType)2, "$msg_itsfull", 0, (Sprite)null);
				return false;
			}
			((Character)user).Message((MessageType)2, "$msg_added " + item.m_shared.m_name, 0, (Sprite)null);
			user.GetInventory().RemoveItem(item, 1);
			m_nview.InvokeRPC("AddWood", new object[1] { ((Object)item.m_dropPrefab).name });
			m_addedOreTime = Time.time;
			if ((double)m_addOreAnimationDuration > 0.0)
			{
				SetAnimation(active: true);
			}
			return true;
		}

		private float GetBakeTimer()
		{
			return m_nview.GetZDO().GetFloat(ZDOVars.s_bakeTimer, 0f);
		}

		private void SetBakeTimer(float t)
		{
			m_nview.GetZDO().Set(ZDOVars.s_bakeTimer, t);
		}

		private float GetFuel()
		{
			return m_nview.GetZDO().GetFloat(ZDOVars.s_fuel, 0f);
		}

		private void SetFuel(float fuel)
		{
			m_nview.GetZDO().Set(ZDOVars.s_fuel, fuel);
		}

		private int GetQueueSize()
		{
			return m_nview.GetZDO().GetInt(ZDOVars.s_queued, 0);
		}

		private void RPC_AddWood(long sender, string name)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (m_nview.IsOwner())
			{
				if (!IsItemAllowed(name))
				{
					ZLog.Log((object)("Item not allowed " + name));
					return;
				}
				QueueOre(name);
				m_oreAddedEffects.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
				ZLog.Log((object)("Added ore " + name));
			}
		}

		private void QueueOre(string name)
		{
			int queueSize = GetQueueSize();
			m_nview.GetZDO().Set("item" + queueSize, name);
			m_nview.GetZDO().Set(ZDOVars.s_queued, queueSize + 1, false);
		}

		private string GetQueuedOre()
		{
			return (GetQueueSize() == 0) ? "" : m_nview.GetZDO().GetString(ZDOVars.s_item0, "");
		}

		private void RemoveOneOre()
		{
			int queueSize = GetQueueSize();
			if (queueSize != 0)
			{
				for (int i = 0; i < queueSize; i++)
				{
					string @string = m_nview.GetZDO().GetString("item" + (i + 1), "");
					m_nview.GetZDO().Set("item" + i, @string);
				}
				m_nview.GetZDO().Set(ZDOVars.s_queued, queueSize - 1, false);
			}
		}

		private bool OnEmpty(Switch sw, Humanoid user, ItemData item)
		{
			if (GetProcessedQueueSize() <= 0)
			{
				return false;
			}
			m_nview.InvokeRPC("ConverterEmptyProcessed", Array.Empty<object>());
			return true;
		}

		private void RPC_ConverterEmptyProcessed(long sender)
		{
			if (m_nview.IsOwner())
			{
				SpawnProcessed();
			}
		}

		private bool OnAddPowerSource(Switch sw, Humanoid user, ItemData item)
		{
			if (item != null && item.m_shared.m_name != m_fuelItem.m_itemData.m_shared.m_name)
			{
				((Character)user).Message((MessageType)2, "$msg_wrongitem", 0, (Sprite)null);
				return false;
			}
			if ((double)GetFuel() > (double)(m_maxFuel - 1))
			{
				((Character)user).Message((MessageType)2, "$msg_itsfull", 0, (Sprite)null);
				return false;
			}
			if (!user.GetInventory().HaveItem(m_fuelItem.m_itemData.m_shared.m_name, true))
			{
				((Character)user).Message((MessageType)2, "$msg_donthaveany " + m_fuelItem.m_itemData.m_shared.m_name, 0, (Sprite)null);
				return false;
			}
			((Character)user).Message((MessageType)2, "$msg_added " + m_fuelItem.m_itemData.m_shared.m_name, 0, (Sprite)null);
			user.GetInventory().RemoveItem(m_fuelItem.m_itemData.m_shared.m_name, 1, -1, true);
			m_nview.InvokeRPC("AddPowerSource", Array.Empty<object>());
			return true;
		}

		private void RPC_AddPowerSource(long sender)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (m_nview.IsOwner())
			{
				SetFuel(GetFuel() + 1f);
				m_fuelAddedEffects.Create(((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform, 1f, -1);
			}
		}

		private double GetDeltaTime()
		{
			DateTime time = ZNet.instance.GetTime();
			DateTime dateTime = new DateTime(m_nview.GetZDO().GetLong(ZDOVars.s_startTime, time.Ticks));
			double totalSeconds = (time - dateTime).TotalSeconds;
			m_nview.GetZDO().Set(ZDOVars.s_startTime, time.Ticks);
			return totalSeconds;
		}

		private float GetAccumulator()
		{
			return m_nview.GetZDO().GetFloat(ZDOVars.s_accTime, 0f);
		}

		private void SetAccumulator(float t)
		{
			m_nview.GetZDO().Set(ZDOVars.s_accTime, t);
		}

		private void UpdateRoof()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (m_requiresRoof)
			{
				m_haveRoof = Cover.IsUnderRoof(m_roofCheckPoint.position);
			}
		}

		private void UpdateSmoke()
		{
			if ((Object)(object)m_smokeSpawner != (Object)null)
			{
				m_blockedSmoke = m_smokeSpawner.IsBlocked();
			}
			else
			{
				m_blockedSmoke = false;
			}
		}

		private void UpdateBalrondConverter()
		{
			if (!m_nview.IsValid())
			{
				return;
			}
			UpdateState();
			if (!m_nview.IsOwner())
			{
				return;
			}
			double deltaTime = GetDeltaTime();
			float num = GetAccumulator() + (float)deltaTime;
			if ((double)num > 3600.0)
			{
				num = 3600f;
			}
			float num2 = (Object.op_Implicit((Object)(object)m_windmill) ? m_windmill.GetPowerOutput() : 1f);
			while ((double)num >= 1.0)
			{
				num -= 1f;
				float fuel = GetFuel();
				string queuedOre = GetQueuedOre();
				if ((m_maxFuel != 0 && !((double)fuel > 0.0)) || (m_maxOre != 0 && !(queuedOre != "")) || !((double)m_secPerProduct > 0.0))
				{
					continue;
				}
				float num3 = 1f * num2;
				if (m_maxFuel > 0)
				{
					float num4 = m_secPerProduct / m_fuelPerProduct;
					float num5 = fuel - num3 / num4;
					if ((double)num5 < 9.99999974737875E-05)
					{
						num5 = 0f;
					}
					SetFuel(num5);
				}
				if (queuedOre != "")
				{
					float num6 = GetBakeTimer() + num3;
					SetBakeTimer(num6);
					if ((double)num6 >= (double)m_secPerProduct)
					{
						SetBakeTimer(0f);
						RemoveOneOre();
						QueueProcessed(queuedOre);
					}
				}
			}
			if (GetQueuedOre() == "" || ((double)m_maxFuel > 0.0 && (double)GetFuel() == 0.0))
			{
				SpawnProcessed();
			}
			SetAccumulator(num);
		}

		private void QueueProcessed(string ore)
		{
			if (!m_spawnStack)
			{
				Spawn(ore, 1);
				return;
			}
			ItemConversion itemConversion = GetItemConversion(ore);
			string @string = m_nview.GetZDO().GetString(ZDOVars.s_spawnOre, "");
			int @int = m_nview.GetZDO().GetInt(ZDOVars.s_spawnAmount, 0);
			if (@string.Length > 0)
			{
				if (@string != ore)
				{
					SpawnProcessed();
					m_nview.GetZDO().Set(ZDOVars.s_spawnOre, ore);
					m_nview.GetZDO().Set(ZDOVars.s_spawnAmount, itemConversion.m_count, false);
					return;
				}
				int num = @int + itemConversion.m_count;
				if (itemConversion == null || num >= itemConversion.m_to.m_itemData.m_shared.m_maxStackSize)
				{
					Spawn(ore, @int);
					Spawn(ore, itemConversion.m_count);
					m_nview.GetZDO().Set(ZDOVars.s_spawnOre, "");
					m_nview.GetZDO().Set(ZDOVars.s_spawnAmount, 0, false);
				}
				else
				{
					m_nview.GetZDO().Set(ZDOVars.s_spawnAmount, num, false);
				}
			}
			else
			{
				m_nview.GetZDO().Set(ZDOVars.s_spawnOre, ore);
				m_nview.GetZDO().Set(ZDOVars.s_spawnAmount, itemConversion.m_count, false);
			}
		}

		private void SpawnProcessed()
		{
			int @int = m_nview.GetZDO().GetInt(ZDOVars.s_spawnAmount, 0);
			if (@int > 0)
			{
				Spawn(m_nview.GetZDO().GetString(ZDOVars.s_spawnOre, ""), @int);
				m_nview.GetZDO().Set(ZDOVars.s_spawnOre, "");
				m_nview.GetZDO().Set(ZDOVars.s_spawnAmount, 0, false);
			}
		}

		private int GetProcessedQueueSize()
		{
			return m_nview.GetZDO().GetInt(ZDOVars.s_spawnAmount, 0);
		}

		private void Spawn(string ore, int stack)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			ItemConversion itemConversion = GetItemConversion(ore);
			if (itemConversion != null)
			{
				m_produceEffects.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
				Object.Instantiate<GameObject>(((Component)itemConversion.m_to).gameObject, m_outputPoint.position, m_outputPoint.rotation).GetComponent<ItemDrop>().m_itemData.m_stack = stack;
			}
		}

		private ItemConversion GetItemConversion(string itemName)
		{
			foreach (ItemConversion item in m_conversion)
			{
				if (((Object)((Component)item.m_from).gameObject).name == itemName)
				{
					return item;
				}
			}
			return null;
		}

		private void UpdateState()
		{
			bool flag = IsActive();
			m_enabledObject.SetActive(flag);
			if (Object.op_Implicit((Object)(object)m_disabledObject))
			{
				m_disabledObject.SetActive(!flag);
			}
			if (Object.op_Implicit((Object)(object)m_haveFuelObject))
			{
				m_haveFuelObject.SetActive((double)GetFuel() > 0.0 && !flag);
			}
			if (Object.op_Implicit((Object)(object)m_haveOreObject))
			{
				m_haveOreObject.SetActive(GetQueueSize() > 0);
			}
			if (Object.op_Implicit((Object)(object)m_noOreObject))
			{
				m_noOreObject.SetActive(GetQueueSize() == 0);
			}
			if ((double)m_addOreAnimationDuration > 0.0 && (double)Time.time - (double)m_addedOreTime < (double)m_addOreAnimationDuration)
			{
				flag = true;
			}
			SetAnimation(flag);
		}

		private void SetAnimation(bool active)
		{
			Animator[] animators = m_animators;
			foreach (Animator val in animators)
			{
				if (((Component)val).gameObject.activeInHierarchy)
				{
					val.SetBool("active", active);
					val.SetFloat("activef", active ? 1f : 0f);
				}
			}
		}

		public bool IsActive()
		{
			return (m_maxFuel == 0 || (double)GetFuel() > 0.0) && (m_maxOre == 0 || GetQueueSize() > 0);
		}

		private string OnHoverAddPowerSource()
		{
			return Localization.instance.Localize($"{m_name} ({m_fuelItem.m_itemData.m_shared.m_name} {Mathf.Ceil(GetFuel())}/{m_maxFuel})\n[<color=yellow><b>$KEY_Use</b></color>] Add {m_fuelItem.m_itemData.m_shared.m_name}");
		}

		private string OnHoverEmptyOre()
		{
			return Localization.instance.Localize($"{m_name} ({GetProcessedQueueSize()} Ready) \n[<color=yellow><b>$KEY_Use</b></color>] {m_emptyOreTooltip}");
		}

		private string OnHoverAddWood()
		{
			m_sb.Clear();
			m_sb.Append($"{m_name} ({GetQueueSize()}/{m_maxOre}) ");
			m_sb.Append("\n[<color=yellow><b>$KEY_Use</b></color>] " + m_addOreTooltip);
			return Localization.instance.Localize(m_sb.ToString());
		}
	}
	public class BalrondBoonStone : MonoBehaviour
	{
		public ItemStand m_itemStand;

		public GameObject m_activeEffect;

		public EffectList m_activateStep1 = new EffectList();

		public EffectList m_activateStep2 = new EffectList();

		public EffectList m_activateStep3 = new EffectList();

		public string m_completedMessage = "";

		public MeshRenderer m_mesh;

		public int m_emissiveMaterialIndex;

		public Color m_activeEmissiveColor = Color.white;

		private bool m_active;

		private ZNetView m_nview;

		public string m_name = "";

		public Transform m_attachOther;

		public Transform m_dropSpawnPoint;

		public bool m_canBeRemoved = true;

		public bool m_autoAttach;

		public bool m_horizontal;

		public List<ItemType> m_supportedTypes = new List<ItemType>();

		public List<ItemDrop> m_unsupportedItems = new List<ItemDrop>();

		public List<ItemDrop> m_supportedItems = new List<ItemDrop>();

		public EffectList m_effects = new EffectList();

		public EffectList m_destroyEffects = new EffectList();

		[Header("Guardian power")]
		public float m_powerActivationDelay = 2f;

		public StatusEffect m_boon;

		public EffectList m_activatePowerEffects = new EffectList();

		public EffectList m_activatePowerEffectsPlayer = new EffectList();

		private string m_visualName = "";

		private int m_visualVariant;

		private GameObject m_visualItem;

		[NonSerialized]
		public string m_currentItemName = "";

		private ItemData m_queuedItem;

		public ZNetView m_netViewOverride;

		private void Awake()
		{
			m_nview = (Object.op_Implicit((Object)(object)m_netViewOverride) ? m_netViewOverride : ((Component)this).gameObject.GetComponent<ZNetView>());
			if (m_nview.GetZDO() != null)
			{
				WearNTear component = ((Component)this).GetComponent<WearNTear>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.m_onDestroyed = (Action)Delegate.Combine(component.m_onDestroyed, new Action(OnDestroyed));
				}
				m_nview.Register("DropItem", (Action<long>)RPC_DropItem);
				m_nview.Register("RequestOwn", (Action<long>)RPC_RequestOwn);
				m_nview.Register("DestroyAttachment", (Action<long>)RPC_DestroyAttachment);
				m_nview.Register<string, int, int>("SetVisualItem", (Action<long, string, int, int>)RPC_SetVisualItem);
			}
		}

		private void Start()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (((Renderer)m_mesh).materials[m_emissiveMaterialIndex].HasProperty("_EmissionColor"))
			{
				((Renderer)m_mesh).materials[m_emissiveMaterialIndex].SetColor("_EmissionColor", Color.black);
			}
			if (Object.op_Implicit((Object)(object)m_activeEffect))
			{
				m_activeEffect.SetActive(false);
			}
			SetActivated(m_itemStand.HaveAttachment(), triggerEffect: false);
			((MonoBehaviour)this).InvokeRepeating("UpdateVisual", 1f, 2f);
		}

		private void SetActivated(bool active, bool triggerEffect)
		{
			if (active == m_active)
			{
				return;
			}
			m_active = active;
			if (triggerEffect && active)
			{
				((MonoBehaviour)this).Invoke("DelayedAttachEffects_Step1", 1f);
				((MonoBehaviour)this).Invoke("DelayedAttachEffects_Step2", 5f);
				((MonoBehaviour)this).Invoke("DelayedAttachEffects_Step3", 11f);
				return;
			}
			if (Object.op_Implicit((Object)(object)m_activeEffect))
			{
				m_activeEffect.SetActive(active);
			}
			((MonoBehaviour)this).StopCoroutine("FadeEmission");
			((MonoBehaviour)this).StartCoroutine("FadeEmission");
		}

		private void DelayedAttachEffects_Step1()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			m_activateStep1.Create(((Component)m_itemStand).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
		}

		private void DelayedAttachEffects_Step2()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			m_activateStep2.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
		}

		private void DelayedAttachEffects_Step3()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)m_activeEffect))
			{
				m_activeEffect.SetActive(true);
			}
			m_activateStep3.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
			((MonoBehaviour)this).StopCoroutine("FadeEmission");
			((MonoBehaviour)this).StartCoroutine("Fade