using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Extensions;
using Jotunn.Managers;
using Jotunn.Utils;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Forged by the Ancients")]
[assembly: AssemblyDescription("Valheim rune energy mod by Morda")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Morda")]
[assembly: AssemblyProduct("Forged by the Ancients")]
[assembly: AssemblyCopyright("Copyright © Morda 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("58185267-91c9-4482-b78d-09806077c89e")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ForgedByAncients;

public static class AncientCoreItem
{
	public const string PrefabName = "fba_ancientcore";

	private const string IconResourceName = "fba_ancientcore_icon.png";

	private static bool registered;

	private static Sprite customIcon;

	public static void Register()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Expected O, but got Unknown
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Expected O, but got Unknown
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Expected O, but got Unknown
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Expected O, but got Unknown
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Expected O, but got Unknown
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Expected O, but got Unknown
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Expected O, but got Unknown
		//IL_0119: Unknown result type (might be due to invalid IL or missing references)
		//IL_0123: Expected O, but got Unknown
		if (!registered)
		{
			registered = true;
			customIcon = LoadEmbeddedIcon();
			ItemConfig val = new ItemConfig();
			val.Name = "$item_fba_ancientcore";
			val.Description = "$item_fba_ancientcore_description";
			val.CraftingStation = CraftingStations.Forge;
			val.Amount = 1;
			val.Requirements = (RequirementConfig[])(object)new RequirementConfig[2]
			{
				new RequirementConfig("SurtlingCore", 1, 0, true),
				new RequirementConfig("Crystal", 5, 0, true)
			};
			ItemConfig val2 = val;
			if ((Object)(object)customIcon != (Object)null)
			{
				val2.Icons = (Sprite[])(object)new Sprite[1] { customIcon };
			}
			CustomItem val3 = new CustomItem("fba_ancientcore", "SurtlingCore", val2);
			ItemManager.Instance.AddItem(val3);
			ApplyVisuals(val3);
			ItemManager instance = ItemManager.Instance;
			RecipeConfig val4 = new RecipeConfig();
			val4.Name = "Recipe_fba_ancientcore_x5";
			val4.Item = "fba_ancientcore";
			val4.Amount = 5;
			val4.CraftingStation = CraftingStations.Forge;
			val4.Requirements = (RequirementConfig[])(object)new RequirementConfig[2]
			{
				new RequirementConfig("SurtlingCore", 5, 0, true),
				new RequirementConfig("Crystal", 10, 0, true)
			};
			instance.AddRecipe(new CustomRecipe(val4));
		}
	}

	private static void ApplyVisuals(CustomItem item)
	{
		if (item != null)
		{
			if ((Object)(object)item.ItemPrefab != (Object)null)
			{
				TintDropBlue(item.ItemPrefab);
			}
			ItemDrop itemDrop = item.ItemDrop;
			if (itemDrop?.m_itemData?.m_shared != null && !((Object)(object)customIcon == (Object)null))
			{
				itemDrop.m_itemData.m_shared.m_icons = (Sprite[])(object)new Sprite[1] { customIcon };
			}
		}
	}

	private static Sprite LoadEmbeddedIcon()
	{
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Expected O, but got Unknown
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			Stream manifestResourceStream = executingAssembly.GetManifestResourceStream("fba_ancientcore_icon.png");
			if (manifestResourceStream == null)
			{
				string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
				foreach (string text in manifestResourceNames)
				{
					if (text.EndsWith("fba_ancientcore_icon.png"))
					{
						manifestResourceStream = executingAssembly.GetManifestResourceStream(text);
						break;
					}
				}
			}
			if (manifestResourceStream == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"AncientCore: Icon-Resource nicht gefunden.");
				}
				return null;
			}
			byte[] bytes;
			using (manifestResourceStream)
			{
				using MemoryStream memoryStream = new MemoryStream();
				manifestResourceStream.CopyTo(memoryStream);
				bytes = memoryStream.ToArray();
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			((Object)val).name = "fba_ancientcore_icon";
			if (!TryLoadImage(val, bytes))
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)"AncientCore: Icon-PNG konnte nicht geladen werden.");
				}
				return null;
			}
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
		}
		catch (Exception ex)
		{
			ManualLogSource log3 = Plugin.Log;
			if (log3 != null)
			{
				log3.LogWarning((object)("AncientCore Icon laden fehlgeschlagen: " + ex.Message));
			}
			return null;
		}
	}

	private static bool TryLoadImage(Texture2D tex, byte[] bytes)
	{
		if ((Object)(object)tex == (Object)null || bytes == null || bytes.Length == 0)
		{
			return false;
		}
		try
		{
			MethodInfo methodInfo = AccessToolsLoadImage();
			if (methodInfo == null)
			{
				return false;
			}
			object obj = methodInfo.Invoke(null, new object[3] { tex, bytes, false });
			bool flag = default(bool);
			int num;
			if (obj is bool)
			{
				flag = (bool)obj;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}
		catch (Exception ex)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("TryLoadImage: " + ex.Message));
			}
			return false;
		}
	}

	private static MethodInfo AccessToolsLoadImage()
	{
		Type type = Type.GetType("UnityEngine.ImageConversion, UnityEngine.ImageConversionModule");
		if (type == null)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("UnityEngine.ImageConversion");
				if (type != null)
				{
					break;
				}
			}
		}
		if (type == null)
		{
			return null;
		}
		return type.GetMethod("LoadImage", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
		{
			typeof(Texture2D),
			typeof(byte[]),
			typeof(bool)
		}, null);
	}

	private static void TintDropBlue(GameObject root)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		Color val = default(Color);
		((Color)(ref val))..ctor(0.35f, 0.65f, 1f, 1f);
		Color val2 = new Color(0.25f, 0.55f, 1f, 1f) * 1.6f;
		Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
		foreach (Renderer val3 in componentsInChildren)
		{
			if ((Object)(object)val3 == (Object)null)
			{
				continue;
			}
			Material[] materials = val3.materials;
			bool flag = false;
			foreach (Material val4 in materials)
			{
				if (!((Object)(object)val4 == (Object)null))
				{
					if (val4.HasProperty("_Color"))
					{
						val4.SetColor("_Color", val);
						flag = true;
					}
					if (val4.HasProperty("_TintColor"))
					{
						val4.SetColor("_TintColor", val);
						flag = true;
					}
					if (val4.HasProperty("_EmissionColor"))
					{
						val4.EnableKeyword("_EMISSION");
						val4.SetColor("_EmissionColor", val2);
						flag = true;
					}
				}
			}
			if (flag)
			{
				val3.materials = materials;
			}
		}
		ParticleSystem[] componentsInChildren2 = root.GetComponentsInChildren<ParticleSystem>(true);
		foreach (ParticleSystem val5 in componentsInChildren2)
		{
			if (!((Object)(object)val5 == (Object)null))
			{
				MainModule main = val5.main;
				((MainModule)(ref main)).startColor = new MinMaxGradient(val);
			}
		}
		Light[] componentsInChildren3 = root.GetComponentsInChildren<Light>(true);
		foreach (Light val6 in componentsInChildren3)
		{
			if ((Object)(object)val6 != (Object)null)
			{
				val6.color = val;
			}
		}
	}
}
public class BossUnlockSystem
{
	private readonly ManualLogSource logger;

	public bool StructuresUnlocked { get; private set; }

	public bool RuneStoneUnlocked => StructuresUnlocked;

	public BossUnlockSystem(ManualLogSource logger)
	{
		this.logger = logger;
	}

	public void CheckBossProgress()
	{
		if (!((Object)(object)ZoneSystem.instance == (Object)null))
		{
			bool globalKey = ZoneSystem.instance.GetGlobalKey("defeated_gdking");
			if (globalKey && !StructuresUnlocked)
			{
				UnlockAllStructures();
			}
			else if (!globalKey && StructuresUnlocked)
			{
				StructuresUnlocked = false;
				DisableAllRunePieces();
				logger.LogInfo((object)"Runen-Gebäude gesperrt (Eikthyr in dieser Welt noch nicht besiegt).");
			}
		}
	}

	private void UnlockAllStructures()
	{
		StructuresUnlocked = true;
		Plugin.RegisterAllRunePieces();
		EnableAllRunePieces();
		logger.LogInfo((object)"The Ancients have awakened (by Morda). Rune buildings unlocked.");
	}

	public static void EnableAllRunePieces()
	{
		SetPieceEnabled("fba_runestone", enabled: true);
		SetPieceEnabled("fba_runewindmill", enabled: true);
		SetPieceEnabled("fba_runesmelter", enabled: true);
		SetPieceEnabled("fba_runeblastfurnace", enabled: true);
		SetPieceEnabled("fba_runeoven", enabled: true);
	}

	public static void DisableAllRunePieces()
	{
		SetPieceEnabled("fba_runestone", enabled: false);
		SetPieceEnabled("fba_runewindmill", enabled: false);
		SetPieceEnabled("fba_runesmelter", enabled: false);
		SetPieceEnabled("fba_runeblastfurnace", enabled: false);
		SetPieceEnabled("fba_runeoven", enabled: false);
	}

	private static void SetPieceEnabled(string prefabName, bool enabled)
	{
		try
		{
			CustomPiece piece = PieceManager.Instance.GetPiece(prefabName);
			if ((Object)(object)((piece != null) ? piece.Piece : null) != (Object)null)
			{
				piece.Piece.m_enabled = enabled;
			}
		}
		catch
		{
		}
	}
}
[HarmonyPatch(typeof(CookingStation))]
public static class CookingStationPatches
{
	private const int StatusDone = 1;

	private static RuneOven GetRuneOven(CookingStation station)
	{
		if (!((Object)(object)station != (Object)null))
		{
			return null;
		}
		return ((Component)station).GetComponent<RuneOven>();
	}

	[HarmonyPatch("OnAddFuelSwitch")]
	[HarmonyPrefix]
	private static bool OnAddFuelSwitchPrefix(CookingStation __instance, Switch sw, Humanoid user, ItemData item)
	{
		if ((Object)(object)GetRuneOven(__instance) == (Object)null)
		{
			return true;
		}
		if (user != null)
		{
			((Character)user).Message((MessageType)2, RuneLoc.T("$fba_msg_oven_no_coal"), 0, (Sprite)null);
		}
		return false;
	}

	[HarmonyPatch("OnHoverFuelSwitch")]
	[HarmonyPrefix]
	private static bool OnHoverFuelSwitchPrefix(CookingStation __instance, ref string __result)
	{
		RuneOven runeOven = GetRuneOven(__instance);
		if ((Object)(object)runeOven == (Object)null)
		{
			return true;
		}
		__result = runeOven.GetUnifiedHoverText();
		return false;
	}

	[HarmonyPatch("UpdateCooking")]
	[HarmonyPrefix]
	private static void UpdateCookingPrefix(CookingStation __instance)
	{
		RuneOven runeOven = GetRuneOven(__instance);
		if (!((Object)(object)runeOven == (Object)null))
		{
			runeOven.ApplyRuneSettings();
			runeOven.EnsureFuelFromEnergy();
		}
	}

	[HarmonyPatch("UpdateFuel")]
	[HarmonyPrefix]
	private static bool UpdateFuelPrefix(CookingStation __instance)
	{
		return (Object)(object)GetRuneOven(__instance) == (Object)null;
	}

	[HarmonyPatch("SetSlot")]
	[HarmonyPrefix]
	private static void SetSlotPrefix(CookingStation __instance, int slot, ref int __state)
	{
		__state = -1;
		if ((Object)(object)GetRuneOven(__instance) == (Object)null)
		{
			return;
		}
		ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
		if (!((Object)(object)component == (Object)null) && component.IsValid())
		{
			ZDO zDO = component.GetZDO();
			if (zDO != null)
			{
				__state = zDO.GetInt("slotstatus" + slot, 0);
			}
		}
	}

	[HarmonyPatch("SetSlot")]
	[HarmonyPostfix]
	private static void SetSlotPostfix(CookingStation __instance, int slot, int __state)
	{
		RuneOven runeOven = GetRuneOven(__instance);
		if ((Object)(object)runeOven == (Object)null)
		{
			return;
		}
		ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
		if ((Object)(object)component == (Object)null || !component.IsValid())
		{
			return;
		}
		ZDO zDO = component.GetZDO();
		if (zDO != null)
		{
			int num = zDO.GetInt("slotstatus" + slot, 0);
			if (__state != 1 && num == 1 && ZNetHelper.IsOwner(component))
			{
				runeOven.ConsumeCookEnergy();
				RuneInvoke.CookAutoDropSlot(__instance, slot);
			}
		}
	}

	[HarmonyPatch("GetHoverText")]
	[HarmonyPostfix]
	private static void GetHoverTextPostfix(CookingStation __instance, ref string __result)
	{
		RuneOven runeOven = GetRuneOven(__instance);
		if (!((Object)(object)runeOven == (Object)null))
		{
			__result = runeOven.GetUnifiedHoverText();
		}
	}

	[HarmonyPatch("Interact")]
	[HarmonyPrefix]
	private static bool InteractPrefix(CookingStation __instance, Humanoid user, bool hold, bool alt, ref bool __result)
	{
		if ((Object)(object)GetRuneOven(__instance) == (Object)null)
		{
			return true;
		}
		if (hold || (Object)(object)user == (Object)null)
		{
			__result = false;
			return false;
		}
		__result = RuneInvoke.CookInteract(__instance, user);
		return false;
	}

	[HarmonyPatch("UseItem")]
	[HarmonyPrefix]
	private static bool UseItemPrefix(CookingStation __instance, Humanoid user, ItemData item, ref bool __result)
	{
		if ((Object)(object)GetRuneOven(__instance) == (Object)null)
		{
			return true;
		}
		if ((Object)(object)user == (Object)null || item == null)
		{
			__result = false;
			return false;
		}
		__result = RuneInvoke.CookUseItem(__instance, user, item);
		return false;
	}
}
internal static class CursorLog
{
}
[BepInPlugin("com.forgedbyancients.core", "Forged by the Ancients", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
	public const string ModGuid = "com.forgedbyancients.core";

	public const string ModName = "Forged by the Ancients";

	public const string ModVersion = "1.0.0";

	public const string ModAuthor = "Morda";

	public static ManualLogSource Log;

	public static BossUnlockSystem BossUnlock;

	private Harmony harmony;

	private static bool piecesLogged;

	private void Awake()
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Forged by the Ancients v1.0.0 by Morda loaded.");
		RuneLocalization.Register();
		RuneModConfig.Bind(((BaseUnityPlugin)this).Config);
		BossUnlock = new BossUnlockSystem(((BaseUnityPlugin)this).Logger);
		PrefabManager.OnVanillaPrefabsAvailable += RegisterPieces;
		harmony = new Harmony("com.forgedbyancients.core.harmony");
		try
		{
			harmony.PatchAll(typeof(SmelterPatches));
			harmony.PatchAll(typeof(CookingStationPatches));
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Harmony patches failed: " + ex));
		}
	}

	private void Update()
	{
		BossUnlock?.CheckBossProgress();
	}

	private void RegisterPieces()
	{
		RegisterAllRunePieces();
		if (BossUnlock != null && BossUnlock.StructuresUnlocked)
		{
			BossUnlockSystem.EnableAllRunePieces();
		}
		PrefabManager.OnVanillaPrefabsAvailable -= RegisterPieces;
	}

	internal static void RegisterAllRunePieces()
	{
		bool enabled = BossUnlock != null && BossUnlock.StructuresUnlocked;
		AncientCoreItem.Register();
		RuneStonePiece.Register(enabled);
		RuneWindmillPiece.Register(enabled);
		RuneSmelterPiece.Register(enabled);
		RuneBlastFurnacePiece.Register(enabled);
		RuneOvenPiece.Register(enabled);
		if (!piecesLogged)
		{
			piecesLogged = true;
			Log.LogInfo((object)("Pieces registered (unlocked=" + enabled + "). Author: Morda"));
		}
	}

	private void OnDestroy()
	{
		PrefabManager.OnVanillaPrefabsAvailable -= RegisterPieces;
		Harmony obj = harmony;
		if (obj != null)
		{
			obj.UnpatchSelf();
		}
	}
}
public static class RuneBlastFurnacePiece
{
	private static bool registered;

	public static void Register(bool enabled)
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Expected O, but got Unknown
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Expected O, but got Unknown
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Expected O, but got Unknown
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Expected O, but got Unknown
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Expected O, but got Unknown
		if (registered)
		{
			BossUnlockSystem.EnableAllRunePieces();
			return;
		}
		registered = true;
		CustomPiece val = new CustomPiece("fba_runeblastfurnace", "blastfurnace", RunePieceHelper.BaseConfig("$piece_fba_runeblastfurnace", "$piece_fba_runeblastfurnace_description", "Crafting", enabled, (RequirementConfig[])(object)new RequirementConfig[4]
		{
			new RequirementConfig("Stone", 20, 0, true),
			new RequirementConfig("Silver", 10, 0, true),
			new RequirementConfig("fba_ancientcore", 5, 0, true),
			new RequirementConfig("Copper", 5, 0, true)
		}));
		GameObject piecePrefab = val.PiecePrefab;
		RunePieceHelper.ClearStationExtension(piecePrefab);
		Piece component = piecePrefab.GetComponent<Piece>();
		if ((Object)(object)component != (Object)null)
		{
			component.m_name = "$piece_fba_runeblastfurnace";
			component.m_description = "$piece_fba_runeblastfurnace_description";
			component.m_enabled = enabled;
			RunePieceHelper.SoftenPlacement(component);
			RunePieceHelper.BindWorkbench(component);
		}
		RuneSmelter runeSmelter = piecePrefab.GetComponent<RuneSmelter>();
		if ((Object)(object)runeSmelter == (Object)null)
		{
			runeSmelter = piecePrefab.AddComponent<RuneSmelter>();
		}
		runeSmelter.DisplayName = "$piece_fba_runeblastfurnace";
		Smelter component2 = piecePrefab.GetComponent<Smelter>();
		if ((Object)(object)component2 != (Object)null)
		{
			component2.m_name = "$piece_fba_runeblastfurnace";
		}
		if ((Object)(object)piecePrefab.GetComponent<RuneSmelterHover>() == (Object)null)
		{
			piecePrefab.AddComponent<RuneSmelterHover>();
		}
		PieceManager.Instance.AddPiece(val);
	}
}
public abstract class RuneBuildingBase : MonoBehaviour
{
	public RuneStoneEnergy GetRuneStone()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		return RuneNetwork.GetNearestRuneStone(((Component)this).transform.position, RuneNetworkConfig.RuneStoneRange);
	}

	protected bool HasRuneEnergy(int amount)
	{
		RuneStoneEnergy runeStone = GetRuneStone();
		if ((Object)(object)runeStone != (Object)null)
		{
			return runeStone.CurrentEnergy >= amount;
		}
		return false;
	}

	protected bool ConsumeRuneEnergy(int amount)
	{
		RuneStoneEnergy runeStone = GetRuneStone();
		if ((Object)(object)runeStone == (Object)null)
		{
			return false;
		}
		return runeStone.ConsumeEnergy(amount);
	}

	protected void AddRuneEnergy(int amount)
	{
		GetRuneStone()?.AddEnergy(amount);
	}
}
public static class RuneEffectHelper
{
	private static readonly Color RuneBlue = new Color(0.25f, 0.55f, 1f, 1f);

	private static readonly Color RuneBlueSoft = new Color(0.35f, 0.65f, 1f, 0.85f);

	private static readonly string[] FlameNames = new string[7] { "flames", "flames (1)", "flames (2)", "flare", "flare (1)", "flare (2)", "flare (3)" };

	private static readonly string[] SmokeNames = new string[2] { "smoke (1)", "SmokeSpawner" };

	private static readonly string[] HideNames = new string[1] { "Cube" };

	private static readonly string[] LightNames = new string[3] { "Point light", "Point light (1)", "FireWarmth" };

	public static ParticleSystem CreateRuneParticles(GameObject parent, Vector3 position, float scale = 1f)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: 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)
		if ((Object)(object)ZNetScene.instance == (Object)null)
		{
			return null;
		}
		GameObject prefab = ZNetScene.instance.GetPrefab("vfx_HealthUpgrade");
		if ((Object)(object)prefab == (Object)null)
		{
			return null;
		}
		GameObject obj = Object.Instantiate<GameObject>(prefab, parent.transform);
		((Object)obj).name = "AncientRuneMagicEffect";
		obj.transform.localPosition = position;
		obj.transform.localRotation = Quaternion.identity;
		obj.transform.localScale = Vector3.one * scale;
		ParticleSystem componentInChildren = obj.GetComponentInChildren<ParticleSystem>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren.Play();
		}
		return componentInChildren;
	}

	public static void ApplyBlueSmelterFire(GameObject smelterRoot)
	{
		if ((Object)(object)smelterRoot == (Object)null || (Object)(object)smelterRoot.transform.Find("AncientBlueTorchFire") != (Object)null)
		{
			return;
		}
		Transform val = FindEnabledRoot(smelterRoot);
		if ((Object)(object)val == (Object)null)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)"RuneEffectHelper: _enabled nicht gefunden.");
			}
		}
		else
		{
			TintExistingFire(val);
			TryAttachBlueTorchFx(val);
		}
	}

	public static void ApplyBlueCookingFire(GameObject ovenRoot, CookingStation station)
	{
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)ovenRoot == (Object)null || (Object)(object)FindChildRecursive(ovenRoot.transform, "AncientBlueTorchFire") != (Object)null)
		{
			return;
		}
		TintExistingFire(ovenRoot.transform);
		if ((Object)(object)station != (Object)null)
		{
			if ((Object)(object)station.m_haveFuelObject != (Object)null)
			{
				TintExistingFire(station.m_haveFuelObject.transform);
			}
			if ((Object)(object)station.m_haveFireObject != (Object)null)
			{
				TintExistingFire(station.m_haveFireObject.transform);
				TryAttachBlueTorchFx(station.m_haveFireObject.transform);
			}
			else if ((Object)(object)station.m_haveFuelObject != (Object)null)
			{
				TryAttachBlueTorchFx(station.m_haveFuelObject.transform);
			}
		}
		ParticleSystem[] componentsInChildren = ovenRoot.GetComponentsInChildren<ParticleSystem>(true);
		foreach (ParticleSystem val in componentsInChildren)
		{
			if (!((Object)(object)val == (Object)null))
			{
				string text = ((Object)((Component)val).gameObject).name.ToLowerInvariant();
				if (text.Contains("smoke") || text.Contains("flame") || text.Contains("flare") || text.Contains("fire") || text.Contains("coal") || text.Contains("ember") || text.Contains("spark"))
				{
					TintParticleSystem(val, RuneBlueSoft);
				}
			}
		}
		Light[] componentsInChildren2 = ovenRoot.GetComponentsInChildren<Light>(true);
		foreach (Light val2 in componentsInChildren2)
		{
			if ((Object)(object)val2 != (Object)null)
			{
				val2.color = RuneBlue;
			}
		}
	}

	private static void TintExistingFire(Transform enabledRoot)
	{
		//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_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: 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_01ae: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)enabledRoot == (Object)null)
		{
			return;
		}
		Transform[] componentsInChildren = ((Component)enabledRoot).GetComponentsInChildren<Transform>(true);
		foreach (Transform val in componentsInChildren)
		{
			if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)enabledRoot)
			{
				continue;
			}
			string name = ((Object)val).name;
			if (NameMatches(name, HideNames))
			{
				((Component)val).gameObject.SetActive(false);
				continue;
			}
			bool num = NameMatches(name, FlameNames);
			bool flag = NameMatches(name, SmokeNames);
			bool flag2 = NameMatches(name, LightNames);
			string text = name.ToLowerInvariant();
			bool flag3 = text.Contains("coal") || text.Contains("ember") || text.Contains("fire") || text.Contains("burn");
			if (!num && !flag && !flag2 && !flag3)
			{
				continue;
			}
			((Component)val).gameObject.SetActive(true);
			Color color = RuneBlueSoft;
			if (name == "FireWarmth")
			{
				((Color)(ref color))..ctor(0.45f, 0.7f, 1f, 0.55f);
			}
			else if (flag)
			{
				((Color)(ref color))..ctor(0.4f, 0.65f, 1f, 0.45f);
			}
			else if (flag2)
			{
				color = RuneBlue;
			}
			ParticleSystem[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val2 in componentsInChildren2)
			{
				TintParticleSystem(val2, color);
				if (!val2.isPlaying)
				{
					val2.Play();
				}
			}
			Light[] componentsInChildren3 = ((Component)val).GetComponentsInChildren<Light>(true);
			foreach (Light val3 in componentsInChildren3)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					((Behaviour)val3).enabled = true;
					val3.color = (Color)((name == "FireWarmth") ? new Color(0.45f, 0.7f, 1f, 1f) : RuneBlue);
				}
			}
			Renderer[] componentsInChildren4 = ((Component)val).GetComponentsInChildren<Renderer>(true);
			for (int j = 0; j < componentsInChildren4.Length; j++)
			{
				TintRenderer(componentsInChildren4[j]);
			}
		}
	}

	private static void TryAttachBlueTorchFx(Transform enabledRoot)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Expected O, but got Unknown
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: 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_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)enabledRoot == (Object)null || (Object)(object)FindChildRecursive(enabledRoot, "AncientBlueTorchFire") != (Object)null)
		{
			return;
		}
		GameObject val = FindBlueTorchPrefab();
		if ((Object)(object)val == (Object)null)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)"RuneEffectHelper: piece_groundtorch_blue nicht gefunden – nutze nur eingefärbte Flammen.");
			}
			return;
		}
		GameObject val2 = new GameObject("AncientBlueTorchFire");
		val2.transform.SetParent(enabledRoot, false);
		val2.transform.localPosition = Vector3.zero;
		val2.transform.localRotation = Quaternion.identity;
		val2.transform.localScale = Vector3.one;
		Transform val3 = FindChildRecursive(val.transform, "_enabled");
		if ((Object)(object)val3 != (Object)null)
		{
			CopyChildIfExists(val3, val2.transform, "Point light");
			CopyChildIfExists(val3, val2.transform, "FireWarmth");
		}
		Transform val4 = FindChildRecursive(val.transform, "fx_Torch_Blue");
		if ((Object)(object)val4 != (Object)null)
		{
			GameObject obj = Object.Instantiate<GameObject>(((Component)val4).gameObject, val2.transform);
			((Object)obj).name = "fx_Torch_Blue";
			obj.transform.localPosition = Vector3.zero;
			obj.transform.localRotation = Quaternion.identity;
			obj.transform.localScale = Vector3.one;
			obj.SetActive(true);
			PlayParticles(obj);
		}
	}

	private static void CopyChildIfExists(Transform sourceRoot, Transform target, string childName)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		Transform val = FindChildRecursive(sourceRoot, childName);
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		GameObject obj = Object.Instantiate<GameObject>(((Component)val).gameObject, target);
		((Object)obj).name = ((Object)val).name;
		obj.transform.localPosition = val.localPosition;
		obj.transform.localRotation = val.localRotation;
		obj.transform.localScale = val.localScale;
		obj.SetActive(true);
		Light[] componentsInChildren = obj.GetComponentsInChildren<Light>(true);
		foreach (Light val2 in componentsInChildren)
		{
			if ((Object)(object)val2 != (Object)null)
			{
				((Behaviour)val2).enabled = true;
				val2.color = RuneBlue;
			}
		}
	}

	private static void TintParticleSystem(ParticleSystem ps, Color color)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Expected O, but got Unknown
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)ps == (Object)null))
		{
			MainModule main = ps.main;
			((MainModule)(ref main)).startColor = new MinMaxGradient(color);
			ColorOverLifetimeModule colorOverLifetime = ps.colorOverLifetime;
			if (((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled)
			{
				Gradient val = new Gradient();
				val.SetKeys((GradientColorKey[])(object)new GradientColorKey[2]
				{
					new GradientColorKey(color, 0f),
					new GradientColorKey(Color.Lerp(color, Color.white, 0.35f), 1f)
				}, (GradientAlphaKey[])(object)new GradientAlphaKey[2]
				{
					new GradientAlphaKey(color.a, 0f),
					new GradientAlphaKey(0f, 1f)
				});
				((ColorOverLifetimeModule)(ref colorOverLifetime)).color = new MinMaxGradient(val);
			}
		}
	}

	private static void TintRenderer(Renderer renderer)
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)renderer == (Object)null)
		{
			return;
		}
		Material[] materials = renderer.materials;
		foreach (Material val in materials)
		{
			if (!((Object)(object)val == (Object)null))
			{
				if (val.HasProperty("_Color"))
				{
					val.SetColor("_Color", RuneBlueSoft);
				}
				if (val.HasProperty("_TintColor"))
				{
					val.SetColor("_TintColor", RuneBlueSoft);
				}
				if (val.HasProperty("_EmissionColor"))
				{
					val.EnableKeyword("_EMISSION");
					val.SetColor("_EmissionColor", RuneBlue * 1.2f);
				}
			}
		}
	}

	private static bool NameMatches(string name, string[] list)
	{
		foreach (string text in list)
		{
			if (name == text)
			{
				return true;
			}
		}
		return false;
	}

	private static GameObject FindBlueTorchPrefab()
	{
		string[] array = new string[5]
		{
			RuneNetworkConfig.BlueFireSourcePrefab,
			"piece_groundtorch_blue",
			"piece_groundtorchblue",
			"piece_groundtorchblue",
			RuneNetworkConfig.BlueFireFallbackPrefab
		};
		foreach (string text in array)
		{
			if (string.IsNullOrEmpty(text))
			{
				continue;
			}
			GameObject val = null;
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				val = ZNetScene.instance.GetPrefab(text);
			}
			if ((Object)(object)val == (Object)null)
			{
				try
				{
					val = PrefabManager.Instance.GetPrefab(text);
				}
				catch
				{
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
		}
		return null;
	}

	private static Transform FindEnabledRoot(GameObject smelterRoot)
	{
		Smelter component = smelterRoot.GetComponent<Smelter>();
		if ((Object)(object)component != (Object)null && (Object)(object)component.m_enabledObject != (Object)null)
		{
			return component.m_enabledObject.transform;
		}
		return FindChildRecursive(smelterRoot.transform, "_enabled");
	}

	private static Transform FindChildRecursive(Transform root, string name)
	{
		if ((Object)(object)root == (Object)null)
		{
			return null;
		}
		if (((Object)root).name == name)
		{
			return root;
		}
		for (int i = 0; i < root.childCount; i++)
		{
			Transform val = FindChildRecursive(root.GetChild(i), name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
		}
		return null;
	}

	private static void PlayParticles(GameObject root)
	{
		ParticleSystem[] componentsInChildren = root.GetComponentsInChildren<ParticleSystem>(true);
		foreach (ParticleSystem val in componentsInChildren)
		{
			if ((Object)(object)val != (Object)null)
			{
				val.Play();
			}
		}
	}

	public static void ApplyRuneStoneBlueWayEffect(GameObject stoneRoot)
	{
		if (!((Object)(object)stoneRoot == (Object)null))
		{
			DisableRadiusMarker(stoneRoot);
			TintOdenGlowMaterials(stoneRoot);
		}
	}

	public static void DisableRadiusMarker(GameObject stoneRoot)
	{
		if ((Object)(object)stoneRoot == (Object)null)
		{
			return;
		}
		CircleProjector[] componentsInChildren = stoneRoot.GetComponentsInChildren<CircleProjector>(true);
		foreach (CircleProjector val in componentsInChildren)
		{
			if (!((Object)(object)val == (Object)null))
			{
				DestroyProjectorSegments(val);
				((Behaviour)val).enabled = false;
				((Component)val).gameObject.SetActive(false);
			}
		}
		string[] array = new string[8] { "WayEffect", "AreaMarker", "areamarker", "EnabledEffect", "InRangeEffect", "ConnectEffect", "Flash", "shield" };
		Transform[] componentsInChildren2 = stoneRoot.GetComponentsInChildren<Transform>(true);
		foreach (Transform val2 in componentsInChildren2)
		{
			if ((Object)(object)val2 == (Object)null || (Object)(object)val2 == (Object)(object)stoneRoot.transform)
			{
				continue;
			}
			string text = ((Object)val2).name.ToLowerInvariant();
			bool flag = false;
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				if (text == text2.ToLowerInvariant() || text.Contains(text2.ToLowerInvariant()))
				{
					flag = true;
					break;
				}
			}
			if (text.Contains("model") || text.Contains("mesh") || text.Contains("stone") || text.Contains("oden") || !flag)
			{
				continue;
			}
			((Component)val2).gameObject.SetActive(false);
			ParticleSystem[] componentsInChildren3 = ((Component)val2).GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val3 in componentsInChildren3)
			{
				if ((Object)(object)val3 != (Object)null)
				{
					val3.Stop(true, (ParticleSystemStopBehavior)0);
				}
			}
		}
	}

	private static void DestroyProjectorSegments(CircleProjector projector)
	{
		if ((Object)(object)projector == (Object)null)
		{
			return;
		}
		try
		{
			IList value = Traverse.Create((object)projector).Field("m_segments").GetValue<IList>();
			if (value == null)
			{
				return;
			}
			for (int num = value.Count - 1; num >= 0; num--)
			{
				object? obj = value[num];
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
			value.Clear();
		}
		catch
		{
		}
	}

	private static void TintOdenGlowMaterials(GameObject root)
	{
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: 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_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
		foreach (Renderer val in componentsInChildren)
		{
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			Material[] materials = val.materials;
			bool flag = false;
			foreach (Material val2 in materials)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				string text = ((Object)val2).name.Replace(" (Instance)", "");
				if (!(text != "Guardstone_OdenGlow_mat") || text.Contains("OdenGlow"))
				{
					if (val2.HasProperty("_Color"))
					{
						val2.SetColor("_Color", RuneBlueSoft);
					}
					if (val2.HasProperty("_TintColor"))
					{
						val2.SetColor("_TintColor", RuneBlueSoft);
					}
					if (val2.HasProperty("_EmissionColor"))
					{
						val2.EnableKeyword("_EMISSION");
						val2.SetColor("_EmissionColor", RuneBlue * 1.4f);
					}
					if (val2.HasProperty("_EmissionColor"))
					{
						val2.SetColor("_EmissionColor", RuneBlue * 2f);
					}
					flag = true;
				}
			}
			if (flag)
			{
				val.materials = materials;
			}
		}
	}
}
public static class RuneModConfig
{
	public static ConfigEntry<int> WindmillEnergyLight;

	public static ConfigEntry<int> WindmillEnergyMedium;

	public static ConfigEntry<int> WindmillEnergyStrong;

	public static ConfigEntry<int> WindmillEnergyStorm;

	public static ConfigEntry<int> EnergyPerOre;

	public static ConfigEntry<int> EnergyPerCook;

	public static ConfigEntry<int> RuneStoneMaxEnergy;

	public static ConfigEntry<int> SmelterMaxOre;

	public static ConfigEntry<float> SmeltSpeedMultiplier;

	public static ConfigEntry<float> CookSpeedMultiplier;

	public static ConfigEntry<float> WindmillConnectRange;

	public static ConfigEntry<float> SmelterConnectRange;

	public static ConfigEntry<float> StoneConnectRange;

	public static void Bind(ConfigFile config)
	{
		WindmillEnergyLight = ConfigFileExtensions.BindConfig<int>(config, "Windrad", "EnergieLeichterWind", 2, "Energie pro Sekunde bei leichtem Wind", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		WindmillEnergyMedium = ConfigFileExtensions.BindConfig<int>(config, "Windrad", "EnergieMittlererWind", 4, "Energie pro Sekunde bei mittlerem Wind", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		WindmillEnergyStrong = ConfigFileExtensions.BindConfig<int>(config, "Windrad", "EnergieStarkerWind", 6, "Energie pro Sekunde bei starkem Wind", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		WindmillEnergyStorm = ConfigFileExtensions.BindConfig<int>(config, "Windrad", "EnergieSturm", 8, "Energie pro Sekunde bei Sturm", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		EnergyPerOre = ConfigFileExtensions.BindConfig<int>(config, "Runenschmelze", "EnergieProErz", 20, "Runenenergie-Kosten pro fertig geschmolzenem Erz (Runenschmelze & Runen Hochofen)", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		EnergyPerCook = ConfigFileExtensions.BindConfig<int>(config, "RunenSteinofen", "EnergieProGericht", 20, "Runenenergie-Kosten pro fertig gegartem Essen (Runen Steinofen)", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		SmelterMaxOre = ConfigFileExtensions.BindConfig<int>(config, "Runenschmelze", "MaxErz", 50, "Wie viel Erz Runenschmelze und Runen Hochofen aufnehmen können", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		SmeltSpeedMultiplier = ConfigFileExtensions.BindConfig<float>(config, "Runenschmelze", "SchmelzGeschwindigkeit", 3f, "Produktions-Multiplikator für Runenschmelze und Runen Hochofen (3 = dreimal so schnell)", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		CookSpeedMultiplier = ConfigFileExtensions.BindConfig<float>(config, "RunenSteinofen", "GarGeschwindigkeit", 3f, "Produktions-Multiplikator für Runen Steinofen (3 = dreimal so schnell)", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		RuneStoneMaxEnergy = ConfigFileExtensions.BindConfig<int>(config, "Runenstein", "MaxEnergie", 5000, "Maximaler Energiespeicher des Runensteins", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		WindmillConnectRange = ConfigFileExtensions.BindConfig<float>(config, "Netzwerk", "RadiusWindrad", 100f, "Reichweite Windrad → Runenstein in Metern (horizontal)", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		SmelterConnectRange = ConfigFileExtensions.BindConfig<float>(config, "Netzwerk", "RadiusRunenschmelze", 100f, "Reichweite Schmelze / Hochofen / Steinofen → Runenstein in Metern (horizontal)", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		StoneConnectRange = ConfigFileExtensions.BindConfig<float>(config, "Netzwerk", "RadiusRunenstein", 100f, "Reichweite Runenstein-Verbindungen in Metern (horizontal)", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		ApplyToRuntime();
		config.SettingChanged += delegate
		{
			ApplyToRuntime();
		};
		SynchronizationManager.OnConfigurationSynchronized += delegate
		{
			ApplyToRuntime();
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"Runen-Config vom Server synchronisiert.");
			}
		};
	}

	public static void ApplyToRuntime()
	{
		if (WindmillEnergyLight != null)
		{
			RuneNetworkConfig.WindmillEnergyLight = WindmillEnergyLight.Value;
			RuneNetworkConfig.WindmillEnergyMedium = WindmillEnergyMedium.Value;
			RuneNetworkConfig.WindmillEnergyStrong = WindmillEnergyStrong.Value;
			RuneNetworkConfig.WindmillEnergyStorm = WindmillEnergyStorm.Value;
			RuneNetworkConfig.EnergyPerOre = EnergyPerOre.Value;
			RuneNetworkConfig.EnergyPerCook = EnergyPerCook.Value;
			RuneNetworkConfig.RuneStoneMaxEnergy = RuneStoneMaxEnergy.Value;
			RuneNetworkConfig.SmelterMaxOre = SmelterMaxOre.Value;
			RuneNetworkConfig.SmeltSpeedMultiplier = SmeltSpeedMultiplier.Value;
			RuneNetworkConfig.CookSpeedMultiplier = CookSpeedMultiplier.Value;
			RuneNetworkConfig.WindmillSearchRange = WindmillConnectRange.Value;
			RuneNetworkConfig.RuneStoneRange = SmelterConnectRange.Value;
			RuneNetworkConfig.StoneConnectRange = StoneConnectRange.Value;
		}
	}
}
public static class RuneNetwork
{
	private static readonly List<RuneStoneEnergy> runeStones = new List<RuneStoneEnergy>();

	private static readonly List<RuneSmelter> runeSmelters = new List<RuneSmelter>();

	private static readonly List<RuneOven> runeOvens = new List<RuneOven>();

	private static readonly List<RuneWindmill> runeWindmills = new List<RuneWindmill>();

	public static void RegisterRuneStone(RuneStoneEnergy stone)
	{
		if (!((Object)(object)stone == (Object)null) && !runeStones.Contains(stone))
		{
			runeStones.Add(stone);
		}
	}

	public static void UnregisterRuneStone(RuneStoneEnergy stone)
	{
		runeStones.Remove(stone);
	}

	public static void RegisterSmelter(RuneSmelter smelter)
	{
		if (!((Object)(object)smelter == (Object)null) && !runeSmelters.Contains(smelter))
		{
			runeSmelters.Add(smelter);
		}
	}

	public static void UnregisterSmelter(RuneSmelter smelter)
	{
		runeSmelters.Remove(smelter);
	}

	public static void RegisterOven(RuneOven oven)
	{
		if (!((Object)(object)oven == (Object)null) && !runeOvens.Contains(oven))
		{
			runeOvens.Add(oven);
		}
	}

	public static void UnregisterOven(RuneOven oven)
	{
		runeOvens.Remove(oven);
	}

	public static void RegisterWindmill(RuneWindmill windmill)
	{
		if (!((Object)(object)windmill == (Object)null) && !runeWindmills.Contains(windmill))
		{
			runeWindmills.Add(windmill);
		}
	}

	public static void UnregisterWindmill(RuneWindmill windmill)
	{
		runeWindmills.Remove(windmill);
	}

	public static float DistanceMeters(Vector3 a, Vector3 b)
	{
		//IL_0000: 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_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		float num = a.x - b.x;
		float num2 = a.z - b.z;
		return Mathf.Sqrt(num * num + num2 * num2);
	}

	public static RuneStoneEnergy GetNearestRuneStone(Vector3 position, float radiusMeters)
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		RuneStoneEnergy result = null;
		float num = radiusMeters;
		for (int num2 = runeStones.Count - 1; num2 >= 0; num2--)
		{
			RuneStoneEnergy runeStoneEnergy = runeStones[num2];
			if ((Object)(object)runeStoneEnergy == (Object)null)
			{
				runeStones.RemoveAt(num2);
			}
			else
			{
				float num3 = DistanceMeters(position, ((Component)runeStoneEnergy).transform.position);
				if (num3 < num)
				{
					num = num3;
					result = runeStoneEnergy;
				}
			}
		}
		return result;
	}

	public static int CountSmeltersConnectedTo(RuneStoneEnergy stone)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)stone == (Object)null)
		{
			return 0;
		}
		int num = 0;
		float stoneConnectRange = RuneNetworkConfig.StoneConnectRange;
		for (int num2 = runeSmelters.Count - 1; num2 >= 0; num2--)
		{
			RuneSmelter runeSmelter = runeSmelters[num2];
			if ((Object)(object)runeSmelter == (Object)null)
			{
				runeSmelters.RemoveAt(num2);
			}
			else if (!(DistanceMeters(((Component)runeSmelter).transform.position, ((Component)stone).transform.position) > stoneConnectRange) && (Object)(object)GetNearestRuneStone(((Component)runeSmelter).transform.position, RuneNetworkConfig.RuneStoneRange) == (Object)(object)stone)
			{
				num++;
			}
		}
		for (int num3 = runeOvens.Count - 1; num3 >= 0; num3--)
		{
			RuneOven runeOven = runeOvens[num3];
			if ((Object)(object)runeOven == (Object)null)
			{
				runeOvens.RemoveAt(num3);
			}
			else if (!(DistanceMeters(((Component)runeOven).transform.position, ((Component)stone).transform.position) > stoneConnectRange) && (Object)(object)GetNearestRuneStone(((Component)runeOven).transform.position, RuneNetworkConfig.RuneStoneRange) == (Object)(object)stone)
			{
				num++;
			}
		}
		return num;
	}

	public static int CountWindmillsConnectedTo(RuneStoneEnergy stone)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)stone == (Object)null)
		{
			return 0;
		}
		int num = 0;
		float stoneConnectRange = RuneNetworkConfig.StoneConnectRange;
		for (int num2 = runeWindmills.Count - 1; num2 >= 0; num2--)
		{
			RuneWindmill runeWindmill = runeWindmills[num2];
			if ((Object)(object)runeWindmill == (Object)null)
			{
				runeWindmills.RemoveAt(num2);
			}
			else if (!(DistanceMeters(((Component)runeWindmill).transform.position, ((Component)stone).transform.position) > stoneConnectRange) && (Object)(object)GetNearestRuneStone(((Component)runeWindmill).transform.position, RuneNetworkConfig.WindmillSearchRange) == (Object)(object)stone)
			{
				num++;
			}
		}
		return num;
	}

	public static int GetWindmillEnergyPerSecondFor(RuneStoneEnergy stone)
	{
		//IL_0053: 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_0072: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)stone == (Object)null)
		{
			return 0;
		}
		int num = 0;
		int currentEnergyOutput = RuneWindmill.GetCurrentEnergyOutput();
		float stoneConnectRange = RuneNetworkConfig.StoneConnectRange;
		for (int num2 = runeWindmills.Count - 1; num2 >= 0; num2--)
		{
			RuneWindmill runeWindmill = runeWindmills[num2];
			if ((Object)(object)runeWindmill == (Object)null)
			{
				runeWindmills.RemoveAt(num2);
			}
			else if (!(DistanceMeters(((Component)runeWindmill).transform.position, ((Component)stone).transform.position) > stoneConnectRange) && (Object)(object)GetNearestRuneStone(((Component)runeWindmill).transform.position, RuneNetworkConfig.WindmillSearchRange) == (Object)(object)stone)
			{
				num += currentEnergyOutput;
			}
		}
		return num;
	}
}
public static class RuneNetworkConfig
{
	public static float SmeltSpeedMultiplier = 3f;

	public static float CookSpeedMultiplier = 3f;

	public static int EnergyPerOre = 20;

	public static int EnergyPerCook = 20;

	public static float RuneStoneRange = 100f;

	public static float WindmillSearchRange = 100f;

	public static float StoneConnectRange = 100f;

	public static int RuneStoneMaxEnergy = 5000;

	public static int SmelterMaxOre = 50;

	public static float WindmillMediumThreshold = 0.35f;

	public static float WindmillStrongThreshold = 0.55f;

	public static float WindmillStormThreshold = 0.75f;

	public static int WindmillEnergyLight = 2;

	public static int WindmillEnergyMedium = 4;

	public static int WindmillEnergyStrong = 6;

	public static int WindmillEnergyStorm = 8;

	public static string BlueFireSourcePrefab = "piece_groundtorch_blue";

	public static string BlueFireFallbackPrefab = "piece_brazierfloor02";
}
public static class RuneColors
{
	public const string Blue = "#66AAFF";

	public const string BlueSoft = "#55CCFF";
}
internal static class RuneInvoke
{
	private static readonly MethodInfo SmelterOnAddOre = AccessTools.Method(typeof(Smelter), "OnAddOre", new Type[3]
	{
		typeof(Switch),
		typeof(Humanoid),
		typeof(ItemData)
	}, (Type[])null);

	private static readonly MethodInfo SmelterOnEmpty = AccessTools.Method(typeof(Smelter), "OnEmpty", new Type[3]
	{
		typeof(Switch),
		typeof(Humanoid),
		typeof(ItemData)
	}, (Type[])null);

	private static readonly MethodInfo SmelterGetQueueSize = AccessTools.Method(typeof(Smelter), "GetQueueSize", (Type[])null, (Type[])null);

	private static readonly MethodInfo SmelterGetProcessed = AccessTools.Method(typeof(Smelter), "GetProcessedQueueSize", (Type[])null, (Type[])null);

	private static readonly MethodInfo CookOnInteract = AccessTools.Method(typeof(CookingStation), "OnInteract", new Type[1] { typeof(Humanoid) }, (Type[])null);

	private static readonly MethodInfo CookOnUseItem = AccessTools.Method(typeof(CookingStation), "OnUseItem", new Type[2]
	{
		typeof(Humanoid),
		typeof(ItemData)
	}, (Type[])null);

	private static readonly MethodInfo CookIsEmpty = AccessTools.Method(typeof(CookingStation), "IsEmpty", (Type[])null, (Type[])null);

	private static readonly MethodInfo CookSetSlot = AccessTools.Method(typeof(CookingStation), "SetSlot", (Type[])null, (Type[])null);

	private static readonly MethodInfo CookSpawnItem = AccessTools.Method(typeof(CookingStation), "SpawnItem", (Type[])null, (Type[])null);

	private static readonly Type CookStatusType = AccessTools.Inner(typeof(CookingStation), "Status");

	public static bool SmelterAddOre(Smelter smelter, Humanoid user, ItemData item)
	{
		if ((Object)(object)smelter == (Object)null || (Object)(object)user == (Object)null || SmelterOnAddOre == null)
		{
			return false;
		}
		try
		{
			return (bool)SmelterOnAddOre.Invoke(smelter, new object[3] { smelter.m_addOreSwitch, user, item });
		}
		catch (Exception ex)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("SmelterAddOre failed: " + ex.Message));
			}
			return false;
		}
	}

	public static bool SmelterEmpty(Smelter smelter, Humanoid user)
	{
		if ((Object)(object)smelter == (Object)null || (Object)(object)user == (Object)null || SmelterOnEmpty == null)
		{
			return false;
		}
		try
		{
			return (bool)SmelterOnEmpty.Invoke(smelter, new object[3] { smelter.m_emptyOreSwitch, user, null });
		}
		catch (Exception ex)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("SmelterEmpty failed: " + ex.Message));
			}
			return false;
		}
	}

	public static int SmelterQueue(Smelter smelter)
	{
		if ((Object)(object)smelter == (Object)null || SmelterGetQueueSize == null)
		{
			return 0;
		}
		try
		{
			return (int)SmelterGetQueueSize.Invoke(smelter, null);
		}
		catch
		{
			return 0;
		}
	}

	public static int SmelterReady(Smelter smelter)
	{
		if ((Object)(object)smelter == (Object)null || SmelterGetProcessed == null)
		{
			return 0;
		}
		try
		{
			return (int)SmelterGetProcessed.Invoke(smelter, null);
		}
		catch
		{
			return 0;
		}
	}

	public static bool CookInteract(CookingStation station, Humanoid user)
	{
		if ((Object)(object)station == (Object)null || (Object)(object)user == (Object)null || CookOnInteract == null)
		{
			return false;
		}
		try
		{
			return (bool)CookOnInteract.Invoke(station, new object[1] { user });
		}
		catch (Exception ex)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("CookInteract failed: " + ex.Message));
			}
			return false;
		}
	}

	public static bool CookUseItem(CookingStation station, Humanoid user, ItemData item)
	{
		if ((Object)(object)station == (Object)null || (Object)(object)user == (Object)null || item == null || CookOnUseItem == null)
		{
			return false;
		}
		try
		{
			return (bool)CookOnUseItem.Invoke(station, new object[2] { user, item });
		}
		catch (Exception ex)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("CookUseItem failed: " + ex.Message));
			}
			return false;
		}
	}

	public static bool CookIsEmptyStation(CookingStation station)
	{
		if ((Object)(object)station == (Object)null || CookIsEmpty == null)
		{
			return true;
		}
		try
		{
			return (bool)CookIsEmpty.Invoke(station, null);
		}
		catch
		{
			return true;
		}
	}

	public static void CookAutoDropSlot(CookingStation station, int slot)
	{
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)station == (Object)null || CookSpawnItem == null || CookSetSlot == null || CookStatusType == null)
		{
			return;
		}
		try
		{
			ZNetView component = ((Component)station).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return;
			}
			string text = zDO.GetString("slot" + slot, "");
			int num = zDO.GetInt("slotstatus" + slot, 0);
			if (!string.IsNullOrEmpty(text) && (num == 1 || num == 2))
			{
				Vector3 val = ((Component)station).transform.position + ((Component)station).transform.forward;
				if ((Object)(object)station.m_spawnPoint != (Object)null)
				{
					val = station.m_spawnPoint.position;
				}
				CookSpawnItem.Invoke(station, new object[3] { text, slot, val });
				object obj = Enum.ToObject(CookStatusType, 0);
				CookSetSlot.Invoke(station, new object[4] { slot, "", 0f, obj });
			}
		}
		catch (Exception ex)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("CookAutoDropSlot failed: " + ex.Message));
			}
		}
	}

	public static void EnsureBuildingTrigger(GameObject root, float radius, float centerY)
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)root == (Object)null)
		{
			return;
		}
		ZNetView component = root.GetComponent<ZNetView>();
		if (!((Object)(object)component == (Object)null) && component.GetZDO() != null)
		{
			Transform val = root.transform.Find("FBA_InteractTrigger");
			GameObject val2;
			if ((Object)(object)val != (Object)null)
			{
				val2 = ((Component)val).gameObject;
			}
			else
			{
				val2 = new GameObject("FBA_InteractTrigger");
				val2.transform.SetParent(root.transform, false);
				val2.transform.localPosition = new Vector3(0f, centerY, 0f);
				val2.transform.localRotation = Quaternion.identity;
				val2.transform.localScale = Vector3.one;
			}
			SphereCollider val3 = val2.GetComponent<SphereCollider>();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = val2.AddComponent<SphereCollider>();
			}
			((Collider)val3).isTrigger = true;
			val3.radius = radius;
			val3.center = Vector3.zero;
		}
	}

	public static void DisableSwitchColliders(Switch sw)
	{
		if ((Object)(object)sw == (Object)null)
		{
			return;
		}
		Collider[] componentsInChildren = ((Component)sw).GetComponentsInChildren<Collider>(true);
		foreach (Collider val in componentsInChildren)
		{
			if ((Object)(object)val != (Object)null)
			{
				val.enabled = false;
			}
		}
	}
}
internal static class RuneLoc
{
	public static string T(string tokenOrText)
	{
		if (string.IsNullOrEmpty(tokenOrText))
		{
			return tokenOrText;
		}
		return LocalizationManager.Instance.TryTranslate(tokenOrText);
	}

	public static string Tf(string token, params object[] args)
	{
		try
		{
			return string.Format(T(token), args);
		}
		catch
		{
			return T(token);
		}
	}
}
public static class RuneLocalization
{
	public static void Register()
	{
		CustomLocalization localization = LocalizationManager.Instance.GetLocalization();
		Dictionary<string, string> dict = English();
		Add(localization, "English", dict);
		Add(localization, "Swedish", Swedish());
		Add(localization, "French", French());
		Add(localization, "Italian", Italian());
		Add(localization, "German", German());
		Add(localization, "Spanish", Spanish());
		Add(localization, "Russian", Russian());
		Add(localization, "Romanian", Romanian());
		Add(localization, "Bulgarian", Bulgarian());
		Add(localization, "Macedonian", dict);
		Add(localization, "Finnish", Finnish());
		Add(localization, "Danish", Danish());
		Add(localization, "Norwegian", Norwegian());
		Add(localization, "Icelandic", Icelandic());
		Add(localization, "Turkish", Turkish());
		Add(localization, "Lithuanian", Lithuanian());
		Add(localization, "Czech", Czech());
		Add(localization, "Hungarian", Hungarian());
		Add(localization, "Slovak", Slovak());
		Add(localization, "Polish", Polish());
		Add(localization, "Dutch", Dutch());
		Add(localization, "Portuguese_European", PortugueseEuropean());
		Add(localization, "Portuguese_Brazilian", PortugueseBrazilian());
		Add(localization, "Chinese", Chinese());
		Add(localization, "Chinese_Trad", ChineseTrad());
		Add(localization, "Japanese", Japanese());
		Add(localization, "Korean", Korean());
		Add(localization, "Hindi", dict);
		Add(localization, "Thai", dict);
		Add(localization, "Abenaki", dict);
		Add(localization, "Croatian", Croatian());
		Add(localization, "Georgian", dict);
		Add(localization, "Greek", Greek());
		Add(localization, "Serbian", Serbian());
		Add(localization, "Ukrainian", Ukrainian());
		Add(localization, "Latvian", Latvian());
	}

	private static void Add(CustomLocalization loc, string language, Dictionary<string, string> dict)
	{
		loc.AddTranslation(ref language, dict);
	}

	private static Dictionary<string, string> Dict(string piece_fba_runestone, string piece_fba_runestone_description, string piece_fba_runewindmill, string piece_fba_runewindmill_description, string piece_fba_runesmelter, string piece_fba_runesmelter_description, string piece_fba_runeblastfurnace, string piece_fba_runeblastfurnace_description, string piece_fba_runeoven, string piece_fba_runeoven_description, string item_fba_ancientcore, string item_fba_ancientcore_description, string fba_no_runestone, string fba_connected_runestone, string fba_add_ore, string fba_take_out, string fba_add_food, string fba_msg_no_coal, string fba_msg_windmill_no_fuel, string fba_msg_windmill_no_ore, string fba_msg_oven_no_coal, string fba_low_energy, string fba_rune_energy, string fba_connected_label, string fba_generation_label, string fba_per_second, string fba_radius_label, string fba_ready, string fba_wind_none, string fba_wind_light, string fba_wind_medium, string fba_wind_strong, string fba_wind_storm, string fba_windmill_one, string fba_windmill_many, string fba_furnace_one, string fba_furnace_many)
	{
		return new Dictionary<string, string>
		{
			{ "piece_fba_runestone", piece_fba_runestone },
			{ "piece_fba_runestone_description", piece_fba_runestone_description },
			{ "piece_fba_runewindmill", piece_fba_runewindmill },
			{ "piece_fba_runewindmill_description", piece_fba_runewindmill_description },
			{ "piece_fba_runesmelter", piece_fba_runesmelter },
			{ "piece_fba_runesmelter_description", piece_fba_runesmelter_description },
			{ "piece_fba_runeblastfurnace", piece_fba_runeblastfurnace },
			{ "piece_fba_runeblastfurnace_description", piece_fba_runeblastfurnace_description },
			{ "piece_fba_runeoven", piece_fba_runeoven },
			{ "piece_fba_runeoven_description", piece_fba_runeoven_description },
			{ "item_fba_ancientcore", item_fba_ancientcore },
			{ "item_fba_ancientcore_description", item_fba_ancientcore_description },
			{ "fba_no_runestone", fba_no_runestone },
			{ "fba_connected_runestone", fba_connected_runestone },
			{ "fba_add_ore", fba_add_ore },
			{ "fba_take_out", fba_take_out },
			{ "fba_add_food", fba_add_food },
			{ "fba_msg_no_coal", fba_msg_no_coal },
			{ "fba_msg_windmill_no_fuel", fba_msg_windmill_no_fuel },
			{ "fba_msg_windmill_no_ore", fba_msg_windmill_no_ore },
			{ "fba_msg_oven_no_coal", fba_msg_oven_no_coal },
			{ "fba_low_energy", fba_low_energy },
			{ "fba_rune_energy", fba_rune_energy },
			{ "fba_connected_label", fba_connected_label },
			{ "fba_generation_label", fba_generation_label },
			{ "fba_per_second", fba_per_second },
			{ "fba_radius_label", fba_radius_label },
			{ "fba_ready", fba_ready },
			{ "fba_wind_none", fba_wind_none },
			{ "fba_wind_light", fba_wind_light },
			{ "fba_wind_medium", fba_wind_medium },
			{ "fba_wind_strong", fba_wind_strong },
			{ "fba_wind_storm", fba_wind_storm },
			{ "fba_windmill_one", fba_windmill_one },
			{ "fba_windmill_many", fba_windmill_many },
			{ "fba_furnace_one", fba_furnace_one },
			{ "fba_furnace_many", fba_furnace_many }
		};
	}

	private static Dictionary<string, string> English()
	{
		return Dict("Runestone", "An ancient stone that stores rune energy.", "Rune Windmill", "An ancient windmill that converts wind into rune energy.", "Rune Smelter", "An ancient smelter powered by rune energy.", "Rune Blast Furnace", "An ancient blast furnace that melts iron and higher ores with rune energy.", "Rune Stone Oven", "An ancient stone oven that cooks food with rune energy instead of coal.", "Ancient Core", "A core of the Ancients steeped in rune magic. Craftable at the forge.", "No runestone in range", "Connected to runestone ({0} m)", "Add ore", "Take out", "Add food", "The {0} does not need coal.", "The Rune Windmill does not need fuel.", "The Rune Windmill does not process grain – it generates rune energy.", "The Rune Stone Oven does not need coal.", "Not enough rune energy", "rune energy", "Connected:", "Generation:", "/ second", "Radius:", "ready", "No wind", "Light wind", "Medium wind", "Strong wind", "Storm", "Windmill", "Windmills", "Furnace", "Furnaces");
	}

	private static Dictionary<string, string> German()
	{
		return Dict("Runenstein", "Ein uralter Stein, der Runenenergie speichert.", "Runen Windrad", "Ein uraltes Windrad, das Wind in Runenenergie verwandelt.", "Runenschmelze", "Eine uralte Schmelze, die durch Runenenergie betrieben wird.", "Runen Hochofen", "Ein uralter Hochofen, der Eisen und höheres Erz mit Runenenergie schmilzt.", "Runen Steinofen", "Ein uralter Steinofen, der Essen mit Runenenergie statt Kohle gart.", "Uralter Kern", "Ein von Runenmagie durchdrungener Kern der Alten. Craftbar an der Schmiede.", "Kein Runenstein in Reichweite", "Mit Runenstein verbunden ({0} m)", "Erz hinzufügen", "Entnehmen", "Essen einwerfen", "Der {0} benötigt keine Kohle.", "Das Runen Windrad braucht keinen Brennstoff.", "Das Runen Windrad verarbeitet kein Getreide – es erzeugt Runenenergie.", "Der Runen Steinofen benötigt keine Kohle.", "Zu wenig Runenenergie", "Runenenergie", "Verbunden:", "Erzeugung:", "/ Sekunde", "Radius:", "bereit", "Kein Wind", "Leichter Wind", "Mittlerer Wind", "Starker Wind", "Sturm", "Windrad", "Windräder", "Ofen", "Öfen");
	}

	private static Dictionary<string, string> French()
	{
		return Dict("Pierre runique", "Une pierre ancienne qui stocke l'énergie runique.", "Moulin à vent runique", "Un ancien moulin à vent qui convertit le vent en énergie runique.", "Fonderie runique", "Une ancienne fonderie alimentée par l'énergie runique.", "Haut-fourneau runique", "Un ancien haut-fourneau qui fond le fer et les minerais supérieurs avec l'énergie runique.", "Four de pierre runique", "Un ancien four de pierre qui cuit les aliments avec l'énergie runique au lieu du charbon.", "Noyau ancien", "Un noyau des Anciens imprégné de magie runique. Fabricable à la forge.", "Aucune pierre runique à portée", "Connecté à la pierre runique ({0} m)", "Ajouter du minerai", "Retirer", "Ajouter de la nourriture", "Le {0} n'a pas besoin de charbon.", "Le moulin à vent runique n'a pas besoin de combustible.", "Le moulin à vent runique ne transforme pas le grain – il génère de l'énergie runique.", "Le four de pierre runique n'a pas besoin de charbon.", "Pas assez d'énergie runique", "énergie runique", "Connecté :", "Production :", "/ seconde", "Rayon :", "prêt", "Pas de vent", "Vent léger", "Vent moyen", "Vent fort", "Tempête", "Moulin à vent", "Moulins à vent", "Four", "Fours");
	}

	private static Dictionary<string, string> Italian()
	{
		return Dict("Pietra runica", "Un'antica pietra che accumula energia runica.", "Mulino a vento runico", "Un antico mulino a vento che converte il vento in energia runica.", "Fonderia runica", "Un'antica fonderia alimentata dall'energia runica.", "Altoforno runico", "Un antico altoforno che fonde ferro e minerali superiori con energia runica.", "Forno di pietra runico", "Un antico forno di pietra che cuoce il cibo con energia runica invece del carbone.", "Nucleo antico", "Un nucleo degli Antichi impregnato di magia runica. Creabile alla forgia.", "Nessuna pietra runica nel raggio", "Collegato alla pietra runica ({0} m)", "Aggiungi minerale", "Preleva", "Aggiungi cibo", "Il {0} non ha bisogno di carbone.", "Il mulino a vento runico non ha bisogno di combustibile.", "Il mulino a vento runico non processa grano – genera energia runica.", "Il forno di pietra runico non ha bisogno di carbone.", "Energia runica insufficiente", "energia runica", "Collegato:", "Generazione:", "/ secondo", "Raggio:", "pronto", "Nessun vento", "Vento leggero", "Vento medio", "Vento forte", "Tempesta", "Mulino a vento", "Mulini a vento", "Forno", "Forni");
	}

	private static Dictionary<string, string> Spanish()
	{
		return Dict("Piedra rúnica", "Una piedra antigua que almacena energía rúnica.", "Molino de viento rúnico", "Un antiguo molino de viento que convierte el viento en energía rúnica.", "Fundición rúnica", "Una antigua fundición impulsada por energía rúnica.", "Alto horno rúnico", "Un antiguo alto horno que funde hierro y minerales superiores con energía rúnica.", "Horno de piedra rúnico", "Un antiguo horno de piedra que cocina comida con energía rúnica en lugar de carbón.", "Núcleo antiguo", "Un núcleo de los Antiguos impregnado de magia rúnica. Fabricable en la forja.", "Ninguna piedra rúnica al alcance", "Conectado a la piedra rúnica ({0} m)", "Añadir mineral", "Sacar", "Añadir comida", "El {0} no necesita carbón.", "El molino de viento rúnico no necesita combustible.", "El molino de viento rúnico no procesa grano: genera energía rúnica.", "El horno de piedra rúnico no necesita carbón.", "Energía rúnica insuficiente", "energía rúnica", "Conectado:", "Generación:", "/ segundo", "Radio:", "listo", "Sin viento", "Viento ligero", "Viento medio", "Viento fuerte", "Tormenta", "Molino de viento", "Molinos de viento", "Horno", "Hornos");
	}

	private static Dictionary<string, string> Swedish()
	{
		return Dict("Runsten", "En uråldrig sten som lagrar runenergi.", "Runväderkvarn", "En uråldrig väderkvarn som omvandlar vind till runenergi.", "Runsmälta", "En uråldrig smälta driven av runenergi.", "Runmasugn", "En uråldrig masugn som smälter järn och högre malmer med runenergi.", "Runstenugn", "En uråldrig stenugn som tillagar mat med runenergi istället för kol.", "Uråldrig kärna", "En kärna från de Gamla genomsyrad av runmagi. Kan tillverkas vid smedjan.", "Ingen runsten inom räckhåll", "Ansluten till runsten ({0} m)", "Lägg till malm", "Ta ut", "Lägg till mat", "{0} behöver inte kol.", "Runväderkvarnen behöver inget bränsle.", "Runväderkvarnen bearbetar inte säd – den genererar runenergi.", "Runstenugnen behöver inte kol.", "För lite runenergi", "runenergi", "Ansluten:", "Produktion:", "/ sekund", "Radie:", "redo", "Ingen vind", "Lätt vind", "Medelvind", "Stark vind", "Storm", "Väderkvarn", "Väderkvarnar", "Ugn", "Ugnar");
	}

	private static Dictionary<string, string> Danish()
	{
		return Dict("Runesten", "En ældgammel sten, der lagrer runeenergi.", "Runevindmølle", "En ældgammel vindmølle, der omdanner vind til runeenergi.", "Runesmelteovn", "En ældgammel smelteovn drevet af runeenergi.", "Runehøjovn", "En ældgammel højovn, der smelter jern og højere malme med runeenergi.", "Runestensovn", "En ældgammel stensovn, der tilbereder mad med runeenergi i stedet for kul.", "Ældgammel kerne", "En kerne fra de Gamle gennemsyret af runemagi. Kan laves ved smedjen.", "Ingen runesten inden for rækkevidde", "Forbundet til runesten ({0} m)", "Tilføj malm", "Tag ud", "Tilføj mad", "{0} behøver ikke kul.", "Runevindmøllen behøver ikke brændstof.", "Runevindmøllen forarbejder ikke korn – den genererer runeenergi.", "Runestensovnen behøver ikke kul.", "For lidt runeenergi", "runeenergi", "Forbundet:", "Produktion:", "/ sekund", "Radius:", "klar", "Ingen vind", "Let vind", "Mellem vind", "Stærk vind", "Storm", "Vindmølle", "Vindmøller", "Ovn", "Ovne");
	}

	private static Dictionary<string, string> Norwegian()
	{
		return Dict("Runestein", "En eldgammel stein som lagrer runeenergi.", "Runevindmølle", "En eldgammel vindmølle som omdanner vind til runeenergi.", "Runesmelte", "En eldgammel smelte drevet av runeenergi.", "Runehøyovn", "En eldgammel høyovn som smelter jern og høyere malmer med runeenergi.", "Runesteinovn", "En eldgammel steinovn som tilbereder mat med runeenergi i stedet for kull.", "Eldgammel kjerne", "En kjerne fra de Gamle gjennomtrukket av runemagi. Kan lages ved smia.", "Ingen runestein innen rekkevidde", "Tilkoblet runestein ({0} m)", "Legg til malm", "Ta ut", "Legg til mat", "{0} trenger ikke kull.", "Runevindmøllen trenger ikke brensel.", "Runevindmøllen bearbeider ikke korn – den genererer runeenergi.", "Runesteinovnen trenger ikke kull.", "For lite runeenergi", "runeenergi", "Tilkoblet:", "Produksjon:", "/ sekund", "Radius:", "klar", "Ingen vind", "Lett vind", "Middels vind", "Sterk vind", "Storm", "Vindmølle", "Vindmøller", "Ovn", "Ovner");
	}

	private static Dictionary<string, string> Dutch()
	{
		return Dict("Runensteen", "Een eeuwenoude steen die runenenergie opslaat.", "Runenwindmolen", "Een eeuwenoude windmolen die wind omzet in runenenergie.", "Runensmelterij", "Een eeuwenoude smelterij aangedreven door runenenergie.", "Runenhoogoven", "Een eeuwenoude hoogoven die ijzer en hogere ertsen smelt met runenenergie.", "Runensteenoven", "Een eeuwenoude steenoven die voedsel bereidt met runenenergie in plaats van steenkool.", "Oude kern", "Een kern van de Ouden doordrenkt met runenmagie. Maakbaar bij de smederij.", "Geen runensteen binnen bereik", "Verbonden met runensteen ({0} m)", "Erts toevoegen", "Uithalen", "Voedsel toevoegen", "De {0} heeft geen steenkool nodig.", "De runenwindmolen heeft geen brandstof nodig.", "De runenwindmolen verwerkt geen graan – hij genereert runenenergie.", "De runensteenoven heeft geen steenkool nodig.", "Niet genoeg runenenergie", "runenenergie", "Verbonden:", "Opwekking:", "/ seconde", "Radius:", "gereed", "Geen wind", "Lichte wind", "Matige wind", "Harde wind", "Storm", "Windmolen", "Windmolens", "Oven", "Ovens");
	}

	private static Dictionary<string, string> Polish()
	{
		return Dict("Kamień runiczny", "Starożytny kamień przechowujący energię runiczną.", "Runiczny wiatrak", "Starożytny wiatrak przekształcający wiatr w energię runiczną.", "Runiczna huta", "Starożytna huta zasilana energią runiczną.", "Runiczny wielki piec", "Starożytny wielki piec wytapiający żelazo i wyższe rudy energią runiczną.", "Runiczny piec kamienny", "Starożytny piec kamienny piekący jedzenie energią runiczną zamiast węgla.", "Starożytny rdzeń", "Rdzeń Starożytnych przeniknięty magią runiczną. Wytwarzany w kuźni.", "Brak kamienia runicznego w zasięgu", "Połączono z kamieniem runicznym ({0} m)", "Dodaj rudę", "Wyjmij", "Dodaj jedzenie", "{0} nie potrzebuje węgla.", "Runiczny wiatrak nie potrzebuje paliwa.", "Runiczny wiatrak nie przetwarza ziarna – generuje energię runiczną.", "Runiczny piec kamienny nie potrzebuje węgla.", "Za mało energii runicznej", "energia runiczna", "Połączono:", "Generowanie:", "/ sekundę", "Promień:", "gotowe", "Brak wiatru", "Lekki wiatr", "Umiarkowany wiatr", "Silny wiatr", "Burza", "Wiatrak", "Wiatraki", "Piec", "Piece");
	}

	private static Dictionary<string, string> Russian()
	{
		return Dict("Рунный камень", "Древний камень, хранящий рунную энергию.", "Рунная ветряная мельница", "Древняя ветряная мельница, преобразующая ветер в рунную энергию.", "Рунная плавильня", "Древняя плавильня, работающая на рунной энергии.", "Рунная доменная печь", "Древняя доменная печь, плавящая железо и более ценные руды рунной энергией.", "Рунная каменная печь", "Древняя каменная печь, готовящая еду рунной энергией вместо угля.", "Древнее ядро", "Ядро Древних, пропитанное рунной магией. Создаётся у кузницы.", "Нет рунного камня поблизости", "Подключено к рунному камню ({0} м)", "Добавить руду", "Забрать", "Добавить еду", "{0} не нуждается в угле.", "Рунной ветряной мельнице не нужно топливо.", "Рунная ветряная мельница не перерабатывает зерно — она вырабатывает рунную энергию.", "Рунной каменной печи не нужен уголь.", "Недостаточно рунной энергии", "рунная энергия", "Подключено:", "Выработка:", "/ сек.", "Радиус:", "готово", "Нет ветра", "Лёгкий ветер", "Умеренный ветер", "Сильный ветер", "Шторм", "Мельница", "Мельницы", "Печь", "Печи");
	}

	private static Dictionary<string, string> Ukrainian()
	{
		return Dict("Рунний камінь", "Стародавній камінь, що зберігає рунну енергію.", "Рунний вітряк", "Стародавній вітряк, що перетворює вітер на рунну енергію.", "Рунна плавильня", "Стародавня плавильня, що працює на рунній енергії.", "Рунна доменна піч", "Стародавня доменна піч, що плавить залізо та вищі руди рунною енергією.", "Рунна кам'яна піч", "Стародавня кам'яна піч, що готує їжу рунною енергією замість вугілля.", "Стародавнє ядро", "Ядро Стародавніх, просякнуте рунною магією. Створюється біля кузні.", "Немає рунного каменю в межах досяжності", "Підключено до рунного каменю ({0} м)", "Додати руду", "Забрати", "Додати їжу", "{0} не потребує вугілля.", "Рунному вітряку не потрібне паливо.", "Рунний вітряк не обробляє зерно — він виробляє рунну енергію.", "Рунній кам'яній печі не потрібне вугілля.", "Замало рунної енергії", "рунна енергія", "Підключено:", "Вироблення:", "/ сек.", "Радіус:", "готово", "Немає вітру", "Легкий вітер", "Помірний вітер", "Сильний вітер", "Шторм", "Вітряк", "Вітряки", "Піч", "Печі");
	}

	private static Dictionary<string, string> Czech()
	{
		return Dict("Runový kámen", "Prastarý kámen, který uchovává runovou energii.", "Runový větrný mlýn", "Prastarý větrný mlýn, který přeměňuje vítr na runovou energii.", "Runová tavírna", "Prastará tavírna poháněná runovou energií.", "Runová vysoká pec", "Prastará vysoká pec, která taví železo a vyšší rudy runovou energií.", "Runová kamenná pec", "Prastará kamenná pec, která peče jídlo runovou energií místo uhlí.", "Prastaré jádro", "Jádro Starých prostoupené runovou magií. Výroba u kovárny.", "Žádný runový kámen v dosahu", "Připojeno k runovému kameni ({0} m)", "Přidat rudu", "Vybrat", "Přidat jídlo", "{0} nepotřebuje uhlí.", "Runový větrný mlýn nepotřebuje palivo.", "Runový větrný mlýn nezpracovává obilí – vyrábí runovou energii.", "Runová kamenná pec nepotřebuje uhlí.", "Nedostatek runové energie", "runová energie", "Připojeno:", "Výroba:", "/ sekundu", "Poloměr:", "připraveno", "Bez větru", "Slabý vítr", "Střední vítr", "Silný vítr", "Bouře", "Větrný mlýn", "Větrné mlýny", "Pec", "Pece");
	}

	private static Dictionary<string, string> Slovak()
	{
		return Dict("Runový kameň", "Prastarý kameň, ktorý uchováva runovú energiu.", "Runový veterný mlyn", "Prastarý veterný mlyn, ktorý premieňa vietor na runovú energiu.", "Runová taviareň", "Prastará taviareň poháňaná runovou energiou.", "Runová vysoká pec", "Prastará vysoká pec, ktorá taví železo a vyššie rudy runovou energiou.", "Runová kamenná pec", "Prastará kamenná pec, ktorá pečie jedlo runovou energiou namiesto uhlia.", "Prastaré jadro", "Jadro Starých preniknuté runovou mágiou. Výroba pri kovárni.", "Žiadny runový kameň v dosahu", "Pripojené k runovému kameňu ({0} m)", "Pridať rudu", "Vybrať", "Pridať jedlo", "{0} nepotrebuje uhlie.", "Runový veterný mlyn nepotrebuje palivo.", "Runový veterný mlyn nespracúva obilie – vyrába runovú energiu.", "Runová kamenná pec nepotrebuje uhlie.", "Nedostatok runovej energie", "runová energia", "Pripojené:", "Výroba:", "/ sekundu", "Polomer:", "pripravené", "Bez vetra", "Slabý vietor", "Stredný vietor", "Silný vietor", "Búrka", "Veterný mlyn", "Veterné mlyny", "Pec", "Pece");
	}

	private static Dictionary<string, string> Hungarian()
	{
		return Dict("Rúnakő", "Ősi kő, amely rúnaenergiát tárol.", "Rúna szélmalom", "Ősi szélmalom, amely a szelet rúnaenergiává alakítja.", "Rúna olvasztó", "Ősi olvasztó, amelyet rúnaenergia hajt.", "Rúna kohó", "Ősi kohó, amely vasat és magasabb érceket olvaszt rúnaenergiával.", "Rúna kőkemence", "Ősi kőkemence, amely ételt süt rúnaenergiával szén helyett.", "Ősi mag", "Az Ősök magja, átitatva rúnamágiával. Kovácsműhelyben készíthető.", "Nincs rúnakő hatótávon belül", "Csatlakoztatva a rúnakőhöz ({0} m)", "Érc hozzáadása", "Kivétel", "Étel hozzáadása", "A(z) {0} nem igényel szenet.", "A rúna szélmalomnak nincs szüksége üzemanyagra.", "A rúna szélmalom nem dolgoz fel gabonát – rúnaenergiát termel.", "A rúna kőkemence nem igényel szenet.", "Nincs elég rúnaenergia", "rúnaenergia", "Csatlakoztatva:", "Termelés:", "/ másodperc", "Sugár:", "kész", "Nincs szél", "Enyhe szél", "Közepes szél", "Erős szél", "Vihar", "Szélmalom", "Szélmalmok", "Kemence", "Kemencék");
	}

	private static Dictionary<string, string> Romanian()
	{
		return Dict("Piatră runică", "O piatră străveche care stochează energie runică.", "Moară de vânt runică", "O moară de vânt străveche care transformă vântul în energie runică.", "Topitorie runică", "O topitorie străveche alimentată cu energie runică.", "Furnal runic", "Un furnal străvechi care topește fierul și minereurile superioare cu energie runică.", "Cuptor de piatră runic", "Un cuptor de piatră străvechi care gătește mâncarea cu energie runică în loc de cărbune.", "Nucleu străvechi", "Un nucleu al Anticilor impregnat cu magie runică. Se fabrică la forjă.", "Nicio piatră runică în rază", "Conectat la piatra runică ({0} m)", "Adaugă minereu", "Scoate", "Adaugă mâncare", "{0} nu are nevoie de cărbune.", "Moara de vânt runică nu are nevoie de combustibil.", "Moara de vânt runică nu prelucrează cereale – generează energie runică.", "Cuptorul de piatră runic nu are nevoie de cărbune.", "Energie runică insuficientă", "energie runică", "Conectat:", "Generare:", "/ secundă", "Rază:", "gata", "Fără vânt", "Vânt ușor", "Vânt mediu", "Vânt puternic", "Furtună", "Moară de vânt", "Morile de vânt", "Cuptor", "Cuptoare");
	}

	private static Dictionary<string, string> Bulgarian()
	{
		return Dict("Рунен камък", "Древен камък, който съхранява рунна енергия.", "Рунна вятърна мелница", "Древна вятърна мелница, която превръща вятъра в рунна енергия.", "Рунна топилня", "Древна топилня, задвижвана от рунна енергия.", "Рунна доменна пещ", "Древна доменна пещ, която топи желязо и по-висши руди с рунна енергия.", "Рунна каменна пещ", "Древна каменна пещ, която готви храна с рунна енергия вместо въглища.", "Древно ядро", "Ядро на Древните, пропито с рунна магия. Изработва се в ковачницата.", "Няма рунен камък в обхват", "Свързано с рунен камък ({0} м)", "Добави руда", "Извади", "Добави храна", "{0} не се нуждае от въглища.", "Рунната вятърна мелница не се нуждае от гориво.", "Рунната вятърна мелница не преработва зърно – тя генерира рунна енергия.", "Рунната каменна пещ не се нуждае от въглища.", "Недостатъчно рунна енергия", "рунна енергия", "Свързано:", "Производство:", "/ секунда", "Радиус:", "готово", "Без вятър", "Лек вятър", "Умерен вятър", "Силен вятър", "Буря", "Мелница", "Мелници", "Пещ", "Пещи");
	}

	private static Dictionary<string, string> Finnish()
	{
		return Dict("Riimukivi", "Ikuinen kivi, joka varastoi riimuenergiaa.", "Riimutuulimylly", "Ikuinen tuulimylly, joka muuttaa tuulen riimuenergiaksi.", "Riimusulatto", "Ikuinen sulatto, jota käyttää riimuenergia.", "Riimumasuuni", "Ikuinen masuuni, joka sulattaa rautaa ja korkeampia malmeja riimuenergialla.", "Riimukiviuuni", "Ikuinen kiviuuni, joka kypsentää ruokaa riimuenergialla hiilen sijaan.", "Ikuinen ydin", "Muinaisiin ydin, joka on täynnä riimumagiaa. Valmistetaan pajalla.", "Ei riimukiveä kantaman sisällä", "Yhdistetty riimukiveen ({0} m)", "Lisää malmia", "Ota pois", "Lisää ruokaa", "{0} ei tarvitse hiiltä.", "Riimutuulimylly ei tarvitse polttoainetta.", "Riimutuulimylly ei käsittele viljaa – se tuottaa riimuenergiaa.", "Riimukiviuuni ei tarvitse hiiltä.", "Liian vähän riimuenergiaa", "riimuenergia", "Yhdistetty:", "Tuotto:", "/ sekunti", "Säde:", "valmis", "Ei tuulta", "Heikko tuuli", "Keskituuli", "Kova tuuli", "Myrsky", "Tuulimylly", "Tuulimyllyt", "Uuni", "Uunit");
	}

	private static Dictionary<string, string> Turkish()
	{
		return Dict("Runik taş", "Rune enerjisi depolayan kadim bir taş.", "Runik yel değirmeni", "Rüzgarı rune enerjisine çeviren kadim bir yel değirmeni.", "Runik eritici", "Rune enerjisiyle çalışan kadim bir eritici.", "Runik yüksek fırın", "Demiri ve daha yüksek cevherleri rune enerjisiyle eriten kadim bir yüksek fırın.", "Runik taş fırın", "Kömür yerine rune enerjisiyle yemek pişiren kadim bir taş fırın.", "Kadim çekirdek", "Rune büyüsüyle dolu Kadimlerin çekirdeği. Demircide üretilebilir.", "Menzilde runik taş yok", "Runik taşa bağlı ({0} m)", "Cevher ekle", "Çıkar", "Yiyecek ekle", "{0} kömüre ihtiyaç duymaz.", "Runik yel değirmeni yakıta ihtiyaç duymaz.", "Runik yel değirmeni tahıl işlemez – rune enerjisi üretir.", "Runik taş fırın kömüre ihtiyaç duymaz.", "Yetersiz rune enerjisi", "rune enerjisi", "Bağlı:", "Üretim:", "/ saniye", "Yarıçap:", "hazır", "Rüzgar yok", "Hafif rüzgar", "Orta rüzgar", "Güçlü rüzgar", "Fırtına", "Yel değirmeni", "Yel değirmenleri", "Fırın", "Fırınlar");
	}

	private static Dictionary<string, string> PortugueseEuropean()
	{
		return Dict("Pedra rúnica", "Uma pedra antiga que armazena energia rúnica.", "Moinho de vento rúnico", "Um antigo moinho de vento que converte o vento em energia rúnica.", "Fundição rúnica", "Uma antiga fundição alimentada por energia rúnica.", "Alto-forno rúnico", "Um antigo alto-forno que funde ferro e minérios superiores com energia rúnica.", "Forno de pedra rúnico", "Um antigo forno de pedra que cozinha comida com energia rúnica em vez de carvão.", "Núcleo antigo", "Um núcleo dos Antigos impregnado de magia rúnica. Fabricável na forja.", "Nenhuma pedra rúnica ao alcance", "Ligado à pedra rúnica ({0} m)", "Adicionar minério", "Retirar", "Adicionar comida", "O {0} não precisa de carvão.", "O moinho de vento rúnico não precisa de combustível.", "O moinho de vento rúnico não processa grão – gera energia rúnica.", "O forno de pedra rúnico não precisa de carvão.", "Energia rúnica insuficiente", "energia rúnica", "Ligado:", "Geração:", "/ segundo", "Raio:", "pronto", "Sem vento", "Vento fraco", "Vento médio", "Vento forte", "Tempestade", "Moinho de vento", "Moinhos de vento", "Forno", "Fornos");
	}

	private static Dictionary<string, string> PortugueseBrazilian()
	{
		return Dict("Pedra rúnica", "Uma pedra antiga que armazena energia rúnica.", "Moinho de vento rúnico", "Um antigo moinho de vento que converte o vento em energia rúnica.", "Fundição rúnica", "Uma antiga fundição alimentada por energia rúnica.", "Alto-forno rúnico", "Um antigo alto-forno que derrete ferro e minérios superiores com energia rúnica.", "Forno de pedra rúnico", "Um antigo forno de pedra que cozinha comida com energia rúnica em vez de carvão.", "Núcleo antigo", "Um núcleo dos Antigos impregnado de magia rúnica. Fabricável na forja.", "Nenhuma pedra rúnica no alcance", "Conectado à pedra rúnica ({0} m)", "Adicionar minério", "Retirar", "Adicionar comida", "O {0} não precisa de carvão.", "O moinho de vento rúnico não precisa de combustível.", "O moinho de vento rúnico não processa grãos – gera energia rúnica.", "O forno de pedra rúnico não precisa de carvão.", "Energia rúnica insuficiente", "energia rúnica", "Conectado:", "Geração:", "/ segundo", "Raio:", "pronto", "Sem vento", "Vento leve", "Vento médio", "Vento forte", "Tempestade", "Moinho de vento", "Moinhos de vento", "Forno", "Fornos");
	}

	private static Dictionary<string, string> Chinese()
	{
		return Dict("符文石", "一块储存符文能量的远古石碑。", "符文风车", "一座将风转化为符文能量的远古风车。", "符文熔炉", "一座以符文能量驱动的远古熔炉。", "符文高炉", "一座用符文能量熔炼铁及更高等矿石的远古高炉。", "符文石炉", "一座用符文能量而非煤炭烹饪食物的远古石炉。", "远古核心", "浸透符文魔力的远古者核心。可在锻造台制作。", "范围内没有符文石", "已连接符文石（{0} 米）", "放入矿石", "取出", "放入食物", "{0}不需要煤炭。", "符文风车不需要燃料。", "符文风车不加工谷物——它生成符文能量。", "符文石炉不需要煤炭。", "符文能量不足", "符文能量", "已连接：", "生成：", "/ 秒", "半径：", "就绪", "无风", "微风", "中风", "强风", "风暴", "风车", "风车", "炉子", "炉子");
	}

	private static Dictionary<string, string> ChineseTrad()
	{
		return Dict("符文石", "一塊儲存符文能量的遠古石碑。", "符文風車", "一座將風轉化為符文能量的遠古風車。", "符文熔爐", "一座以符文能量驅動的遠古熔爐。", "符文高爐", "一座用符文能量熔煉鐵及更高等礦石的遠古高爐。", "符文石爐", "一座用符文能量而非煤炭烹飪食物的遠古石爐。", "遠古核心", "浸透符文魔力的遠古者核心。可在鍛造台製作。", "範圍內沒有符文石", "已連接符文石（{0} 公尺）", "放入礦石", "取出", "放入食物", "{0}不需要煤炭。", "符文風車不需要燃料。", "符文風車不加工穀物——它生成符文能量。", "符文石爐不需要煤炭。", "符文能量不足", "符文能量", "已連接：", "生成：", "/ 秒", "半徑：", "就緒", "無風", "微風", "中風", "強風", "風暴", "風車", "風車", "爐子", "爐子");
	}

	private static Dictionary<string, string> Japanese()
	{
		return Dict("ルーン石", "ルーンエネルギーを蓄える古代の石。", "ルーン風車", "風をルーンエネルギーに変える古代の風車。", "ルーン精錬炉", "ルーンエネルギーで動く古代の精錬炉。", "ルーン溶鉱炉", "ルーンエネルギーで鉄や上位の鉱石を溶かす古代の溶鉱炉。", "ルーン石窯", "石炭の代わりにルーンエネルギーで料理を焼く古代の石窯。", "古代の核", "ルーン魔法に満ちた古代人の核。鍛冶場で作成可能。", "範囲内にルーン石がありません", "ルーン石に接続中（{0} m）", "鉱石を入れる", "取り出す", "食料を入れる", "{0}に石炭は不要です。", "ルーン風車に燃料は不要です。", "ルーン風車は穀物を処理しません―ルーンエネルギーを生成します。", "ルーン石窯に石炭は不要です。", "ルーンエネルギーが不足しています", "ルーンエネルギー", "接続:", "生成:", "/ 秒", "半径:", "準備完了", "風なし", "弱い風", "中程度の風", "強い風", "嵐", "風車", "風車", "炉", "炉");
	}

	private static Dictionary<string, string> Korean()
	{
		return Dict("룬 스톤", "룬 에너지를 저장하는 고대의 돌.", "룬 풍차", "바람을 룬 에너지로 바꾸는 고대의 풍차.", "룬 제련소", "룬 에너지로 작동하는 고대의 제련소.", "룬 용광로", "룬 에너지로 철과 상위 광석을 녹이는 고대의 용광로.", "룬 돌 화덕", "석탄 대신 룬 에너지로 음식을 굽는 고대의 돌 화덕.", "고대의 핵", "룬 마법에 물든 고대인의 핵. 대장간에서 제작 가능.", "범위 내에 룬 스톤이 없습니다", "룬 스톤에 연결됨 ({0} m)", "광석 넣기", "꺼내기", "음식 넣기", "{0}에는 석탄이 필요 없습니다.", "룬 풍차에는 연료가 필요 없습니다.", "룬 풍차는 곡물을 가공하지 않습니다 – 룬 에너지를 생성합니다.", "룬 돌 화덕에는 석탄이 필요 없습니다.", "룬 에너지가 부족합니다", "룬 에너지", "연결됨:", "생성:", "/ 초", "반경:", "준비됨", "바람 없음", "약한 바람", "중간 바람", "강한 바람", "폭풍", "풍차", "풍차", "화덕", "화덕");
	}

	private static Dictionary<string, string> Croatian()
	{
		return Dict("Runski kamen", "Drevni kamen koji pohranjuje runsku energiju.", "Runski vjetrenjača", "Drevna vjetrenjača koja pretvara vjetar u runsku energiju.", "Runska talionica", "Drevna talionica pokretana runskom energijom.", "Runska visoka peć", "Drevna visoka peć koja tali željezo i više rude runskom energijom.", "Runska kamena peć", "Drevna kamena peć koja peče hranu runskom energijom umjesto ugljena.", "Drevna jezgra", "Jezgra Drevnih prožeta runskom magijom. Izrađuje se kod kovačnice.", "Nema runskog kamena u dosegu", "Povezano s runskim kamenom ({0} m)", "Dodaj rudu", "Izvadi", "Dodaj hranu", "{0} ne treba ugljen.", "Runska vjetrenjača ne treba gorivo.", "Runska vjetrenjača ne obrađuje žito – generira runsku energiju.", "Runska kamena peć ne treba ugljen.", "Nedovoljno runske energije", "runska energija", "Povezano:", "Proizvodnja:", "/ sekundu", "Radijus:", "spremno", "Bez vjetra", "Lagani vjetar", "Srednji vjetar", "Jaki vjetar", "Oluja", "Vjetrenjača", "Vjetrenjače", "Peć", "Peći");
	}

	private static Dictionary<string, string> Serbian()
	{
		return Dict("Рунски камен", "Древни камен који складишти рунску енергију.", "Рунска ветрењача", "Древна ветрењача која претвара ветар у рунску енергију.", "Рунска топионица", "Древна топионица покретана рунском енергијом.", "Рунска висока пећ", "Древна висока пећ која топи гвожђе и више руде рунском енергијом.", "Рунска камена пећ", "Древна камена пећ која пече храну рунском енергијом уместо угља.", "Древно језгро", "Језгро Древних прожето рунском магијом. Израђује се код ковачнице.", "Нема рунског камена у домету", "Повезано са рунским каменом ({0} м)", "Додај руду", "Извади", "Додај храну", "{0} не треба угаљ.", "Рунској ветрењачи не треба гориво.", "Рунска ветрењача не прерађује жито – генерише рунску енергију.", "Рунској каменој пећи не треба угаљ.", "Недовољно рунске енергије", "рунска енергија", "Повезано:", "Производња:", "/ секунду", "Радијус:", "спремно", "Без ветра", "Слаб ветар", "Умерен ветар", "Јак ветар", "Олуја", "Ветрењача", "Ветрењаче", "Пећ", "Пећи");
	}

	private static Dictionary<string, string> Greek()
	{
		return Dict("Ρουνική πέτρα", "Μια αρχαία πέτρα που αποθηκεύει ρουνική ενέργεια.", "Ρουνικός ανεμόμυλος", "Ένας αρχαίος ανεμόμυλος που μετατρέπει τον άνεμο σε ρουνική ενέργεια.", "Ρουνικό χυτήριο", "Ένα αρχαίο χυτήριο που λειτουργεί με ρουνική ενέργεια.", "Ρουνική υψικάμινος", "Μια αρχαία υψικάμινος που λιώνει σίδηρο και ανώτερα μεταλλεύματα με ρουνική ενέργεια.", "Ρουνικός πέτρινος φούρνος", "Ένας αρχαίος πέτρινος φούρνος που μαγειρεύει φαγητό με ρουνική ενέργεια αντί για κάρβουνο.", "Αρχαίος πυρήνας", "Ένας πυρήνας των Αρ