using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using ValheimMMO.Cities;
using ValheimMMO.Config;
using ValheimMMO.Drops;
using ValheimMMO.Dungeons;
using ValheimMMO.Hunger;
using ValheimMMO.InventorySlots;
using ValheimMMO.Items;
using ValheimMMO.Merchant;
using ValheimMMO.Progression;
using ValheimMMO.Pvp;
using ValheimMMO.Quests;
using ValheimMMO.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: IgnoresAccessChecksTo("assembly_utils")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ValheimMMO")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.3.4.0")]
[assembly: AssemblyInformationalVersion("0.3.4")]
[assembly: AssemblyProduct("ValheimMMO")]
[assembly: AssemblyTitle("ValheimMMO")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ValheimMMO
{
	[BepInPlugin("com.lucas.valheimmmo", "Mayheim", "0.3.4")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginId = "com.lucas.valheimmmo";

		public const string PluginName = "Mayheim";

		public const string PluginVersion = "0.3.4";

		internal static ManualLogSource Log;

		internal static Plugin Instance;

		private Harmony _harmony;

		private void Awake()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			ModConfig.Bind(((BaseUnityPlugin)this).Config);
			((Component)this).gameObject.AddComponent<MmoUI>();
			((Component)this).gameObject.AddComponent<MerchantSellUI>();
			((Component)this).gameObject.AddComponent<QuestNpcUI>();
			((Component)this).gameObject.AddComponent<QuestTracker>();
			_harmony = new Harmony("com.lucas.valheimmmo");
			PatchIsolated();
			Log.LogInfo((object)"Mayheim v0.3.4 carregado.");
		}

		private void PatchIsolated()
		{
			int num = 0;
			int num2 = 0;
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(typeof(Plugin).Assembly);
			foreach (Type type in typesFromAssembly)
			{
				if (type.GetCustomAttributes(typeof(HarmonyPatch), inherit: true).Length != 0)
				{
					try
					{
						_harmony.CreateClassProcessor(type).Patch();
						num++;
					}
					catch (Exception ex)
					{
						num2++;
						Log.LogError((object)("Falha ao aplicar patch " + type.FullName + ": " + ex.Message));
					}
				}
			}
			Log.LogInfo((object)($"Patches aplicados: {num} classes" + ((num2 > 0) ? $", {num2} com falha (ver acima)" : ".")));
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
}
namespace ValheimMMO.UI
{
	[HarmonyPatch(typeof(GameCamera), "UpdateMouseCapture")]
	internal static class GameCamera_UpdateMouseCapture_Patch
	{
		private static void Postfix()
		{
			if (QuestNpcUI.IsOpen || MmoUI.PanelOpen)
			{
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
		}
	}
	internal sealed class ClonedBar
	{
		public GameObject Root;

		public RectTransform Rect;

		public GuiBar[] Bars;

		public TMP_Text Text;

		public Animator Animator;

		public bool Alive => (Object)(object)Root != (Object)null;

		public static ClonedBar From(RectTransform source, string name, bool fixedText)
		{
			//IL_00b3: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)source).gameObject, ((Transform)source).parent);
			((Object)val).name = name;
			ClonedBar clonedBar = new ClonedBar
			{
				Root = val,
				Rect = val.GetComponent<RectTransform>(),
				Bars = val.GetComponentsInChildren<GuiBar>(true),
				Text = val.GetComponentInChildren<TMP_Text>(true),
				Animator = (val.GetComponent<Animator>() ?? val.GetComponentInChildren<Animator>(true))
			};
			if ((Object)(object)clonedBar.Text != (Object)null && fixedText)
			{
				TMP_Text text = clonedBar.Text;
				text.enableAutoSizing = false;
				text.fontSize = 15f;
				text.textWrappingMode = (TextWrappingModes)0;
				text.overflowMode = (TextOverflowModes)0;
				text.alignment = (TextAlignmentOptions)514;
				((Graphic)text).color = Color.white;
				text.fontStyle = (FontStyles)(text.fontStyle | 1);
				RectTransform rectTransform = text.rectTransform;
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = Vector2.one;
				rectTransform.offsetMin = new Vector2(8f, 0f);
				rectTransform.offsetMax = new Vector2(-8f, 0f);
			}
			val.SetActive(true);
			return clonedBar;
		}

		public void SetVisible(bool visible)
		{
			if (Alive)
			{
				if (Root.activeSelf != visible)
				{
					Root.SetActive(visible);
				}
				if (visible && (Object)(object)Animator != (Object)null)
				{
					Animator.SetBool("Visible", true);
				}
			}
		}

		public void SetLength(float size, float borderBuffer)
		{
			if (Alive)
			{
				size = Mathf.Ceil(size);
				Rect.SetSizeWithCurrentAnchors((Axis)0, size + borderBuffer);
				GuiBar[] bars = Bars;
				for (int i = 0; i < bars.Length; i++)
				{
					bars[i].SetWidth(size);
				}
			}
		}

		public void SetValue(float value, float max, Color color)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (Alive)
			{
				for (int i = 0; i < Bars.Length; i++)
				{
					Bars[i].SetMaxValue(max);
					Bars[i].SetValue(Mathf.Clamp(value, 0f, max));
					Bars[i].SetColor((i == 0) ? color : (color * new Color(0.55f, 0.55f, 0.55f, 1f)));
				}
			}
		}
	}
	internal static class HudBars
	{
		private static ClonedBar _xp;

		private static readonly Color XpColor = new Color(0.42f, 0.55f, 0.95f);

		internal static void Update(Hud hud)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)hud == (Object)null || (Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			PlayerProgress playerProgress = PlayerProgress.Get(localPlayer);
			if (playerProgress == null)
			{
				return;
			}
			bool flag = ModConfig.ShowXpBar.Value && !InventoryGui.IsVisible();
			if (_xp == null || !_xp.Alive)
			{
				if (!flag)
				{
					return;
				}
				_xp = ClonedBar.From(hud.m_staminaBar2Root, "MMO_XpBar", fixedText: true);
				if (_xp == null)
				{
					return;
				}
			}
			_xp.SetVisible(flag);
			if (flag)
			{
				_xp.Rect.anchoredPosition = new Vector2(ModConfig.XpBarOffsetX.Value, ModConfig.XpBarOffsetY.Value);
				_xp.SetLength(Mathf.Max(120f, ModConfig.XpBarWidth.Value), 16f);
				bool flag2 = playerProgress.Level >= ModConfig.MaxLevel.Value;
				float num = (flag2 ? 1f : playerProgress.LevelProgress);
				_xp.SetValue(num, 1f, XpColor);
				if ((Object)(object)_xp.Text != (Object)null)
				{
					_xp.Text.text = (flag2 ? $"Lv {playerProgress.Level}   MAX" : $"Lv {playerProgress.Level}   {playerProgress.Xp} / {playerProgress.XpForNextLevel}   {num * 100f:0}%");
				}
			}
		}
	}
	internal static class HudHungerBar
	{
		private static ClonedBar _bar;

		internal static void Update(Hud hud, Player player)
		{
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)hud == (Object)null || (Object)(object)player == (Object)null || (Object)(object)hud.m_healthBarRoot == (Object)null)
			{
				return;
			}
			PlayerProgress playerProgress = PlayerProgress.Get(player);
			if (!ModConfig.ShowHungerBar.Value || !ModConfig.HungerEnabled.Value || playerProgress == null || !(playerProgress.Satiety >= 0f))
			{
				if (_bar != null)
				{
					_bar.SetVisible(visible: false);
				}
				return;
			}
			HideFoodUi(hud);
			if (_bar == null || !_bar.Alive)
			{
				_bar = ClonedBar.From(hud.m_healthBarRoot, "MMO_HungerBar", fixedText: false);
				if (_bar == null)
				{
					return;
				}
			}
			_bar.SetVisible(visible: true);
			if ((Object)(object)hud.m_foodBarRoot != (Object)null)
			{
				((Transform)_bar.Rect).position = ((Transform)hud.m_foodBarRoot).position;
				((Transform)_bar.Rect).rotation = ((Transform)hud.m_foodBarRoot).rotation;
			}
			float max = HungerSystem.Max;
			HungerState s = HungerSystem.StateOf(playerProgress.Satiety);
			_bar.SetLength(max / 25f * 32f, 0f);
			_bar.SetValue(playerProgress.Satiety, max, HungerSystem.ColorOf(s));
			if ((Object)(object)_bar.Text != (Object)null)
			{
				_bar.Text.text = Mathf.CeilToInt(playerProgress.Satiety).ToString();
			}
			if ((Object)(object)hud.m_foodIcon != (Object)null)
			{
				((Graphic)hud.m_foodIcon).color = HungerSystem.ColorOf(s);
			}
		}

		private static void HideFoodUi(Hud hud)
		{
			if (hud.m_foodBars != null)
			{
				Image[] foodBars = hud.m_foodBars;
				foreach (Image val in foodBars)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					if (((Behaviour)val).enabled)
					{
						((Behaviour)val).enabled = false;
					}
					Graphic[] componentsInChildren = ((Component)val).GetComponentsInChildren<Graphic>(true);
					foreach (Graphic val2 in componentsInChildren)
					{
						if ((Object)(object)val2 != (Object)null && ((Behaviour)val2).enabled)
						{
							((Behaviour)val2).enabled = false;
						}
					}
				}
			}
			if (hud.m_foodIcons != null)
			{
				Image[] foodBars = hud.m_foodIcons;
				foreach (Image val3 in foodBars)
				{
					if ((Object)(object)val3 != (Object)null && ((Component)val3).gameObject.activeSelf)
					{
						((Component)val3).gameObject.SetActive(false);
					}
				}
			}
			if (hud.m_foodTime != null)
			{
				TMP_Text[] foodTime = hud.m_foodTime;
				foreach (TMP_Text val4 in foodTime)
				{
					if ((Object)(object)val4 != (Object)null && ((Component)val4).gameObject.activeSelf)
					{
						((Component)val4).gameObject.SetActive(false);
					}
				}
			}
			if ((Object)(object)hud.m_foodBaseBar != (Object)null && ((Component)hud.m_foodBaseBar).gameObject.activeSelf)
			{
				((Component)hud.m_foodBaseBar).gameObject.SetActive(false);
			}
			if ((Object)(object)hud.m_foodText != (Object)null && ((Component)hud.m_foodText).gameObject.activeSelf)
			{
				((Component)hud.m_foodText).gameObject.SetActive(false);
			}
			if ((Object)(object)hud.m_foodBarRoot != (Object)null && ((Component)hud.m_foodBarRoot).gameObject.activeSelf)
			{
				((Component)hud.m_foodBarRoot).gameObject.SetActive(false);
			}
			object obj2;
			if (!((Object)(object)hud.m_healthPanel != (Object)null))
			{
				RectTransform healthBarRoot = hud.m_healthBarRoot;
				Transform obj = ((healthBarRoot != null) ? ((Transform)healthBarRoot).parent : null);
				obj2 = ((obj is RectTransform) ? obj : null);
			}
			else
			{
				obj2 = hud.m_healthPanel;
			}
			RectTransform val5 = (RectTransform)obj2;
			if ((Object)(object)val5 != (Object)null)
			{
				for (int k = 0; k < ((Transform)val5).childCount; k++)
				{
					Transform child = ((Transform)val5).GetChild(k);
					string name = ((Object)child).name;
					bool num = name.Length == 5 && name.StartsWith("food", StringComparison.OrdinalIgnoreCase) && char.IsDigit(name[4]);
					bool flag = name.StartsWith("foodicon (", StringComparison.OrdinalIgnoreCase);
					if ((num || flag) && ((Component)child).gameObject.activeSelf)
					{
						((Component)child).gameObject.SetActive(false);
					}
				}
			}
			if ((Object)(object)hud.m_foodIcon != (Object)null)
			{
				if (!((Component)hud.m_foodIcon).gameObject.activeSelf)
				{
					((Component)hud.m_foodIcon).gameObject.SetActive(true);
				}
				if (!((Behaviour)hud.m_foodIcon).enabled)
				{
					((Behaviour)hud.m_foodIcon).enabled = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Hud), "Update")]
	internal static class Hud_Update_BarsPatch
	{
		private static void Postfix(Hud __instance)
		{
			HudBars.Update(__instance);
		}
	}
	[HarmonyPatch(typeof(Hud), "UpdateFood")]
	internal static class Hud_UpdateFood_HungerPatch
	{
		private static void Postfix(Hud __instance, Player player)
		{
			HudHungerBar.Update(__instance, player);
		}
	}
	public class MmoUI : MonoBehaviour
	{
		internal static MmoUI Instance;

		internal static bool PanelOpen;

		private const float PanelWidth = 470f;

		private Rect _window = new Rect(80f, 80f, 470f, 0f);

		private Vector2 _equipScroll;

		private bool _showEquipList = true;

		private string _respecReason;

		private static readonly Color BgColor = new Color(0.075f, 0.06f, 0.045f, 0.94f);

		private static readonly Color BorderColor = new Color(0.72f, 0.58f, 0.3f, 1f);

		private static readonly Color TextColor = new Color(0.92f, 0.86f, 0.7f, 1f);

		private static readonly Color GoldColor = new Color(0.95f, 0.78f, 0.4f, 1f);

		private static readonly Color MutedColor = new Color(0.65f, 0.6f, 0.5f, 1f);

		private static readonly Color ItemBonusColor = new Color(1f, 0.62f, 0.2f, 1f);

		private static readonly Color ButtonColor = new Color(0.22f, 0.17f, 0.11f, 1f);

		private static readonly Color ButtonHover = new Color(0.32f, 0.25f, 0.15f, 1f);

		private static readonly Color BarBg = new Color(0f, 0f, 0f, 0.6f);

		private static readonly Color XpFill = new Color(0.42f, 0.55f, 0.95f, 1f);

		private static GUISkin _skin;

		private static Texture2D _white;

		private static Font _norse;

		private static bool _fontSearched;

		private static string Gold => ColorUtility.ToHtmlStringRGB(GoldColor);

		private static string Muted => ColorUtility.ToHtmlStringRGB(MutedColor);

		private static string Bonus => ColorUtility.ToHtmlStringRGB(ItemBonusColor);

		private static Texture2D White
		{
			get
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_white == (Object)null)
				{
					_white = Solid(Color.white);
				}
				return _white;
			}
		}

		private static Font NorseFont
		{
			get
			{
				if (_fontSearched)
				{
					return _norse;
				}
				_fontSearched = true;
				try
				{
					Font[] array = Resources.FindObjectsOfTypeAll<Font>();
					foreach (Font val in array)
					{
						if ((Object)(object)val != (Object)null && ((Object)val).name.IndexOf("norse", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							_norse = val;
							break;
						}
					}
				}
				catch
				{
				}
				return _norse;
			}
		}

		internal static Texture2D WhiteTex => White;

		internal static Color GoldC => GoldColor;

		internal static Color MutedC => MutedColor;

		internal static Color BorderC => BorderColor;

		internal static Color BonusC => ItemBonusColor;

		internal static GUISkin Skin
		{
			get
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Expected O, but got Unknown
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Expected O, but got Unknown
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Expected O, but got Unknown
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Expected O, but got Unknown
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Expected O, but got Unknown
				//IL_015d: 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)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_020b: Expected O, but got Unknown
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_0231: Expected O, but got Unknown
				//IL_0238: Unknown result type (might be due to invalid IL or missing references)
				//IL_0242: Expected O, but got Unknown
				//IL_0249: Unknown result type (might be due to invalid IL or missing references)
				//IL_0253: Expected O, but got Unknown
				//IL_025e: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_skin != (Object)null)
				{
					return _skin;
				}
				GUISkin val = ScriptableObject.CreateInstance<GUISkin>();
				((Object)val).hideFlags = (HideFlags)61;
				GUISkin skin = GUI.skin;
				Font norseFont = NorseFont;
				val.window = new GUIStyle(skin.window)
				{
					padding = new RectOffset(16, 16, 28, 14),
					fontSize = 16,
					alignment = (TextAnchor)1
				};
				Texture2D background = Bordered(BgColor, BorderColor);
				val.window.normal.background = background;
				val.window.onNormal.background = background;
				val.window.normal.textColor = GoldColor;
				val.window.onNormal.textColor = GoldColor;
				val.window.border = new RectOffset(3, 3, 3, 3);
				if ((Object)(object)norseFont != (Object)null)
				{
					val.window.font = norseFont;
				}
				val.label = new GUIStyle(skin.label)
				{
					fontSize = 14,
					richText = true
				};
				val.label.normal.textColor = TextColor;
				if ((Object)(object)norseFont != (Object)null)
				{
					val.label.font = norseFont;
				}
				val.button = new GUIStyle(skin.button)
				{
					fontSize = 14,
					richText = true
				};
				val.button.normal.background = Bordered(ButtonColor, BorderColor, 12, 1);
				val.button.hover.background = Bordered(ButtonHover, GoldColor, 12, 1);
				val.button.active.background = Bordered(ButtonHover, GoldColor, 12, 1);
				val.button.normal.textColor = TextColor;
				val.button.hover.textColor = GoldColor;
				val.button.active.textColor = GoldColor;
				val.button.border = new RectOffset(2, 2, 2, 2);
				if ((Object)(object)norseFont != (Object)null)
				{
					val.button.font = norseFont;
				}
				val.scrollView = new GUIStyle(skin.scrollView);
				val.verticalScrollbar = new GUIStyle(skin.verticalScrollbar);
				val.verticalScrollbarThumb = new GUIStyle(skin.verticalScrollbarThumb);
				val.verticalScrollbarThumb.normal.background = Solid(BorderColor);
				_skin = val;
				return _skin;
			}
		}

		private static bool AttachedToInventory
		{
			get
			{
				if (ModConfig.PanelOpensWithInventory.Value && InventoryGui.IsVisible())
				{
					return !PanelOpen;
				}
				return false;
			}
		}

		internal static bool Visible
		{
			get
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					if (!PanelOpen)
					{
						return AttachedToInventory;
					}
					return true;
				}
				return false;
			}
		}

		private static Texture2D Solid(Color c)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1, (TextureFormat)4, false);
			val.SetPixel(0, 0, c);
			val.Apply();
			((Object)val).hideFlags = (HideFlags)61;
			return val;
		}

		private static Texture2D Bordered(Color fill, Color border, int size = 12, int thickness = 2)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false);
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					bool flag = j < thickness || i < thickness || j >= size - thickness || i >= size - thickness;
					val.SetPixel(j, i, flag ? border : fill);
				}
			}
			val.Apply();
			((Object)val).hideFlags = (HideFlags)61;
			return val;
		}

		private void Awake()
		{
			Instance = this;
		}

		private void Update()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = ModConfig.OpenPanelKey.Value;
			if (((KeyboardShortcut)(ref value)).IsDown() && CanShowUi())
			{
				PanelOpen = !PanelOpen;
			}
			if (PanelOpen && (Object)(object)Player.m_localPlayer == (Object)null)
			{
				PanelOpen = false;
			}
		}

		private static bool CanShowUi()
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			if ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus())
			{
				return false;
			}
			if (Console.IsVisible() || TextInput.IsVisible())
			{
				return false;
			}
			if (Menu.IsVisible() || InventoryGui.IsVisible())
			{
				return false;
			}
			return true;
		}

		private void OnGUI()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00b9: 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)
			if (Visible)
			{
				GUISkin skin = GUI.skin;
				Matrix4x4 matrix = GUI.matrix;
				GUI.skin = Skin;
				float num = Mathf.Clamp((float)Screen.height / 1080f, 0.75f, 2.5f);
				GUI.matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(num, num, 1f));
				float num2 = (float)Screen.width / num;
				if (AttachedToInventory)
				{
					Rect val = default(Rect);
					((Rect)(ref val))..ctor((num2 - 470f) * 0.5f, 34f, 470f, 0f);
					GUILayout.Window(((Object)this).GetInstanceID(), val, new WindowFunction(DrawPanel), "PERSONAGEM", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(470f) });
				}
				else
				{
					_window = GUILayout.Window(((Object)this).GetInstanceID(), _window, new WindowFunction(DrawPanel), "PERSONAGEM", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(470f) });
				}
				GUI.matrix = matrix;
				GUI.skin = skin;
			}
		}

		private void DrawPanel(int id)
		{
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			PlayerProgress playerProgress = PlayerProgress.Get(localPlayer);
			if (playerProgress == null)
			{
				return;
			}
			bool flag = playerProgress.Level >= ModConfig.MaxLevel.Value;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("<size=15>" + localPlayer.GetPlayerName() + "</size>", Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUILayout.Label($"<size=20><b><color=#{Gold}>Level {playerProgress.Level}</color></b></size>" + (flag ? "" : $"<size=12><color=#{Muted}> / {ModConfig.MaxLevel.Value}</color></size>"), Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			GUILayout.Space(6f);
			DrawXpBar(playerProgress, flag);
			if (ModConfig.PvpEnabled.Value)
			{
				float num = Karma.Local(localPlayer);
				string arg = ((num >= ModConfig.WantedThreshold.Value) ? "E04A3A" : Muted);
				GUILayout.Label($"<size=12><color=#{arg}>Karma {num:0.0} · {Karma.StatusName(num)}</color></size>", Array.Empty<GUILayoutOption>());
			}
			GUILayout.Space(12f);
			Separator();
			GUILayout.Space(8f);
			DrawAttributes(localPlayer, playerProgress);
			GUILayout.Space(10f);
			Separator();
			GUILayout.Space(8f);
			DrawEquipment(localPlayer);
			GUILayout.Space(10f);
			Separator();
			GUILayout.Space(8f);
			string reason;
			bool flag2 = PlayerProgress.CanRespec(localPlayer, out reason);
			GUI.enabled = ModConfig.RespecEnabled.Value && playerProgress.SpentPoints > 0 && flag2;
			if (GUILayout.Button("Redistribuir todos os pontos", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(26f) }))
			{
				if (playerProgress.RespecAll(localPlayer, out _respecReason))
				{
					RefreshStats(localPlayer);
					((Character)localPlayer).Message((MessageType)2, "Pontos redistribuidos", 0, (Sprite)null);
				}
				else
				{
					((Character)localPlayer).Message((MessageType)2, _respecReason, 0, (Sprite)null);
				}
			}
			GUI.enabled = true;
			if (!flag2 && ModConfig.RespecEnabled.Value)
			{
				GUILayout.Label("<size=12><color=#" + Muted + "><i>" + reason + "</i></color></size>", Array.Empty<GUILayoutOption>());
			}
			if (PanelOpen)
			{
				GUILayout.Space(6f);
				if (GUILayout.Button("Fechar", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) }))
				{
					PanelOpen = false;
				}
				GUI.DragWindow(new Rect(0f, 0f, 10000f, 26f));
			}
		}

		private void DrawAttributes(Player player, PlayerProgress prog)
		{
			int unspentPoints = prog.UnspentPoints;
			GUILayout.Label((unspentPoints > 0) ? string.Format("<color=#{0}><b>{1}</b></color> ponto{2} para distribuir", Gold, unspentPoints, (unspentPoints == 1) ? "" : "s") : ("<color=#" + Muted + ">Nenhum ponto disponivel</color>"), Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("<size=11><color=#" + Muted + ">ATRIBUTO</color></size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(126f) });
			GUILayout.Label("<size=11><color=#" + Muted + ">PONTOS</color></size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(50f) });
			GUILayout.Space(62f);
			GUILayout.Label("<size=11><color=#" + Muted + ">ITENS</color></size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(48f) });
			GUILayout.FlexibleSpace();
			GUILayout.Label("<size=11><color=#" + Muted + ">EFEITO</color></size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(130f) });
			GUILayout.EndHorizontal();
			prog.ComputeStats(player, out var hp, out var stamina, out var eitr);
			float maxCarryWeight = player.GetMaxCarryWeight();
			int[] array = ItemBonuses.TotalEquipped((Humanoid)(object)player);
			Attr[] all = AttrInfo.All;
			foreach (Attr attr in all)
			{
				int num = (int)attr;
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) });
				GUILayout.Label("<b>" + AttrInfo.DisplayName(attr) + "</b>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(126f) });
				GUILayout.Label($"<size=16>{prog.Spent[num]}</size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(50f) });
				GUI.enabled = unspentPoints > 0;
				if (GUILayout.Button("+", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(28f),
					GUILayout.Height(24f)
				}))
				{
					prog.TrySpend(attr, player);
					RefreshStats(player);
				}
				GUI.enabled = prog.Spent[num] > 0 && ModConfig.RespecEnabled.Value;
				if (GUILayout.Button("-", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(28f),
					GUILayout.Height(24f)
				}))
				{
					if (!prog.TryRefund(attr, player, out _respecReason))
					{
						((Character)player).Message((MessageType)2, _respecReason, 0, (Sprite)null);
					}
					else
					{
						RefreshStats(player);
					}
				}
				GUI.enabled = true;
				GUILayout.Label((array[num] > 0) ? $"<color=#{Bonus}>+{array[num]}</color>" : ("<color=#" + Muted + ">-</color>"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(48f) });
				GUILayout.FlexibleSpace();
				GUILayout.Label("<color=#" + Muted + ">" + AttrInfo.Effect(attr) + "</color>  <b>" + ValueFor(attr, hp, stamina, eitr, maxCarryWeight) + "</b>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(130f) });
				GUILayout.EndHorizontal();
			}
		}

		private void DrawEquipment(Player player)
		{
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_052a: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return;
			}
			List<ItemData> equippedItems = inventory.GetEquippedItems();
			GUILayout.Label(string.Format("<b>Equipamento</b>  <size=12><color=#{0}>{1} peca{2}</color></size>", Muted, equippedItems.Count, (equippedItems.Count == 1) ? "" : "s"), Array.Empty<GUILayoutOption>());
			GUILayout.Space(2f);
			EquipmentRow.Slot[] slots = EquipmentRow.Slots;
			foreach (EquipmentRow.Slot slot in slots)
			{
				ItemData val = EquipmentRow.ItemIn(inventory, slot);
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(26f) });
				GUILayout.Label("<size=12><color=#" + Muted + ">" + slot.Name + "</color></size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(78f) });
				if (val == null)
				{
					GUILayout.Label("<size=12><color=#" + Muted + ">vazio</color></size>", Array.Empty<GUILayoutOption>());
					GUILayout.EndHorizontal();
					continue;
				}
				DrawIcon(val, 24f);
				GUILayout.Space(6f);
				string text = Localization.instance.Localize(val.m_shared.m_name);
				string text2 = ((val.m_shared.m_maxQuality > 1) ? $" <size=11><color=#{Muted}>q{val.m_quality}</color></size>" : "");
				string text3 = ((val.m_stack > 1) ? $" <size=11><color=#{Muted}>x{val.m_stack}</color></size>" : "");
				GUILayout.Label(text + text2 + text3, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(190f) });
				int[] bonuses = ItemBonuses.For(val);
				GUILayout.Label(ItemBonuses.Any(bonuses) ? ("<size=12><color=#" + Bonus + ">" + ItemBonuses.Describe(bonuses) + "</color></size>") : ("<size=12><color=#" + Muted + ">-</color></size>"), Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
				if (GUILayout.Button("Tirar", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(52f),
					GUILayout.Height(22f)
				}))
				{
					((Humanoid)player).UnequipItem(val, true);
					RefreshStats(player);
				}
				GUILayout.EndHorizontal();
			}
			List<ItemData> list = EquipmentRow.OverflowItems(inventory);
			if (list.Count > 0)
			{
				GUILayout.Space(4f);
				GUILayout.Label($"<size=12><color=#{Muted}>Sem espaco na mochila ({list.Count}): abra espaco e clique em Guardar.</color></size>", Array.Empty<GUILayoutOption>());
				foreach (ItemData item in list)
				{
					GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(26f) });
					DrawIcon(item, 22f);
					GUILayout.Space(6f);
					GUILayout.Label(Localization.instance.Localize(item.m_shared.m_name), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(190f) });
					GUILayout.FlexibleSpace();
					if (GUILayout.Button("Guardar", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(70f),
						GUILayout.Height(22f)
					}) && !EquipmentRow.TryStore(inventory, item))
					{
						((Character)player).Message((MessageType)2, "Mochila cheia.", 0, (Sprite)null);
					}
					if (GUILayout.Button("Equipar", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(70f),
						GUILayout.Height(22f)
					}))
					{
						((Humanoid)player).EquipItem(item, true);
						RefreshStats(player);
					}
					GUILayout.EndHorizontal();
				}
			}
			GUILayout.Space(6f);
			List<ItemData> list2 = new List<ItemData>();
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem != null && allItem.IsEquipable() && !allItem.m_equipped)
				{
					list2.Add(allItem);
				}
			}
			list2.Sort(delegate(ItemData a, ItemData b)
			{
				int num = SlotOrder(a).CompareTo(SlotOrder(b));
				return (num == 0) ? string.Compare(a.m_shared.m_name, b.m_shared.m_name, StringComparison.Ordinal) : num;
			});
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(_showEquipList ? "▾  Equipar da mochila" : "▸  Equipar da mochila", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(22f) }))
			{
				_showEquipList = !_showEquipList;
			}
			GUILayout.Label(string.Format("<size=12><color=#{0}>{1} disponivel{2}</color></size>", Muted, list2.Count, (list2.Count == 1) ? "" : "is"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) });
			GUILayout.EndHorizontal();
			if (!_showEquipList || list2.Count == 0)
			{
				return;
			}
			_equipScroll = GUILayout.BeginScrollView(_equipScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(Mathf.Min(160f, 28f * (float)list2.Count + 6f)) });
			foreach (ItemData item2 in list2)
			{
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(26f) });
				DrawIcon(item2, 22f);
				GUILayout.Space(6f);
				string text4 = Localization.instance.Localize(item2.m_shared.m_name);
				string text5 = ((item2.m_shared.m_maxQuality > 1) ? $" <size=11><color=#{Muted}>q{item2.m_quality}</color></size>" : "");
				int[] bonuses2 = ItemBonuses.For(item2);
				string text6 = (ItemBonuses.Any(bonuses2) ? ("  <size=12><color=#" + Bonus + ">" + ItemBonuses.Describe(bonuses2) + "</color></size>") : "");
				if (GUILayout.Button("<size=13>" + text4 + text5 + text6 + "</size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) }))
				{
					((Humanoid)player).EquipItem(item2, true);
					RefreshStats(player);
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
		}

		private static void DrawXpBar(PlayerProgress prog, bool atCap)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = GUILayoutUtility.GetRect(1f, 20f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUI.color = BorderColor;
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x - 1f, ((Rect)(ref rect)).y - 1f, ((Rect)(ref rect)).width + 2f, ((Rect)(ref rect)).height + 2f), (Texture)(object)White);
			GUI.color = BarBg;
			GUI.DrawTexture(rect, (Texture)(object)White);
			float num = (atCap ? 1f : prog.LevelProgress);
			GUI.color = XpFill;
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width * num, ((Rect)(ref rect)).height), (Texture)(object)White);
			GUI.color = Color.white;
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				alignment = (TextAnchor)4,
				fontSize = 12,
				fontStyle = (FontStyle)1
			};
			val.normal.textColor = Color.white;
			string text = (atCap ? "LEVEL MAXIMO" : $"{prog.Xp} / {prog.XpForNextLevel} XP   ({num * 100f:0}%)");
			GUI.Label(rect, text, val);
		}

		private static void Separator()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = GUILayoutUtility.GetRect(1f, 1f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUI.color = new Color(BorderColor.r, BorderColor.g, BorderColor.b, 0.5f);
			GUI.DrawTexture(rect, (Texture)(object)White);
			GUI.color = Color.white;
		}

		private static void DrawIcon(ItemData item, float size)
		{
			//IL_001a: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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)
			Rect rect = GUILayoutUtility.GetRect(size, size, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(size),
				GUILayout.Height(size)
			});
			Sprite val = null;
			try
			{
				val = item.GetIcon();
			}
			catch
			{
			}
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.texture == (Object)null))
			{
				Texture2D texture = val.texture;
				Rect textureRect = default(Rect);
				try
				{
					textureRect = val.textureRect;
				}
				catch
				{
					((Rect)(ref textureRect))..ctor(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height);
				}
				Rect val2 = default(Rect);
				((Rect)(ref val2))..ctor(((Rect)(ref textureRect)).x / (float)((Texture)texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)texture).height, ((Rect)(ref textureRect)).width / (float)((Texture)texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)texture).height);
				GUI.DrawTextureWithTexCoords(rect, (Texture)(object)texture, val2, true);
			}
		}

		private static int SlotOrder(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected I4, but got Unknown
			ItemType itemType = item.m_shared.m_itemType;
			return (itemType - 3) switch
			{
				0 => 0, 
				11 => 0, 
				19 => 0, 
				1 => 0, 
				2 => 1, 
				3 => 2, 
				4 => 3, 
				8 => 4, 
				14 => 5, 
				15 => 6, 
				21 => 7, 
				12 => 8, 
				16 => 9, 
				_ => 20, 
			};
		}

		private static string SlotName(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected I4, but got Unknown
			ItemType itemType = item.m_shared.m_itemType;
			return (itemType - 3) switch
			{
				0 => "Arma", 
				11 => "Arma 2M", 
				19 => "Arma 2M", 
				1 => "Arco", 
				2 => "Escudo", 
				3 => "Cabeca", 
				4 => "Peito", 
				8 => "Pernas", 
				14 => "Capa", 
				15 => "Utilidade", 
				21 => "Amuleto", 
				12 => "Tocha", 
				16 => "Ferramenta", 
				6 => "Municao", 
				_ => ((object)Unsafe.As<ItemType, ItemType>(ref item.m_shared.m_itemType)/*cast due to .constrained prefix*/).ToString(), 
			};
		}

		private static string ValueFor(Attr attr, float hp, float stam, float eitr, float carry)
		{
			return attr switch
			{
				Attr.Vitality => $"{hp:0}", 
				Attr.Endurance => $"{stam:0}", 
				Attr.Spirit => $"{eitr:0}", 
				Attr.Conditioning => $"{carry:0} kg", 
				_ => "", 
			};
		}

		internal static void RefreshStats(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				player.UpdateFood(0f, true);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "TakeInput")]
	internal static class Player_TakeInput_Patch
	{
		private static void Postfix(ref bool __result)
		{
			if (MmoUI.PanelOpen)
			{
				__result = false;
			}
		}
	}
}
namespace ValheimMMO.Quests
{
	internal static class QuestListUI
	{
		public static void Draw(Player player, int tier, string header)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			string text = ColorUtility.ToHtmlStringRGB(MmoUI.MutedC);
			string text2 = ColorUtility.ToHtmlStringRGB(MmoUI.GoldC);
			string text3 = ColorUtility.ToHtmlStringRGB(MmoUI.BonusC);
			GUILayout.Label("<size=12><color=#" + text + ">" + header + "</color></size>", Array.Empty<GUILayoutOption>());
			GUILayout.Space(6f);
			List<Quest> list = QuestSystem.TodayFor(player, tier);
			if (list.Count == 0)
			{
				GUILayout.Label("<color=#" + text + ">Sem missoes hoje.</color>", Array.Empty<GUILayoutOption>());
			}
			foreach (Quest item in list)
			{
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				string text4 = (item.Claimed ? ("<color=#" + text + ">feita hoje</color>") : ((!item.Accepted) ? ("<color=#" + text + ">disponivel</color>") : (item.Complete ? ("<color=#" + text2 + ">completa - fale comigo</color>") : $"<color=#{text2}>{item.Progress}/{item.Required}</color>")));
				GUILayout.Label("<size=14><b>" + item.Title + "</b></size>   <size=12>" + text4 + "</size>", Array.Empty<GUILayoutOption>());
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label($"<size=12><color=#{text}>Recompensa:</color> <color=#{text3}>{item.GoldReward}</color> moedas, <color=#{text3}>{item.XpReward}</color> XP</size>", Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
				string message = null;
				if (item.Claimed)
				{
					GUI.enabled = false;
					GUILayout.Button("Feita hoje", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(110f),
						GUILayout.Height(22f)
					});
					GUI.enabled = true;
				}
				else if (!item.Accepted)
				{
					if (GUILayout.Button("Aceitar", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(110f),
						GUILayout.Height(22f)
					}))
					{
						QuestSystem.Accept(player, item, out message);
					}
				}
				else if (item.Complete)
				{
					if (GUILayout.Button("Concluir", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(110f),
						GUILayout.Height(22f)
					}))
					{
						QuestSystem.Claim(player, item, out message);
					}
				}
				else
				{
					if (item.Kind == QuestKind.Deliver && GUILayout.Button("Entregar", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(110f),
						GUILayout.Height(22f)
					}))
					{
						QuestSystem.Deliver(player, item, out message);
					}
					if (GUILayout.Button("Abandonar", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(90f),
						GUILayout.Height(22f)
					}))
					{
						QuestSystem.Abandon(player, item, out message);
					}
				}
				if (message != null)
				{
					((Character)player).Message((MessageType)2, message, 0, (Sprite)null);
				}
				GUILayout.EndHorizontal();
				GUILayout.Space(8f);
				GUILayout.EndVertical();
			}
		}
	}
	public class QuestNpcUI : MonoBehaviour
	{
		internal static bool IsOpen;

		private static int _tier;

		private const float W = 560f;

		public static void Open(int tier)
		{
			_tier = tier;
			IsOpen = true;
		}

		private void Update()
		{
			if (IsOpen && ((Object)(object)Player.m_localPlayer == (Object)null || Input.GetKeyDown((KeyCode)27)))
			{
				IsOpen = false;
			}
		}

		private void OnGUI()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (IsOpen && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				GUISkin skin = GUI.skin;
				Matrix4x4 matrix = GUI.matrix;
				GUI.skin = MmoUI.Skin;
				float num = Mathf.Clamp((float)Screen.height / 1080f, 0.75f, 2.5f);
				GUI.matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(num, num, 1f));
				float num2 = (float)Screen.width / num;
				CityDef cityDef = CitySystem.ByTier(_tier);
				string text = ((cityDef != null) ? ("MISSOES - " + cityDef.Name.ToUpperInvariant()) : "MISSOES");
				GUILayout.Window(((Object)this).GetInstanceID(), new Rect((num2 - 560f) * 0.5f, 120f, 560f, 0f), new WindowFunction(Draw), text, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(560f) });
				GUI.matrix = matrix;
				GUI.skin = skin;
			}
		}

		private void Draw(int id)
		{
			QuestListUI.Draw(Player.m_localPlayer, _tier, $"Dia {QuestSystem.CurrentDay()} · aceite, cumpra e volte aqui para concluir. Cada missao vale uma vez por dia; amanha troca. Recompensa sempre em ouro.");
			GUILayout.Space(4f);
			if (GUILayout.Button("Fechar", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) }))
			{
				IsOpen = false;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "TakeInput")]
	internal static class Player_TakeInput_QuestNpcPatch
	{
		private static void Postfix(ref bool __result)
		{
			if (QuestNpcUI.IsOpen)
			{
				__result = false;
			}
		}
	}
	internal enum QuestKind
	{
		Kill,
		Deliver,
		DungeonBoss
	}
	internal sealed class Quest
	{
		public int Tier;

		public int Index;

		public QuestKind Kind;

		public string Target;

		public string TargetName;

		public int Required;

		public int Progress;

		public bool Accepted;

		public bool Claimed;

		public int GoldReward;

		public long XpReward;

		public bool Complete => Progress >= Required;

		public bool Active
		{
			get
			{
				if (Accepted)
				{
					return !Claimed;
				}
				return false;
			}
		}

		public string Title => Kind switch
		{
			QuestKind.Kill => $"Mate {Required}x {TargetName}", 
			QuestKind.Deliver => $"Entregue {Required}x {TargetName}", 
			QuestKind.DungeonBoss => "Derrote o boss de dungeon: " + TargetName, 
			_ => "", 
		};

		public string ShortTitle => Kind switch
		{
			QuestKind.Kill => TargetName ?? "", 
			QuestKind.Deliver => "Entregar " + TargetName, 
			QuestKind.DungeonBoss => "Boss: " + TargetName, 
			_ => "", 
		};
	}
	internal static class QuestSystem
	{
		private sealed class DayCache
		{
			public int Day;

			public List<Quest> List;
		}

		public const int MaxTier = 7;

		private static readonly string[][] KillPools = new string[7][]
		{
			new string[4] { "Greyling", "Boar", "Neck", "Deer" },
			new string[5] { "Greydwarf", "Skeleton", "Greydwarf_Shaman", "Troll", "Ghost" },
			new string[6] { "Draugr", "Blob", "Leech", "Wraith", "Abomination", "Surtling" },
			new string[5] { "Wolf", "Fenring", "Hatchling", "StoneGolem", "Ulv" },
			new string[5] { "Goblin", "Deathsquito", "Lox", "GoblinShaman", "GoblinBrute" },
			new string[5] { "Seeker", "Tick", "Gjall", "Dverger", "SeekerBrute" },
			new string[5] { "Charred_Melee", "Charred_Archer", "Asksvin", "Morgen", "Volture" }
		};

		private static readonly string[][] DeliverPools = new string[7][]
		{
			new string[6] { "Wood", "Stone", "Resin", "LeatherScraps", "RawMeat", "Raspberry" },
			new string[6] { "FineWood", "CopperOre", "TinOre", "Bronze", "TrollHide", "Coal" },
			new string[6] { "IronScrap", "Guck", "Bloodbag", "Entrails", "Turnip", "Ooze" },
			new string[6] { "WolfPelt", "Silver", "Obsidian", "FreezeGland", "Crystal", "Onion" },
			new string[6] { "BlackMetalScrap", "Barley", "Flax", "LoxPelt", "Needle", "Tar" },
			new string[6] { "Carapace", "YggdrasilWood", "Sap", "Softtissue", "BlackMarble", "Mandible" },
			new string[5] { "FlametalOreNew", "CharredBone", "Grausten", "Blackwood", "AskHide" }
		};

		private static readonly Dictionary<int, DayCache> Cache = new Dictionary<int, DayCache>();

		public static int CurrentDay()
		{
			if (!((Object)(object)EnvMan.instance != (Object)null))
			{
				return 0;
			}
			return EnvMan.instance.GetDay();
		}

		private static string KeyFor(int tier)
		{
			return $"mmo.quests.{tier}";
		}

		public static List<Quest> TodayFor(Player player, int tier)
		{
			if (!ModConfig.QuestsEnabled.Value || (Object)(object)player == (Object)null)
			{
				return new List<Quest>();
			}
			tier = Mathf.Clamp(tier, 1, KillPools.Length);
			int num = tier - 1;
			int num2 = CurrentDay();
			if (Cache.TryGetValue(tier, out var value) && value.Day == num2)
			{
				if (value.List.Count > 0 && value.List[0].Progress == 0 && !value.List[0].Accepted)
				{
					LoadProgress(player, tier, value.List);
				}
				return value.List;
			}
			Random random = new Random((int)((((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetWorldUID() : 0) ^ ((long)num2 * 7919L) ^ ((long)tier * 104729L)));
			List<Quest> list = new List<Quest>();
			string text = PickExisting(random, KillPools[num], IsCreature);
			if (text != null)
			{
				Character component = ZNetScene.instance.GetPrefab(text).GetComponent<Character>();
				float num3 = Mathf.Max(1f, component.m_health);
				int num4 = 8 + random.Next(0, 8);
				int num5 = Mathf.CeilToInt(Mathf.Pow(num3, 0.6f) * (float)num4 * 1.5f * ModConfig.QuestRewardMultiplier.Value);
				list.Add(new Quest
				{
					Tier = tier,
					Index = 0,
					Kind = QuestKind.Kill,
					Target = text,
					TargetName = Localization.instance.Localize(component.m_name),
					Required = num4,
					GoldReward = num5,
					XpReward = (long)num5 * 3L
				});
			}
			string text2 = PickExisting(random, DeliverPools[num], IsItem);
			if (text2 != null)
			{
				int num6 = 10 + random.Next(0, 11);
				int num7 = Mathf.CeilToInt((float)(MerchantPricing.PriceOf(text2) * num6) * 1.5f * ModConfig.QuestRewardMultiplier.Value);
				list.Add(new Quest
				{
					Tier = tier,
					Index = 1,
					Kind = QuestKind.Deliver,
					Target = text2,
					TargetName = Localization.instance.Localize(ObjectDB.instance.GetItemPrefab(text2).GetComponent<ItemDrop>().m_itemData.m_shared.m_name),
					Required = num6,
					GoldReward = num7,
					XpReward = (long)num7 * 3L
				});
			}
			DungeonTier dungeonTier = DungeonBosses.TierById(Mathf.Clamp(tier, 1, DungeonBosses.Tiers.Length));
			if (dungeonTier != null)
			{
				int num8 = Mathf.CeilToInt((float)DungeonBosses.GoldFor(dungeonTier) * 0.5f * ModConfig.QuestRewardMultiplier.Value);
				list.Add(new Quest
				{
					Tier = tier,
					Index = 2,
					Kind = QuestKind.DungeonBoss,
					Target = dungeonTier.Id.ToString(),
					TargetName = dungeonTier.Title,
					Required = 1,
					GoldReward = num8,
					XpReward = (long)num8 * 3L
				});
			}
			Cache[tier] = new DayCache
			{
				Day = num2,
				List = list
			};
			LoadProgress(player, tier, list);
			return list;
		}

		public static List<Quest> Active(Player player)
		{
			List<Quest> list = new List<Quest>();
			if ((Object)(object)player == (Object)null || !ModConfig.QuestsEnabled.Value)
			{
				return list;
			}
			for (int i = 1; i <= 7; i++)
			{
				foreach (Quest item in TodayFor(player, i))
				{
					if (item.Active)
					{
						list.Add(item);
					}
				}
			}
			return list;
		}

		public static void ClearCache()
		{
			Cache.Clear();
		}

		private static bool IsCreature(string name)
		{
			ZNetScene instance = ZNetScene.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameObject prefab = instance.GetPrefab(name);
				obj = ((prefab != null) ? prefab.GetComponent<Character>() : null);
			}
			return (Object)obj != (Object)null;
		}

		private static bool IsItem(string name)
		{
			ObjectDB instance = ObjectDB.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameObject itemPrefab = instance.GetItemPrefab(name);
				obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
			}
			return (Object)obj != (Object)null;
		}

		private static string PickExisting(Random rng, string[] pool, Func<string, bool> exists)
		{
			List<string> list = new List<string>();
			foreach (string text in pool)
			{
				if (exists(text))
				{
					list.Add(text);
				}
			}
			if (list.Count != 0)
			{
				return list[rng.Next(list.Count)];
			}
			return null;
		}

		private static void LoadProgress(Player player, int tier, List<Quest> quests)
		{
			foreach (Quest quest in quests)
			{
				quest.Progress = 0;
				quest.Claimed = false;
				quest.Accepted = false;
			}
			if (!player.m_customData.TryGetValue(KeyFor(tier), out var value) || string.IsNullOrEmpty(value))
			{
				return;
			}
			string[] array = value.Split('|');
			if (array.Length < 1 || !int.TryParse(array[0], out var result) || result != CurrentDay())
			{
				return;
			}
			foreach (Quest quest2 in quests)
			{
				int num = 1 + quest2.Index * 3;
				if (num + 2 < array.Length)
				{
					quest2.Accepted = array[num] == "1";
					int.TryParse(array[num + 1], out quest2.Progress);
					quest2.Claimed = array[num + 2] == "1";
				}
			}
		}

		private static void SaveProgress(Player player, int tier)
		{
			if (!Cache.TryGetValue(tier, out var value))
			{
				return;
			}
			List<Quest> list = value.List;
			List<string> list2 = new List<string> { CurrentDay().ToString(CultureInfo.InvariantCulture) };
			int idx;
			for (idx = 0; idx < 3; idx++)
			{
				Quest quest = list.Find((Quest x) => x.Index == idx);
				list2.Add((quest != null && quest.Accepted) ? "1" : "0");
				list2.Add((quest?.Progress ?? 0).ToString(CultureInfo.InvariantCulture));
				list2.Add((quest != null && quest.Claimed) ? "1" : "0");
			}
			player.m_customData[KeyFor(tier)] = string.Join("|", list2);
		}

		public static bool Accept(Player player, Quest q, out string message)
		{
			message = null;
			if (q.Accepted || q.Claimed)
			{
				return false;
			}
			int count = Active(player).Count;
			int num = Mathf.Max(1, ModConfig.QuestMaxActive.Value);
			if (count >= num)
			{
				message = $"Voce ja tem {count} missoes em andamento (maximo {num}).";
				return false;
			}
			q.Accepted = true;
			SaveProgress(player, q.Tier);
			message = "Missao aceita: " + q.Title;
			return true;
		}

		public static bool Abandon(Player player, Quest q, out string message)
		{
			message = null;
			if (!q.Active)
			{
				return false;
			}
			q.Accepted = false;
			q.Progress = 0;
			SaveProgress(player, q.Tier);
			message = "Missao abandonada.";
			return true;
		}

		public static void OnKill(string victimPrefab, int dungeonTier)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !ModConfig.QuestsEnabled.Value)
			{
				return;
			}
			for (int i = 1; i <= KillPools.Length; i++)
			{
				List<Quest> list = TodayFor(localPlayer, i);
				bool flag = false;
				foreach (Quest item in list)
				{
					if (item.Active && !item.Complete && ((item.Kind == QuestKind.Kill && item.Target == victimPrefab) || (item.Kind == QuestKind.DungeonBoss && dungeonTier > 0 && item.Target == dungeonTier.ToString())))
					{
						item.Progress++;
						flag = true;
						if (item.Complete)
						{
							((Character)localPlayer).Message((MessageType)2, "Missao completa: " + item.Title + ". Volte ao emissario.", 0, (Sprite)null);
						}
						else
						{
							((Character)localPlayer).Message((MessageType)1, $"{item.ShortTitle}: {item.Progress}/{item.Required}", 0, (Sprite)null);
						}
					}
				}
				if (flag)
				{
					SaveProgress(localPlayer, i);
				}
			}
		}

		public static bool Deliver(Player player, Quest q, out string message)
		{
			message = null;
			if (q.Kind != QuestKind.Deliver || !q.Active)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(q.Target);
			ItemDrop val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			string name = val.m_itemData.m_shared.m_name;
			int num = Mathf.Min(inventory.CountItems(name, -1, true), q.Required - q.Progress);
			if (num <= 0)
			{
				message = "Voce nao tem esse item na mochila.";
				return false;
			}
			inventory.RemoveItem(name, num, -1, true);
			q.Progress += num;
			SaveProgress(player, q.Tier);
			if (q.Complete)
			{
				return Claim(player, q, out message);
			}
			message = $"Entregue {num}. Faltam {q.Required - q.Progress}.";
			return true;
		}

		public static bool Claim(Player player, Quest q, out string message)
		{
			message = null;
			if (q.Claimed || !q.Accepted || !q.Complete)
			{
				message = "Missao ainda nao concluida.";
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("Coins");
			ItemDrop val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val == (Object)null)
			{
				message = "Moeda indisponivel.";
				return false;
			}
			int num = q.GoldReward;
			int num2 = Mathf.Max(1, val.m_itemData.m_shared.m_maxStackSize);
			while (num > 0)
			{
				int num3 = Mathf.Min(num2, num);
				if (inventory.AddItem(((Object)((Component)val).gameObject).name, num3, val.m_itemData.m_quality, val.m_itemData.m_variant, 0L, "", false) == null)
				{
					message = "Sem espaco na mochila para a recompensa.";
					return false;
				}
				num -= num3;
			}
			KillXpNetwork.Award(player, q.XpReward, null);
			q.Claimed = true;
			SaveProgress(player, q.Tier);
			message = $"Missao concluida! {q.GoldReward} moedas e {q.XpReward} XP";
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "Load")]
	internal static class Player_Load_QuestCachePatch
	{
		private static void Postfix()
		{
			QuestSystem.ClearCache();
		}
	}
	public class QuestTracker : MonoBehaviour
	{
		private const float W = 250f;

		private float _refresh;

		private List<Quest> _active = new List<Quest>();

		private void Update()
		{
			_refresh -= Time.unscaledDeltaTime;
			if (!(_refresh > 0f))
			{
				_refresh = 1f;
				Player localPlayer = Player.m_localPlayer;
				_active = (((Object)(object)localPlayer != (Object)null && ModConfig.QuestTrackerEnabled.Value) ? QuestSystem.Active(localPlayer) : new List<Quest>());
			}
		}

		private void OnGUI()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.QuestTrackerEnabled.Value || _active.Count == 0 || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)Hud.instance == (Object)null || !Hud.instance.m_rootObject.activeSelf || Menu.IsVisible() || InventoryGui.IsVisible() || StoreGui.IsVisible() || Minimap.IsOpen() || Console.IsVisible())
			{
				return;
			}
			GUISkin skin = GUI.skin;
			Matrix4x4 matrix = GUI.matrix;
			GUI.skin = MmoUI.Skin;
			float num = Mathf.Clamp((float)Screen.height / 1080f, 0.75f, 2.5f);
			GUI.matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(num, num, 1f));
			float num2 = (float)Screen.width / num;
			string text = ColorUtility.ToHtmlStringRGB(MmoUI.MutedC);
			string text2 = ColorUtility.ToHtmlStringRGB(MmoUI.GoldC);
			GUILayout.BeginArea(new Rect(num2 - 250f - ModConfig.QuestTrackerOffsetX.Value, ModConfig.QuestTrackerOffsetY.Value, 250f, 0f));
			GUILayout.Label("<size=12><color=#" + text2 + "><b>MISSOES</b></color></size>", Array.Empty<GUILayoutOption>());
			foreach (Quest item in _active)
			{
				string text3 = CitySystem.ByTier(item.Tier)?.Name ?? BiomeTiers.Name(item.Tier);
				string text4 = (item.Complete ? ("<color=#" + text2 + ">completa</color>") : $"{item.Progress}/{item.Required}");
				GUILayout.Label("<size=12>" + item.ShortTitle + "  <color=#" + text2 + ">" + text4 + "</color></size>\n<size=10><color=#" + text + ">" + text3 + "</color></size>", Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndArea();
			GUI.matrix = matrix;
			GUI.skin = skin;
		}
	}
}
namespace ValheimMMO.Pvp
{
	internal static class Karma
	{
		private const string Key = "mmo.karma";

		public const string ZdoKey = "mmo_karma";

		private const string RpcKill = "ValheimMMO_KarmaKill";

		private static float _syncTimer;

		private static float _lastSynced = -1f;

		public static float Of(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return 0f;
			}
			if ((Object)(object)p == (Object)(object)Player.m_localPlayer)
			{
				return Local(p);
			}
			ZDO obj = (((Object)(object)((Character)p).m_nview != (Object)null && ((Character)p).m_nview.IsValid()) ? ((Character)p).m_nview.GetZDO() : null);
			if (obj == null)
			{
				return 0f;
			}
			return obj.GetFloat("mmo_karma", 0f);
		}

		public static float Local(Player p)
		{
			if (p.m_customData.TryGetValue("mmo.karma", out var value) && float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return 0f;
		}

		public static bool IsWanted(Player p)
		{
			if (ModConfig.PvpEnabled.Value)
			{
				return Of(p) >= ModConfig.WantedThreshold.Value;
			}
			return false;
		}

		public static bool IsOutlaw(Player p)
		{
			if (ModConfig.PvpEnabled.Value)
			{
				return Of(p) >= ModConfig.OutlawThreshold.Value;
			}
			return false;
		}

		public static string StatusName(float k)
		{
			if (k >= ModConfig.OutlawThreshold.Value)
			{
				return "Fora da lei";
			}
			if (k >= ModConfig.WantedThreshold.Value)
			{
				return "Procurado";
			}
			return "Limpo";
		}

		public static void Set(Player p, float value, bool announce = true)
		{
			if ((Object)(object)p == (Object)null)
			{
				return;
			}
			float num = Local(p);
			value = Mathf.Clamp(value, 0f, ModConfig.KarmaMax.Value);
			p.m_customData["mmo.karma"] = value.ToString("R", CultureInfo.InvariantCulture);
			Sync(p, force: true);
			if (announce)
			{
				bool num2 = num >= ModConfig.WantedThreshold.Value;
				bool flag = value >= ModConfig.WantedThreshold.Value;
				if (!num2 && flag)
				{
					((Character)p).Message((MessageType)2, "Voce agora e PROCURADO. Guardas vao atacar e as cidades fecham para voce.", 0, (Sprite)null);
				}
				if (num2 && !flag)
				{
					((Character)p).Message((MessageType)2, "Seu nome foi limpo.", 0, (Sprite)null);
				}
			}
		}

		public static void Add(Player p, float delta, bool announce = true)
		{
			Set(p, Local(p) + delta, announce);
		}

		private static void Sync(Player p, bool force)
		{
			if (!((Object)(object)((Character)p).m_nview == (Object)null) && ((Character)p).m_nview.IsValid() && ((Character)p).m_nview.IsOwner())
			{
				float num = Local(p);
				if (force || !(Mathf.Abs(num - _lastSynced) < 0.05f))
				{
					((Character)p).m_nview.GetZDO().Set("mmo_karma", num);
					_lastSynced = num;
				}
			}
		}

		internal static void Tick(Player p, float dt)
		{
			if (!ModConfig.PvpEnabled.Value || (Object)(object)p == (Object)null)
			{
				return;
			}
			float num = Local(p);
			if (num > 0f)
			{
				float num2 = Mathf.Max(0f, num - ModConfig.KarmaDecayPerMinute.Value / 60f * dt);
				if (num2 != num)
				{
					bool num3 = num >= ModConfig.WantedThreshold.Value && num2 < ModConfig.WantedThreshold.Value;
					p.m_customData["mmo.karma"] = num2.ToString("R", CultureInfo.InvariantCulture);
					if (num3)
					{
						((Character)p).Message((MessageType)2, "Seu nome foi limpo.", 0, (Sprite)null);
					}
				}
			}
			_syncTimer += dt;
			if (_syncTimer >= 2f)
			{
				_syncTimer = 0f;
				Sync(p, force: false);
			}
		}

		internal static void OnMonsterKill(float victimMaxHp, bool boss)
		{
			Player localPlayer = Player.m_localPlayer;
			if (ModConfig.PvpEnabled.Value && !((Object)(object)localPlayer == (Object)null) && !(Local(localPlayer) <= 0f))
			{
				float num = ModConfig.KarmaMonsterFactor.Value * Mathf.Pow(Mathf.Max(1f, victimMaxHp), 0.6f) * (boss ? 5f : 1f);
				Add(localPlayer, 0f - num);
			}
		}

		internal static void Register()
		{
			if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<string, float>("ValheimMMO_KarmaKill", (Action<long, string, float>)OnKillCredit);
			}
		}

		internal static void OnPlayerDied(Player victim)
		{
			if (!ModConfig.PvpEnabled.Value || (Object)(object)victim == (Object)null)
			{
				return;
			}
			float num = Local(victim);
			if (num > 0f)
			{
				Add(victim, 0f - ModConfig.KarmaDeathLoss.Value, announce: false);
			}
			HitData lastHit = ((Character)victim).m_lastHit;
			Character obj = ((lastHit != null) ? lastHit.GetAttacker() : null);
			Player val = (Player)(object)((obj is Player) ? obj : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)victim)
			{
				return;
			}
			ZDO val2 = (((Object)(object)((Character)val).m_nview != (Object)null && ((Character)val).m_nview.IsValid()) ? ((Character)val).m_nview.GetZDO() : null);
			if (val2 == null)
			{
				return;
			}
			long owner = val2.GetOwner();
			if ((Object)(object)val == (Object)(object)Player.m_localPlayer)
			{
				OnKillCredit(0L, victim.GetPlayerName(), num);
				return;
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				instance.InvokeRoutedRPC(owner, "ValheimMMO_KarmaKill", new object[2]
				{
					victim.GetPlayerName(),
					num
				});
			}
		}

		private static void OnKillCredit(long sender, string victimName, float victimKarma)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !ModConfig.PvpEnabled.Value)
			{
				return;
			}
			if (victimKarma >= ModConfig.WantedThreshold.Value)
			{
				int num = Mathf.RoundToInt(victimKarma * ModConfig.BountyPerKarma.Value);
				if (num > 0)
				{
					KillXpNetwork.GiveGoldPublic(localPlayer, num, $"Recompensa por {victimName}: {num} moedas");
				}
			}
			else
			{
				Add(localPlayer, ModConfig.KarmaPerKill.Value);
				((Character)localPlayer).Message((MessageType)1, $"Assassinato de {victimName}: +{ModConfig.KarmaPerKill.Value:0} karma", 0, (Sprite)null);
			}
		}
	}
	[HarmonyPatch(typeof(Game), "Start")]
	internal static class Game_Start_KarmaPatch
	{
		private static void Postfix()
		{
			Karma.Register();
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateStats", new Type[] { typeof(float) })]
	internal static class Player_UpdateStats_KarmaPatch
	{
		private static void Postfix(Player __instance, float dt)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				Karma.Tick(__instance, dt);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnDeath")]
	internal static class Player_OnDeath_KarmaPatch
	{
		private static void Prefix(Player __instance)
		{
			if ((Object)(object)__instance != (Object)null && (Object)(object)((Character)__instance).m_nview != (Object)null && ((Character)__instance).m_nview.IsOwner())
			{
				Karma.OnPlayerDied(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "GetHoverName")]
	[HarmonyPriority(200)]
	internal static class Player_GetHoverName_KarmaPatch
	{
		private static void Postfix(Player __instance, ref string __result)
		{
			if (ModConfig.PvpEnabled.Value && Karma.IsWanted(__instance))
			{
				__result = "<color=#E04A3A>☠ " + __result + "</color>";
			}
		}
	}
	[HarmonyPatch(typeof(StoreGui), "Show")]
	internal static class StoreGui_Show_KarmaPatch
	{
		private static bool Prefix(Trader trader)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !Karma.IsWanted(localPlayer))
			{
				return true;
			}
			if (!MerchantSpawner.IsMerchant(trader))
			{
				return true;
			}
			((Character)localPlayer).Message((MessageType)2, "O mercador nao negocia com procurados.", 0, (Sprite)null);
			return false;
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "Teleport")]
	internal static class TeleportWorld_Teleport_KarmaPatch
	{
		private static bool Prefix(TeleportWorld __instance, Player player)
		{
			if ((Object)(object)player == (Object)null || !Karma.IsWanted(player))
			{
				return true;
			}
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			ZDO val = (((Object)(object)component != (Object)null && component.IsValid()) ? component.GetZDO() : null);
			if (val == null || !val.GetBool("mmo_city_portal", false))
			{
				return true;
			}
			((Character)player).Message((MessageType)2, "O portal da cidade rejeita procurados.", 0, (Sprite)null);
			return false;
		}
	}
	[HarmonyPatch(typeof(EnemyHud), "TestShow")]
	internal static class EnemyHud_TestShow_StealthPatch
	{
		private static void Postfix(Character c, ref bool __result)
		{
			if (__result && ModConfig.StealthHidesName.Value)
			{
				Player val = (Player)(object)((c is Player) ? c : null);
				if (val != null && (Object)(object)val != (Object)(object)Player.m_localPlayer && ((Character)val).IsCrouching())
				{
					__result = false;
				}
			}
		}
	}
}
namespace ValheimMMO.Progression
{
	public enum Attr
	{
		Vitality,
		Endurance,
		Spirit,
		Conditioning
	}
	public static class AttrInfo
	{
		public const int Count = 4;

		public static readonly Attr[] All = new Attr[4]
		{
			Attr.Vitality,
			Attr.Endurance,
			Attr.Spirit,
			Attr.Conditioning
		};

		public static string DisplayName(Attr a)
		{
			return a switch
			{
				Attr.Vitality => "Vitalidade", 
				Attr.Endurance => "Resistencia", 
				Attr.Spirit => "Espirito", 
				Attr.Conditioning => "Condicionamento", 
				_ => a.ToString(), 
			};
		}

		public static string Short(Attr a)
		{
			return a switch
			{
				Attr.Vitality => "VIT", 
				Attr.Endurance => "RES", 
				Attr.Spirit => "ESP", 
				Attr.Conditioning => "CON", 
				_ => "?", 
			};
		}

		public static string Effect(Attr a)
		{
			return a switch
			{
				Attr.Vitality => "Vida maxima", 
				Attr.Endurance => "Stamina maxima", 
				Attr.Spirit => "Eitr maximo", 
				Attr.Conditioning => "Peso maximo", 
				_ => "", 
			};
		}
	}
	public static class ItemBonuses
	{
		public static bool Enabled => ModConfig.ItemBonusesEnabled.Value;

		public static int[] For(ItemData item)
		{
			if (item != null)
			{
				return For(item, item.m_quality, item.m_worldLevel);
			}
			return new int[4];
		}

		public static int[] For(ItemData item, int quality, float worldLevel)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected I4, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Invalid comparison between Unknown and I4
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Invalid comparison between Unknown and I4
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Invalid comparison between Unknown and I4
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Invalid comparison between Unknown and I4
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Invalid comparison between Unknown and I4
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			int[] result = new int[4];
			if (!Enabled || item?.m_shared == null)
			{
				return result;
			}
			SharedData shared = item.m_shared;
			quality = Mathf.Max(1, quality);
			ItemType itemType = shared.m_itemType;
			switch (itemType - 3)
			{
			default:
				if ((int)itemType != 22)
				{
					break;
				}
				goto case 0;
			case 3:
			case 4:
			case 8:
			{
				float armor2 = item.GetArmor(quality, worldLevel);
				Add(result, ArmorAttribute(shared), armor2 * ModConfig.ArmorToAttribute.Value);
				break;
			}
			case 14:
			{
				float armor = item.GetArmor(quality, worldLevel);
				Add(result, Attr.Conditioning, armor * ModConfig.ArmorToAttribute.Value);
				break;
			}
			case 2:
			{
				float blockPower = item.GetBlockPower(quality, 0f);
				Add(result, Attr.Vitality, blockPower * ModConfig.BlockToAttribute.Value);
				break;
			}
			case 0:
			case 1:
			case 11:
			{
				SkillType skillType = shared.m_skillType;
				DamageTypes damage;
				if ((int)skillType == 9 || (int)skillType == 10)
				{
					float value = ModConfig.MagicStaffBase.Value + ModConfig.MagicStaffPerQuality.Value * (float)(quality - 1);
					Add(result, Attr.Spirit, value);
				}
				else if ((int)skillType == 8 || (int)skillType == 14)
				{
					damage = item.GetDamage(quality, worldLevel);
					float totalDamage = ((DamageTypes)(ref damage)).GetTotalDamage();
					Add(result, Attr.Endurance, totalDamage * ModConfig.RangedDamageToAttribute.Value);
				}
				else
				{
					damage = item.GetDamage(quality, worldLevel);
					float totalDamage2 = ((DamageTypes)(ref damage)).GetTotalDamage();
					Add(result, Attr.Endurance, totalDamage2 * ModConfig.MeleeDamageToAttribute.Value);
				}
				break;
			}
			case 5:
			case 6:
			case 7:
			case 9:
			case 10:
			case 12:
			case 13:
				break;
			}
			return result;
		}

		private static void Add(int[] result, Attr attr, float value)
		{
			int num = Mathf.RoundToInt(value);
			if (num > 0)
			{
				result[(int)attr] += num;
			}
		}

		public static Attr ArmorAttribute(SharedData shared)
		{
			if (shared.m_eitrRegenModifier > 0f)
			{
				return Attr.Spirit;
			}
			if (shared.m_movementModifier <= ModConfig.HeavyArmorMovementThreshold.Value)
			{
				return Attr.Vitality;
			}
			return Attr.Endurance;
		}

		public static int[] TotalEquipped(Humanoid humanoid)
		{
			int[] array = new int[4];
			if (!Enabled || (Object)(object)humanoid == (Object)null)
			{
				return array;
			}
			Inventory inventory = humanoid.GetInventory();
			if (inventory == null)
			{
				return array;
			}
			foreach (ItemData equippedItem in inventory.GetEquippedItems())
			{
				int[] array2 = For(equippedItem);
				for (int i = 0; i < array.Length; i++)
				{
					array[i] += array2[i];
				}
			}
			return array;
		}

		public static bool Any(int[] bonuses)
		{
			if (bonuses == null)
			{
				return false;
			}
			for (int i = 0; i < bonuses.Length; i++)
			{
				if (bonuses[i] != 0)
				{
					return true;
				}
			}
			return false;
		}

		public static string Describe(int[] bonuses, bool shortNames = true)
		{
			List<string> list = new List<string>();
			for (int i = 0; i < bonuses.Length; i++)
			{
				if (bonuses[i] != 0)
				{
					Attr a = (Attr)i;
					list.Add($"+{bonuses[i]} {(shortNames ? AttrInfo.Short(a) : AttrInfo.DisplayName(a))}");
				}
			}
			return string.Join(", ", list);
		}
	}
	[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
	{
		typeof(ItemData),
		typeof(int),
		typeof(bool),
		typeof(float),
		typeof(int)
	})]
	internal static class ItemData_GetTooltip_Patch
	{
		private static void Postfix(ItemData item, int qualityLevel, float worldLevel, ref string __result)
		{
			if (!ModConfig.ShowItemBonusTooltip.Value || !ItemBonuses.Enabled)
			{
				return;
			}
			int[] array = ItemBonuses.For(item, qualityLevel, worldLevel);
			if (!ItemBonuses.Any(array))
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder(__result);
			stringBuilder.Append("\n");
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] != 0)
				{
					Attr a = (Attr)i;
					stringBuilder.Append($"\n{AttrInfo.DisplayName(a)}: <color=orange>+{array[i]}</color>");
				}
			}
			__result = stringBuilder.ToString();
		}
	}
	[HarmonyPatch(typeof(Humanoid), "EquipItem")]
	internal static class Humanoid_EquipItem_Patch
	{
		private static void Postfix(Humanoid __instance, bool __result)
		{
			if (__result)
			{
				RefreshIfLocal(__instance);
			}
		}

		internal static void RefreshIfLocal(Humanoid humanoid)
		{
			Player val = (Player)(object)((humanoid is Player) ? humanoid : null);
			if (val != null && (Object)(object)val == (Object)(object)Player.m_localPlayer)
			{
				val.UpdateFood(0f, true);
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
	internal static class Humanoid_UnequipItem_Patch
	{
		private static void Postfix(Humanoid __instance)
		{
			Humanoid_EquipItem_Patch.RefreshIfLocal(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "GetMaxCarryWeight")]
	internal static class Player_GetMaxCarryWeight_Patch
	{
		private static void Postfix(Player __instance, ref float __result)
		{
			PlayerProgress playerProgress = PlayerProgress.Get(__instance);
			if (playerProgress != null)
			{
				__result += playerProgress.CarryBonusKg(__instance);
			}
		}
	}
	public static class LevelCurve
	{
		public static long XpToNext(int level)
		{
			if (level < 1)
			{
				level = 1;
			}
			if (level >= ModConfig.MaxLevel.Value)
			{
				return 0L;
			}
			return (long)Math.Round((double)ModConfig.XpCurveFactor.Value * Math.Pow(level, ModConfig.XpCurveExponent.Value));
		}

		public static long TotalXpForLevel(int level)
		{
			long num = 0L;
			for (int i = 1; i < level; i++)
			{
				num += XpToNext(i);
			}
			return num;
		}

		public static int PointsGrantedAt(int level)
		{
			return Math.Max(0, (level - 1) * ModConfig.PointsPerLevel.Value);
		}

		public static long XpForKill(Character victim)
		{
			if ((Object)(object)victim == (Object)null)
			{
				return 0L;
			}
			float num = 0f;
			try
			{
				num = victim.GetMaxHealth();
			}
			catch
			{
			}
			if (num <= 0f)
			{
				num = victim.GetMaxHealthBase();
			}
			if (num <= 0f)
			{
				return 0L;
			}
			int num2 = Math.Max(0, victim.GetLevel() - 1);
			double num3 = 1.0 + (double)(ModConfig.XpStarBonus.Value * (float)num2);
			double num4 = 1.0;
			if (victim.IsBoss())
			{
				num4 = (DungeonBosses.IsDungeonBoss(victim, out var _) ? ModConfig.XpDungeonBossMultiplier.Value : ModConfig.XpBossMultiplier.Value);
			}
			return (long)Math.Ceiling((double)ModConfig.XpKillFactor.Value * Math.Pow(num, ModConfig.XpKillExponent.Value) * num3 * num4);
		}
	}
	internal static class LevelDisplay
	{
		public const string ZdoKey = "mmo_level";

		public static void Sync(Player player, int level)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)((Character)player).m_nview == (Object)null) && ((Character)player).m_nview.IsValid() && ((Character)player).m_nview.IsOwner())
			{
				ZDO zDO = ((Character)player).m_nview.GetZDO();
				if (zDO.GetInt("mmo_level", -1) != level)
				{
					zDO.Set("mmo_level", level);
				}
			}
		}

		public static int LevelOf(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return 0;
			}
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				return PlayerProgress.Get(player)?.Level ?? 0;
			}
			ZDO obj = (((Object)(object)((Character)player).m_nview != (Object)null && ((Character)player).m_nview.IsValid()) ? ((Character)player).m_nview.GetZDO() : null);
			if (obj == null)
			{
				return 0;
			}
			return obj.GetInt("mmo_level", 0);
		}
	}
	[HarmonyPatch(typeof(Player), "GetHoverName")]
	internal static class Player_GetHoverName_LevelPatch
	{
		private static void Postfix(Player __instance, ref string __result)
		{
			if (ModConfig.ShowPlayerLevels.Value)
			{
				int num = LevelDisplay.LevelOf(__instance);
				if (num > 0)
				{
					__result = $"{__result} <color=#F2C766>Lv {num}</color>";
				}
			}
		}
	}
	public class PlayerProgress
	{
		private const string CustomDataKey = "mmo.progression";

		private const int Format = 2;

		public int Level = 1;

		public long Xp;

		public readonly int[] Spent = new int[4];

		public float Satiety = -1f;

		private static readonly ConditionalWeakTable<Player, PlayerProgress> Cache = new ConditionalWeakTable<Player, PlayerProgress>();

		public static PlayerProgress Local
		{
			get
			{
				if (!((Object)(object)Player.m_localPlayer != (Object)null))
				{
					return null;
				}
				return Get(Player.m_localPlayer);
			}
		}

		public int TotalPoints => LevelCurve.PointsGrantedAt(Level);

		public int SpentPoints
		{
			get
			{
				int num = 0;
				for (int i = 0; i < Spent.Length; i++)
				{
					num += Spent[i];
				}
				return num;
			}
		}

		public int UnspentPoints => Math.Max(0, TotalPoints - SpentPoints);

		public long XpForNextLevel => LevelCurve.XpToNext(Level);

		public float LevelProgress
		{
			get
			{
				long xpForNextLevel = XpForNextLevel;
				if (xpForNextLevel > 0)
				{
					return Math.Min(1f, (float)Xp / (float)xpForNextLevel);
				}
				return 1f;
			}
		}

		public static PlayerProgress Get(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			if (Cache.TryGetValue(player, out var value))
			{
				return value;
			}
			PlayerProgress playerProgress = new PlayerProgress();
			playerProgress.LoadFrom(player);
			Cache.Add(player, playerProgress);
			return playerProgress;
		}

		public static void ClearCache(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				Cache.Remove(player);
			}
		}

		public bool TrySpend(Attr attr, Player owner)
		{
			if (UnspentPoints <= 0)
			{
				return false;
			}
			Spent[(int)attr]++;
			SaveTo(owner);
			return true;
		}

		public bool TryRefund(Attr attr, Player owner, out string reason)
		{
			reason = null;
			if (!ModConfig.RespecEnabled.Value)
			{
				reason = "Respec esta desativado neste servidor.";
				return false;
			}
			if (Spent[(int)attr] <= 0)
			{
				reason = "Nenhum ponto investido nesse atributo.";
				return false;
			}
			if (!CanRespec(owner, out reason))
			{
				return false;
			}
			Spent[(int)attr]--;
			SaveTo(owner);
			return true;
		}

		public bool RespecAll(Player owner, out string reason)
		{
			reason = null;
			if (!ModConfig.RespecEnabled.Value)
			{
				reason = "Respec esta desativado neste servidor.";
				return false;
			}
			if (SpentPoints == 0)
			{
				reason = "Nao ha pontos para redistribuir.";
				return false;
			}
			if (!CanRespec(owner, out reason))
			{
				return false;
			}
			Array.Clear(Spent, 0, Spent.Length);
			SaveTo(owner);
			return true;
		}

		public static bool CanRespec(Player player, out string reason)
		{
			reason = null;
			if ((Object)(object)player == (Object)null)
			{
				reason = "Jogador invalido.";
				return false;
			}
			if (ModConfig.RespecRequiresShelter.Value && !player.InShelter())
			{
				reason = "Voce precisa estar sob abrigo para redistribuir pontos.";
				return false;
			}
			int value = ModConfig.RespecMinComfort.Value;
			if (value > 0 && player.GetComfortLevel() < value)
			{
				reason = $"Conforto insuficiente ({player.GetComfortLevel()}/{value}). " + "Aproxime-se de uma fogueira e de moveis.";
				return false;
			}
			return true;
		}

		public int AddXp(long amount, Player owner)
		{
			if (amount <= 0)
			{
				return 0;
			}
			int value = ModConfig.MaxLevel.Value;
			if (Level >= value)
			{
				return 0;
			}
			Xp += amount;
			int num = 0;
			while (Level < value)
			{
				long num2 = LevelCurve.XpToNext(Level);
				if (num2 <= 0 || Xp < num2)
				{
					break;
				}
				Xp -= num2;
				Level++;
				num++;
			}
			if (Level >= value)
			{
				Xp = 0L;
			}
			SaveTo(owner);
			return num;
		}

		public int ApplyDeathPenalty(Player owner)
		{
			float num = ModConfig.DeathXpLossPercent.Value / 100f;
			if (num <= 0f)
			{
				return 0;
			}
			long num2 = (long)Math.Round((float)LevelCurve.XpToNext(Level) * num);
			if (num2 <= 0)
			{
				return 0;
			}
			Xp -= num2;
			int num3 = 0;
			if (ModConfig.DeathCanDelevel.Value)
			{
				while (Xp < 0 && Level > 1)
				{
					Level--;
					num3++;
					Xp += LevelCurve.XpToNext(Level);
				}
			}
			if (Xp < 0)
			{
				Xp = 0L;
			}
			if (num3 > 0)
			{
				ReclaimExcessPoints();
			}
			SaveTo(owner);
			return num3;
		}

		private void ReclaimExcessPoints()
		{
			int num = SpentPoints - TotalPoints;
			while (num > 0)
			{
				int num2 = 0;
				for (int i = 1; i < Spent.Length; i++)
				{
					if (Spent[i] > Spent[num2])
					{
						num2 = i;
					}
				}
				if (Spent[num2] > 0)
				{
					Spent[num2]--;
					num--;
					continue;
				}
				break;
			}
		}

		public int EffectivePoints(Attr attr, Player player)
		{
			int num = ItemBonuses.TotalEquipped((Humanoid)(object)player)[(int)attr];
			return Spent[(int)attr] + num;
		}

		public void ComputeStats(Player player, out float hp, out float stamina, out float eitr)
		{
			int num = Math.Max(0, Level - 1);
			float num2 = (((Object)(object)player != (Object)null) ? player.m_baseHP : 25f);
			float num3 = (((Object)(object)player != (Object)null) ? player.m_baseStamina : 50f);
			int[] array = ItemBonuses.TotalEquipped((Humanoid)(object)player);
			hp = num2 + (float)num * ModConfig.GrowthHealthPerLevel.Value + (float)(Spent[0] + array[0]) * ModConfig.HealthPerVitality.Value;
			stamina = num3 + (float)num * ModConfig.GrowthStaminaPerLevel.Value + (float)(Spent[1] + array[1]) * ModConfig.StaminaPerEndurance.Value;
			eitr = (float)num * ModConfig.GrowthEitrPerLevel.Value + (float)(Spent[2] + array[2]) * ModConfig.EitrPerSpirit.Value;
			if (hp < 1f)
			{
				hp = 1f;
			}
			if (stamina < 1f)
			{
				stamina = 1f;
			}
			if (eitr < 0f)
			{
				eitr = 0f;
			}
		}

		public float CarryBonusKg(Player player)
		{
			int num = Math.Max(0, Level - 1);
			int num2 = Spent[3] + ItemBonuses.TotalEquipped((Humanoid)(object)player)[3];
			return (float)num * ModConfig.GrowthCarryPerLevel.Value + (float)num2 * ModConfig.CarryPerConditioning.Value;
		}

		public void SaveTo(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				CultureInfo invariantCulture = CultureInfo.InvariantCulture;
				List<string> list = new List<string>
				{
					2.ToString(invariantCulture),
					Level.ToString(invariantCulture),
					Xp.ToString(invariantCulture)
				};
				for (int i = 0; i < 4; i++)
				{
					list.Add(Spent[i].ToString(invariantCulture));
				}
				list.Add(Satiety.ToString("R", invariantCulture));
				player.m_customData["mmo.progression"] = string.Join("|", list);
				LevelDisplay.Sync(player, Level);
			}
		}

		public void LoadFrom(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			if (!player.m_customData.TryGetValue("mmo.progression", out var value) || string.IsNullOrEmpty(value))
			{
				Reset();
				return;
			}
			try
			{
				CultureInfo invariantCulture = CultureInfo.InvariantCulture;
				string[] array = value.Split('|');
				int num = int.Parse(array[0], invariantCulture);
				Level = Math.Max(1, int.Parse(array[1], invariantCulture));
				Xp = Math.Max(0L, long.Parse(array[2], invariantCulture));
				int num2 = ((num >= 2) ? 4 : 3);
				Array.Clear(Spent, 0, Spent.Length);
				for (int i = 0; i < num2 && i < 4; i++)
				{
					Spent[i] = Math.Max(0, int.Parse(array[3 + i], invariantCulture));
				}
				int num3 = 3 + num2;
				Satiety = ((array.Length > num3) ? float.Parse(array[num3], NumberStyles.Float, invariantCulture) : (-1f));
				Clamp();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Nao foi possivel ler a progressao de " + player.GetPlayerName() + ", resetando. Dado bruto: '" + value + "'. Erro: " + ex.Message));
				Reset();
			}
		}

		private void Clamp()
		{
			if (Level > ModConfig.MaxLevel.Value)
			{
				Level = ModConfig.MaxLevel.Value;
			}
			if (SpentPoints > TotalPoints)
			{
				ReclaimExcessPoints();
			}
		}

		public void Reset()
		{
			Level = 1;
			Xp = 0L;
			Array.Clear(Spent, 0, Spent.Length);
			Satiety = -1f;
		}

		public override string ToString()
		{
			return $"lvl {Level} ({Xp}/{XpForNextLevel} xp) " + $"VIT {Spent[0]} RES {Spent[1]} ESP {Spent[2]} CON {Spent[3]} " + $"livres {UnspentPoints}";
		}
	}
	[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
	internal static class Player_GetTotalFoodValue_Patch
	{
		private static void Postfix(Player __instance, ref float hp, ref float stamina, ref float eitr)
		{
			PlayerProgress playerProgress = PlayerProgress.Get(__instance);
			if (playerProgress != null)
			{
				playerProgress.ComputeStats(__instance, out var hp2, out var stamina2, out var eitr2);
				if (ModConfig.FoodGivesNoStats.Value)
				{
					hp = hp2;
					stamina = stamina2;
					eitr = eitr2;
				}
				else
				{
					hp += hp2 - __instance.m_baseHP;
					stamina += stamina2 - __instance.m_baseStamina;
					eitr += eitr2;
				}
			}
		}
	}
	internal static class KillXpNetwork
	{
		private const string RpcName = "ValheimMMO_KillXp";

		private static readonly ConditionalWeakTable<Character, HashSet<ZDOID>> Contributors = new ConditionalWeakTable<Character, HashSet<ZDOID>>();

		internal static void Register()
		{
			if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<ZPackage>("ValheimMMO_KillXp", (Action<long, ZPackage>)OnKillXp);
				Plugin.Log.LogInfo((object)"RPC de XP registrado.");
			}
		}

		internal static void RecordHit(Character victim, HitData hit)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)victim == (Object)null) && hit != null && !victim.IsPlayer() && !((ZDOID)(ref hit.m_attacker)).IsNone() && hit.GetAttacker() is Player && !(hit.GetTotalDamage() <= 0f))
			{
				Contributors.GetOrCreateValue(victim).Add(hit.m_attacker);
			}
		}

		internal static void BroadcastKill(Character victim)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)victim == (Object)null || ZRoutedRpc.instance == null)
			{
				return;
			}
			HashSet<ZDOID> value;
			bool flag = Contributors.TryGetValue(victim, out value) && value.Count > 0;
			bool flag2 = !ModConfig.XpRequiresOwnDamage.Value;
			if (!flag && !flag2)
			{
				Contributors.Remove(victim);
				return;
			}
			long num = LevelCurve.XpForKill(victim);
			num = (long)((float)num * ModConfig.XpGlobalRate.Value);
			if (num <= 0)
			{
				Contributors.Remove(victim);
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(num);
			val.Write(victim.m_name ?? "");
			val.Write(((Component)victim).transform.position);
			val.Write(flag2);
			val.Write(flag ? value.Count : 0);
			if (flag)
			{
				foreach (ZDOID item in value)
				{
					val.Write(item);
				}
			}
			val.Write(((Object)((Component)victim).gameObject).name.Replace("(Clone)", ""));
			val.Write(DungeonBosses.IsDungeonBoss(victim, out var tier) ? tier.Id : 0);
			val.Write(WorldBoss.IsWorldBoss(victim, out var def) ? WorldBoss.GoldFor(def) : 0);
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ValheimMMO_KillXp", new object[1] { val });
			Contributors.Remove(victim);
		}

		private static void OnKillXp(long sender, ZPackage pkg)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || pkg == null)
			{
				return;
			}
			long num = pkg.ReadLong();
			string victimName = pkg.ReadString();
			Vector3 val = pkg.ReadVector3();
			bool flag = pkg.ReadBool();
			int num2 = pkg.ReadInt();
			ZDOID zDOID = ((Character)localPlayer).GetZDOID();
			bool flag2 = false;
			for (int i = 0; i < num2; i++)
			{
				if (pkg.ReadZDOID() == zDOID)
				{
					flag2 = true;
				}
			}
			string victimPrefab = pkg.ReadString();
			int num3 = pkg.ReadInt();
			int num4 = pkg.ReadInt();
			if (!flag2 && flag)
			{
				float num5 = Mathf.Max(1f, ModConfig.XpNearbyRadius.Value);
				flag2 = Vector3.Distance(((Component)localPlayer).transform.position, val) <= num5;
			}
			if (flag2)
			{
				Award(localPlayer, num, victimName);
				QuestSystem.OnKill(victimPrefab, num3);
				if (num4 > 0)
				{
					GiveGold(localPlayer, num4);
				}
				Karma.OnMonsterKill(Mathf.Pow(Mathf.Max(1f, (float)num / Mathf.Max(0.1f, ModConfig.XpKillFactor.Value * ModConfig.XpGlobalRate.Value)), 1.3333334f), num3 > 0 || num4 > 0);
			}
		}

		public static void GiveGoldPublic(Player player, int amount, string message)
		{
			GiveGold(player, amount, message);
		}

		private static void GiveGold(Player player, int amount, string message = null)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			ObjectDB instance = ObjectDB.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameObject itemPrefab = instance.GetItemPrefab("Coins");
				obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
			}
			ItemDrop val = (ItemDrop)obj;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			int num = Mathf.Max(1, val.m_itemData.m_shared.m_maxStackSize);
			int num2 = amount;
			while (num2 > 0)
			{
				int num3 = Mathf.Min(num, num2);
				if (inventory.AddItem(((Object)((Component)val).gameObject).name, num3, val.m_itemData.m_quality, val.m_itemData.m_variant, 0L, "", false) == null)
				{
					CharacterDrop.DropItems(new List<KeyValuePair<GameObject, int>>
					{
						new KeyValuePair<GameObject, int>(((Component)val).gameObject, 1)
					}, ((Component)player).transform.position + Vector3.up, 0.3f);
					break;
				}
				num2 -= num3;
			}
			((Character)player).Message((MessageType)2, message ?? $"Recompensa do chefe mundial: {amount} moedas", 0, (Sprite)null);
		}

		internal static void Award(Player player, long xp, string victimName)
		{
			PlayerProgress playerProgress = PlayerProgress.Get(player);
			if (playerProgress != null && xp > 0)
			{
				int level = playerProgress.Level;
				int num = playerProgress.AddXp(xp, player);
				string arg = (string.IsNullOrEmpty(victimName) ? "" : ("  (" + Localization.instance.Localize(victimName) + ")"));
				if (num > 0)
				{
					((Character)player).Message((MessageType)2, $"Level {playerProgress.Level}!  +{num * ModConfig.PointsPerLevel.Value} pontos", 0, (Sprite)null);
					Plugin.Log.LogInfo((object)$"Level up: {level} -> {playerProgress.Level} ({playerProgress})");
				}
				else if (ModConfig.ShowXpGainMessages.Value)
				{
					((Character)player).Message((MessageType)1, $"+{xp} XP{arg}", 0, (Sprite)null);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Game), "Start")]
	internal static class Game_Start_RegisterRpcPatch
	{
		private static void Postfix()
		{
			KillXpNetwork.Register();
		}
	}
	[HarmonyPatch(typeof(Character), "RPC_Damage")]
	internal static class Character_RPC_Damage_TrackPatch
	{
		private static void Prefix(Character __instance, HitData hit)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.m_nview == (Object)null) && __instance.m_nview.IsOwner())
			{
				KillXpNetwork.RecordHit(__instance, hit);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	internal static class Character_OnDeath_XpPatch
	{
		private static void Prefix(Character __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !__instance.IsPlayer() && !((Object)(object)__instance.m_nview == (Object)null) && __instance.m_nview.IsValid() && __instance.m_nview.IsOwner())
			{
				KillXpNetwork.BroadcastKill(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnDeath")]
	internal static class Player_OnDeath_PenaltyPatch
	{
		private static void Prefix(Player __instance)
		{
			if ((Object)(object)__instance == (Object)null || !((Character)__instance).m_nview.IsOwner())
			{
				return;
			}
			PlayerProgress playerProgress = PlayerProgress.Get(__instance);
			if (playerProgress != null)
			{
				long xp = playerProgress.Xp;
				int level = playerProgress.Level;
				if (playerProgress.ApplyDeathPenalty(__instance) > 0)
				{
					((Character)__instance).Message((MessageType)2, $"Voce regrediu para o level {playerProgress.Level}", 0, (Sprite)null);
					Plugin.Log.LogInfo((object)$"Morte: level {level} -> {playerProgress.Level}, pontos devolvidos automaticamente.");
				}
				else if (xp != playerProgress.Xp)
				{
					((Character)__instance).Message((MessageType)1, $"-{xp - playerProgress.Xp} XP", 0, (Sprite)null);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "Load")]
	internal static class Player_Load_Patch
	{
		private static void Postfix(Player __instance)
		{
			PlayerProgress.ClearCache(__instance);
			PlayerProgress playerProgress = PlayerProgress.Get(__instance);
			if (playerProgress != null)
			{
				LevelDisplay.Sync(__instance, playerProgress.Level);
			}
			Plugin.Log.LogInfo((object)$"Progressao carregada para {__instance.GetPlayerName()}: {playerProgress}");
		}
	}
}
namespace ValheimMMO.Network
{
	internal static class ConfigSync
	{
		private const string Rpc = "ValheimMMO_Config";

		private static readonly string[] LocalOnlySections = new string[2] { "10 - Interface", "18 - Rede" };

		private static Dictionary<ConfigDefinition, string> _snapshot;

		public static bool Synced { get; private set; }

		internal static void OnNewConnection(ZNetPeer peer)
		{
			if (peer?.m_rpc != null)
			{
				peer.m_rpc.Register<ZPackage>("ValheimMMO_Config", (Action<ZRpc, ZPackage>)OnConfig);
			}
		}

		private static bool IsLocalOnly(string section)
		{
			string[] localOnlySections = LocalOnlySections;
			foreach (string text in localOnlySections)
			{
				if (section == text)
				{
					return true;
				}
			}
			return false;
		}

		internal static void SendTo(ZRpc rpc)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			if (!ModConfig.ConfigSyncEnabled.Value || rpc == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
			List<KeyValuePair<ConfigDefinition, ConfigEntryBase>> list = new List<KeyValuePair<ConfigDefinition, ConfigEntryBase>>();
			foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item in config)
			{
				if (!IsLocalOnly(item.Key.Section))
				{
					list.Add(item);
				}
			}
			ZPackage val = new ZPackage();
			val.Write(list.Count);
			foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item2 in list)
			{
				val.Write(item2.Key.Section);
				val.Write(item2.Key.Key);
				val.Write(item2.Value.GetSerializedValue());
			}
			rpc.Invoke("ValheimMMO_Config", new object[1] { val });
			Plugin.Log.LogInfo((object)$"[Config] {list.Count} entradas enviadas ao cliente.");
		}

		private static void OnConfig(ZRpc rpc, ZPackage pkg)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				return;
			}
			ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
			if (_snapshot == null)
			{
				_snapshot = new Dictionary<ConfigDefinition, string>();
				foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item in config)
				{
					_snapshot[item.Key] = item.Value.GetSerializedValue();
				}
			}
			bool saveOnConfigSet = config.SaveOnConfigSet;
			config.SaveOnConfigSet = false;
			int num = 0;
			int num2 = 0;
			try
			{
				int num3 = pkg.ReadInt();
				for (int i = 0; i < num3; i++)
				{
					string text = pkg.ReadString();
					string text2 = pkg.ReadString();
					string serializedValue = pkg.ReadString();
					if (IsLocalOnly(text))
					{
						continue;
					}
					ConfigDefinition val = new ConfigDefinition(text, text2);
					if (config.ContainsKey(val))
					{
						ConfigEntryBase val2 = config[val];
						try
						{
							val2.SetSerializedValue(serializedValue);
							num++;
						}
						catch (Exception ex)
						{
							Plugin.Log.LogWarning((object)("[Config] " + text + "/" + text2 + ": " + ex.Message));
						}
					}
					else
					{
						num2++;
					}
				}
			}
			finally
			{
				config.SaveOnConfigSet = saveOnConfigSet;
			}
			Synced = true;
			MerchantItems.Invalidate();
			Plugin.Log.LogInfo((object)($"[Config] Sincronizada do servidor: {num} entradas aplicadas" + ((num2 > 0) ? $", {num2} desconhecidas" : ".")));
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)1, "Configuracao do servidor aplicada.", 0, (Sprite)null);
			}
		}

		internal static void Restore()
		{
			if (_snapshot == null)
			{
				return;
			}
			ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
			bool saveOnConfigSet = config.SaveOnConfigSet;
			config.SaveOnConfigSet = false;
			try
			{
				foreach (KeyValuePair<ConfigDefinition, string> item in _snapshot)
				{
					if (config.ContainsKey(item.Key))
					{
						ConfigEntryBase val = config[item.Key];
						try
						{
							val.SetSerializedValue(item.Value);
						}
						catch
						{
						}
					}
				}
			}
			finally
			{
				config.SaveOnConfigSet = saveOnConfigSet;
			}
			_snapshot = null;
			Synced = false;
			MerchantItems.Invalidate();
			Plugin.Log.LogInfo((object)"[Config] Config local restaurada.");
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	internal static class ZNet_OnNewConnection_ConfigPatch
	{
		private static void Postfix(ZNetPeer peer)
		{
			ConfigSync.OnNewConnection(peer);
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	internal static class ZNet_RPC_PeerInfo_ConfigPatch
	{
		private static void Postfix(ZRpc rpc)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && VersionCheck.Allow(rpc, out var _))
			{
				ConfigSync.SendTo(rpc);
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnDestroy")]
	internal static class ZNet_OnDestroy_ConfigPatch
	{
		private static void Prefix()
		{
			ConfigSync.Restore();
		}
	}
	internal static class VersionCheck
	{
		private const string Rpc = "ValheimMMO_Version";

		private static readonly Dictionary<ZRpc, string> Received = new Dictionary<ZRpc, string>();

		internal static void OnNewConnection(ZNetPeer peer)
		{
			if (peer?.m_rpc != null)
			{
				peer.m_rpc.Register<string>("ValheimMMO_Version", (Action<ZRpc, string>)OnVersion);
				if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
				{
					peer.m_rpc.Invoke("ValheimMMO_Version", new object[1] { "0.3.4" });
				}
			}
		}

		private static void OnVersion(ZRpc rpc, string version)
		{
			Received[rpc] = version;
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				rpc.Invoke("ValheimMMO_Version", new object[1] { "0.3.4" });
			}
			else if (version != "0.3.4")
			{
				Plugin.Log.LogWarning((object)("[Versao] Servidor tem ValheimMMO " + version + ", voce tem 0.3.4."));
			}
		}

		internal static bool Allow(ZRpc rpc, out string reason)
		{
			reason = null;
			if (!ModConfig.VersionCheckEnabled.Value)
			{
				return true;
			}
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return true;
			}
			if (!Received.TryGetValue(rpc, out var value))
			{
				reason = "cliente sem o mod ValheimMMO";
				return false;
			}
			if (ModConfig.VersionCheckExact.Value && value != "0.3.4")
			{
				reason = "versao do mod diferente (cliente " + value + ", servidor 0.3.4)";
				return false;
			}
			return true;
		}

		internal static void Forget(ZNetPeer peer)
		{
			if (peer?.m_rpc != null)
			{
				Received.Remove(peer.m_rpc);
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	internal static class ZNet_OnNewConnection_VersionPatch
	{
		private static void Postfix(ZNetPeer peer)
		{
			VersionCheck.OnNewConnection(peer);
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	internal static class ZNet_RPC_PeerInfo_VersionPatch
	{
		private static bool Prefix(ZRpc rpc)
		{
			if (VersionCheck.Allow(rpc, out var reason))
			{
				return true;
			}
			Plugin.Log.LogWarning((object)("[Versao] Conexao recusada: " + reason + "."));
			rpc.Invoke("Error", new object[1] { 3 });
			return false;
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	internal static class ZNet_Disconnect_VersionPatch
	{
		private static void Prefix(ZNetPeer peer)
		{
			VersionCheck.Forget(peer);
		}
	}
}
namespace ValheimMMO.Merchant
{
	internal static class MerchantItems
	{
		private sealed class TierCache
		{
			public ObjectDB Db;

			public int Bucket;

			public int Discount;

			public List<TradeItem> List;
		}

		internal struct GameObject_ItemDrop
		{
			public string Name;

			public ItemDrop Drop;
		}

		private static List<TradeItem> _list;

		private static ObjectDB _builtFor;

		private static int _builtBucket = -1;

		private static readonly Dictionary<int, TierCache> TierLists = new Dictionary<int, TierCache>();

		public static List<TradeItem> List
		{
			get
			{
				ObjectDB instance = ObjectDB.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return new List<TradeItem>();
				}
				int num = CurrentBucket();
				if (_list != null && (Object)(object)_builtFor == (Object)(object)instance && _builtBucket == num)
				{
					return _list;
				}
				_builtFor = instance;
				_builtBucket = num;
				_list = Build(instance, 0, 0f);
				Plugin.Log.LogInfo((object)$"[Mercador] Catalogo montado: {_list.Count} itens, dia {CurrentDay()}, inflacao x{InflationMultiplier():0.00}.");
				return _list;
			}
		}

		public static void Invalidate()
		{
			_list = null;
			_builtFor = null;
			_builtBucket = -1;
			TierLists.Clear();
			MerchantPricing.Invalidate();
			BiomeTiers.Invalidate();
		}

		public static int CurrentDay()
		{
			if (!((Object)(object)EnvMan.instance != (Object)null))
			{
				return 0;
			}
			return EnvMan.instance.GetDay();
		}

		public static int CurrentBucket()
		{
			int value = ModConfig.MerchantInflationEveryDays.Value;
			if (value <= 0)
			{
				return 0;
			}
			return CurrentDay() / value;
		}

		public static float InflationMultiplier()
		{
			int num = CurrentBucket();
			if (num <= 0)
			{
				return 1f;
			}
			float num2 = Mathf.Pow(1f + ModConfig.MerchantInflationPercent.Value / 100f, (float)num);
			float num3 = Mathf.Max(1f, ModConfig.MerchantInflationMaxMultiplier.Value);
			return Mathf.Min(num2, num3);
		}

		public static List<TradeItem> ListFor(int tier, float discount)
		{
			if (tier <= 0 && discount <= 0f)
			{
				return List;
			}
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return new List<TradeItem>();
			}
			int num = CurrentBucket();
			int num2 = Mathf.RoundToInt(discount * 100f);
			if (TierLists.TryGetValue(tier, out var value) && (Object)(object)value.Db == (Object)(object)instance && value.Bucket == num && value.Discount == num2)
			{
				return value.List;
			}
			List<TradeItem> list = Build(instance, tier, discount);
			TierLists[tier] = new TierCache
			{
				Db = instance,
				Bucket = num,
				Discount = num2,
				List = list
			};
			Plugin.Log.LogInfo((object)$"[Mercador] Catalogo tier {tier}: {list.Count} itens (desconto {num2}%).");
			return list;
		}

		public static bool IsSellable(GameObject_ItemDrop item, out string why)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Invalid comparison between Unknown and I4
			why = null;
			SharedData val = item.Drop?.m_itemData?.m_shared;
			if (val == null)
			{
				why = "sem ItemData";
				return false;
			}
			string name = item.Name;
			if (name == "Coins")
			{
				why = "moeda";
				return false;
			}
			if (ModConfig.MerchantExcludeQuestItems.Value && val.m_questItem)
			{
				why = "item de missao";
				return false;
			}
			if (val.m_icons == null || val.m_icons.Length == 0 || (Object)(object)val.m_icons[0] == (Object)null)
			{
				why = "sem icone";
				return false;
			}
			if ((int)val.m_itemType == 10)
			{
				why = "cosmetico";
				return false;
			}
			if (!EquipmentDrops.IsDroppable(name))
			{
				why = "sem ZNetView (interno)";
				return false;
			}
			if (string.IsNullOrEmpty(val.m_name))
			{
				why = "sem nome";
				return false;
			}
			string[] array = (ModConfig.MerchantExcludePattern.Value ?? "").Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length != 0 && ((text[0] == '=') ? string.Equals(name, text.Substring(1), StringComparison.OrdinalIgnoreCase) : (name.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0)))
				{
					why = "padrao '" + text + "'";
					return false;
				}
			}
			return true;
		}

		public static int StackFor(SharedData shared)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			if (shared.m_name == "Mapa do Explorador")
			{
				return 1;
			}
			if (shared.m_name == "Pedra de Retorno")
			{
				return 1;
			}
			int val = Math.Max(1, shared.m_maxStackSize);
			ItemType itemType = shared.m_itemType;
			if ((int)itemType <= 2)
			{
				if ((int)itemType == 1)
				{
					goto IL_0054;
				}
				if ((int)itemType == 2)
				{
					return Math.Min(val, Math.Max(1, ModConfig.MerchantConsumableStack.Value));
				}
			}
			else if ((int)itemType == 9 || (int)itemType == 23)
			{
				goto IL_0054;
			}
			return 1;
			IL_0054:
			return Math.Min(val, Math.Max(1, ModConfig.MerchantMaterialStack.Value));
		}

		private static List<TradeItem> Build(ObjectDB db, int tier, float discount)
		{
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			List<TradeItem> list = new List<TradeItem>();
			float num = InflationMultiplier();
			bool flag = tier > 0 && ModConfig.CitiesEnabled.Value;
			foreach (GameObject item2 in db.m_items)
			{
				if ((Object)(object)item2 == (Object)null)
				{
					continue;
				}
				ItemDrop component = item2.GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				GameObject_ItemDrop item = new GameObject_ItemDrop
				{
					Name = ((Object)item2).name,
					Drop = component
				};
				bool flag2 = CustomItems.IsCustom(((Object)item2).name) || MapItem.IsMap(((Object)item2).name);
				if (!IsSellable(item, out var why))
				{
					if (flag2)
					{
						Plugin.Log.LogWarning((object)("[Mercador] item do mod '" + ((Object)item2).name + "' fora do catalogo: " + why));
					}
					continue;
				}
				float num2 = 1f;
				if (flag)
				{
					int num3 = BiomeTiers.TierOf(((Object)item2).name);
					if (num3 != 0)
					{
						if (num3 > tier || (num3 < tier && !ModConfig.CitySellsLowerTiers.Value))
						{
							continue;
						}
						if (num3 < tier)
						{
							num2 = 1f + ModConfig.ImportMarkupPerTier.Value * (float)(tier - num3);
						}
					}
				}
				int num4 = StackFor(component.m_itemData.m_shared);
				long num5 = (long)Math.Ceiling((float)MerchantPricing.PriceOf(((Object)item2).name) * num * num2 * (1f - Mathf.Clamp01(discount))) * num4;
				if (num5 > int.MaxValue)
				{
					num5 = 2147483647L;
				}
				list.Add(new TradeItem
				{
					m_prefab = component,
					m_stack = num4,
					m_price = (int)Math.Max(1L, num5),
					m_requiredGlobalKey = ""
				});
			}
			list.Sort(delegate(TradeItem a, TradeItem b)
			{
				int num6 = GroupOf(a);
				int num7 = GroupOf(b);
				if (num6 != num7)
				{
					return num6.CompareTo(num7);
				}
				int num8 = a.m_price / Math.Max(1, a.m_stack);
				int num9 = b.m_price / Math.Max(1, b.m_stack);
				return (num8 != num9) ? num8.CompareTo(num9) : string.Compare(((Object)((Component)a.m_prefab).gameObject).name, ((Object)((Component)b.m_prefab).gameObject).name, StringComparison.OrdinalIgnoreCase);
			});
			return list;
		}

		private static int GroupOf(TradeItem t)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			string name = ((Object)((Component)t.m_prefab).gameObject).name;
			if (CustomItems.IsCustom(name) || MapItem.IsMap(name))
			{
				return -1;
			}
			return Group(t.m_prefab.m_itemData.m_shared.m_itemType);
		}

		private static int Group(ItemType t)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected I4, but got Unknown
			return (t - 1) switch
			{
				2 => 0, 
				13 => 0, 
				21 => 0, 
				3 => 1, 
				4 => 2, 
				5 => 3, 
				6 => 3, 
				10 => 3, 
				16 => 3, 
				17 => 4, 
				23 => 4, 
				18 => 5, 
				14 => 5, 
				8 => 6, 
				22 => 6, 
				1 => 7, 
				0 => 8, 
				12 => 9, 
				_ => 10, 
			};
		}
	}
	internal static class MerchantSpawner
	{
		public const string GlobalKey = "mmo_merchant_spawned";

		public const string ZdoTag = "mmo_merchant";

		private static float _timer;

		public static bool IsMerchant(Trader trader)
		{
			if ((Object)(object)trader == (Object)null)
			{
				return false;
			}
			ZNetView component = ((Component)trader).GetComponent<ZNetView>();
			ZDO val = (((Object)(object)component != (Object)null && component.IsValid()) ? component.GetZDO() : null);
			if (val == null)
			{
				return false;
			}
			if (!val.GetBool("mmo_merchant", false))
			{
				return CitySystem.IsCityMerchant(trader);
			}
			return true;
		}

		public static int TierOf(Trader trader)
		{
			if ((Object)(object)trader == (Object)null)
			{
				return -1;
			}
			if (CitySystem.IsCityMerchant(trader))
			{
				return CitySystem.CityTierOf((Component)(object)trader);
			}
			ZNetView component = ((Component)trader).GetComponent<ZNetView>();
			ZDO val = (((Object)(object)component != (Object)null && component.IsValid()) ? component.GetZDO() : null);
			if (val != null && val.GetBool("mmo_merchant", false))
			{
				if (!ModConfig.CitiesEnabled.Value)
				{
					return 0;
				}
				return ModConfig.SpawnMerchantTier.Value;
			}
			return -1;
		}

		public static void Tick(Player player, float dt)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: 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_00ba: 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)
			if (!ModConfig.MerchantEnabled.Value || (Object)(object)player == (Object)null)
			{
				return;
			}
			_timer += dt;
			if (_timer < 5f)
			{
				return;
			}
			_timer = 0f;
			Vector3 val = default(Vector3);
			if ((Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null || ZoneSystem.instance.GetGlobalKey("mmo_merchant_spawned") || !ZoneSystem.instance.GetLocationIcon("StartTemple", ref val) || Vector3.Distance(((Component)player).transform.position, val) > 40f)
			{
				return;
			}
			Trader[] array = Object.FindObjectsByType<Trader>((FindObjectsSortMode)0);
			foreach (Trader val2 in array)
			{
				if (IsMerchant(val2) && Vector3.Distance(((Component)val2).transform.position, val) < 60f)
				{
					ZoneSystem.instance.SetGlobalKey("mmo_merchant_spawned");
					return;
				}
			}
			Vector3 val3 = val + new Vector3(ModConfig.MerchantOffsetX.Value, 0f, ModConfig.MerchantOffsetZ.Value);
			if (Spawn(val3, val, out var error))
			{
				ZoneSystem.instance.SetGlobalKey("mmo_merchant_spawned");
				((Character)player).Message((MessageType)1, "Um mercador se instalou perto das pedras iniciais.", 0, (Sprite)null);
				Plugin.Log.LogInfo((object)$"[Mercador] Spawnado em {val3}.");
			}
			else
			{
				Plugin.Log.LogWarning((object)("[Mercador] Falha ao spawnar: " + error));
				ZoneSystem.instance.SetGlobalKey("mmo_merchant_spawned");
			}
		}

		public static bool Spawn(Vector3 pos, Vector3 lookAt, out string error)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00ac: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			error = null;
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(ModConfig.MerchantPrefab.Value) : null);
			if ((Object)(object)val == (Object)null)
			{
				error = "prefab '" + ModConfig.MerchantPrefab.Value + "' nao encontrado no ZNetScene";
				return false;
			}
			if ((Object)(object)val.GetComponent<Trader>() == (Object)null)
			{
				error = "prefab nao tem componente Trader";
				return false;
			}
			if ((Object)(object)val.GetComponent<ZNetView>() == (Object)null)
			{
				error = "prefab nao tem ZNetView";
				return false;
			}
			float y = default(float);
			if (ZoneSystem.instance.GetGroundHeight(pos, ref y))
			{
				pos.y = y;
			}
			Vector3 val2 = lookAt - pos;
			val2.y = 0f;
			Quaternion val3 = ((((Vector3)(ref val2)).sqrMagnitude > 0.01f) ? Quaternion.LookRotation(((Vector3)(ref val2)).normalized) : Quaternion.identity);
			GameObject val4 = Object.Instantiate<GameObject>(val, pos, val3);
			ZNetView component = val4.GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				error = "ZNetView invalido apos instanciar";
				return false;
			}
			component.GetZDO().Set("mmo_merchant", true);
			component.GetZDO().Persistent = true;
			Trader component2 = val4.GetComponent<Trader>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_name = ModConfig.MerchantName.Value;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateStats", new Type[] { typeof(float) })]
	internal static class Player_UpdateStats_MerchantPatch
	{
		private static void Postfix(Player __instance, float dt)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				MerchantSpawner.Tick(__instance, dt);
			}
		}
	}
	[HarmonyPatch(typeof(Trader), "Start")]
	internal static class Trader_Start_NamePatch
	{
		private static void Postfix(Trader __instance)
		{
			if (MerchantSpawner.IsMerchant(__instance))
			{
				__instance.m_name = ModConfig.MerchantName.Value;
			}
		}
	}
	[HarmonyPatch(typeof(Trader), "GetAvailableItems")]
	internal static class Trader_GetAvailableItems_Patch
	{
		internal static bool InStore;

		private static void Postfix(Trader __instance, ref List<TradeItem> __result)
		{
			if (ModConfig.MerchantEnabled.Value && (InStore || StoreGui.IsVisible()))
			{
				int num = MerchantSpawner.TierOf(__instance);
				if (num >= 0)
				{
					__result = MerchantItems.ListFor(num, 0f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(StoreGui), "FillList")]
	internal static class StoreGui_FillList_Patch
	{
		private static void Prefix()
		{
			Trader_GetAvailableItems_Patch.InStore = true;
		}

		private static void Postfix()
		{
			Trader_GetAvailableItems_Patch.InStore = false;
		}
	}
	[HarmonyPatch(typeof(StoreGui), "Show")]
	internal static class StoreGui_Show_InflationPatch
	{
		private static void Postfix(Trader trader)
		{
			if (!ModConfig.MerchantEnabled.Value || !MerchantSpawner.IsMerchant(trader))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				float num = MerchantItems.InflationMultiplier();
				int value = ModConfig.MerchantInflationEveryDays.Value;
				if (num > 1f)
				{
					((Character)localPlayer).Message((MessageType)1, $"Dia {MerchantItems.CurrentDay()}: precos {(num - 1f) * 100f:+0}%  (sobem {ModConfig.MerchantInflationPercent.Value:0}% a cada {value} dias)", 0, (Sprite)null);
				}
				else if (value > 0)
				{
					((Character)localPlayer).Message((MessageType)1, $"Dia {MerchantItems.CurrentDay()}: precos base  (sobem {ModConfig.MerchantInflationPercent.Value:0}% a cada {value} dias)", 0, (Sprite)null);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	internal static class ObjectDB_Awake_MerchantPatch
	{
		private static void Postfix()
		{
			MerchantItems.Invalidate();
		}
	}
	internal static class MerchantPricing
	{
		private enum Source
		{
			Override,
			Base,
			Recipe,
			Conversion,
			CreatureDrop,
			Gathered,
			Mined,
			VanillaValue,
			Unknown,
			Cycle
		}

		private sealed class Conversion
		{
			public string From;

			public float Markup;

			public float Fee;

			public float Divide = 1f;

			public string Station;
		}

		private static readonly Dictionary<string, int> Cache = new Dictionary<string, int>(StringComparer.Ordinal);

		private static readonly Dictionary<string, Source> Sources = new Dictionary<string, Source>(StringComparer.Ordinal);

		private static readonly Dictionary<string, string> Explain = new Dictionary<string, string>(StringComparer.Ordinal);

		private static readonly HashSet<string> Visiting = new HashSet<string>(StringComparer.Ordinal);

		private static Dictionary<string, List<Recipe>> _recipes;

		private static Dictionary<string, List<Conversion>> _conversions;

		private static Dictionary<string, float> _creatureHp;

		private static HashSet<string> _gathered;

		private static HashSet<string> _mined;

		private static Dictionary<string, int> _basePrices;

		private static Dictionary<string, int> _overrides;

		private static Dictionary<string, int> _traderPrices;

		private static ObjectDB _builtFor;

		public static void Invalidate()
		{
			Cache.Clear();
			Sources.Clear();
			Explain.Clear();
			Visiting.Clear();
			_recipes = null;
			_conversions = null;
			_creatureHp = null;
			_gathered = null;
			_mined = null;
			_basePrices = null;
			_overrides = null;
			_builtFor = null;
		}

		private static void EnsureBuilt()
		{
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null || (_recipes != null && (Object)(object)_builtFor == (Object)(object)instance))
			{
				return;
			}
			Invalidate();
			_builtFor = instance;
			_basePrices = ParseTable(ModConfig.MerchantBasePrices.Value);
			_overrides = ParseTable(ModConfig.MerchantPriceOverrides.Value);
			_recipes = new Dictionary<string, List<Recipe>>(StringComparer.Ordinal);
			foreach (Recipe recipe in instance.m_recipes)
			{
				if (!((Object)(object)recipe == (Object)null) && recipe.m_enabled && !((Object)(object)recipe.m_item == (Object)null))
				{
					string name = ((Object)((Component)recipe.m_item).gameObject).name;
					if (!_recipes.TryGetValue(name, out var value))
					{
						value = (_recipes[name] = new List<Recipe>());
					}
					value.Add(recipe);
				}
			}
			_conversions = new Dictionary<string, List<Conversion>>(StringComparer.Ordinal);
			_creatureHp = new Dictionary<string, float>(StringComparer.Ordinal);
			_gathered = new HashSet<string>(StringComparer.Ordinal);
			_mined = new HashSet<string>(StringComparer.Ordinal);
			_traderPrices = new Dictionary<string, int>(StringComparer.Ordinal);
			if (!((Object)(object)ZNetScene.instance != (Object)null))
			{
				return;
			}
			foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
			{
				if ((Object)(object)prefab == (Object)null)
				{
					continue;
				}
				Trader component = prefab.GetComponent<Trader>();
				if ((Object)(object)component != (Object)null && component.m_items != null)
				{
					foreach (TradeItem item in component.m_items)
					{
						if (!((Object)(object)item?.m_prefab == (Object)null) && item.m_price > 0)
						{
							int num = Mathf.Max(1, Mathf.CeilToInt((float)item.m_price / (float)Mathf.Max(1, item.m_stack)));
							string name2 = ((Object)((Component)item.m_prefab).gameObject).name;
							if (!_traderPrices.TryGetValue(name2, out var value2) || num < value2)
							{
								_traderPrices[name2] = num;
							}
						}
					}
				}
				Smelter component2 = prefab.GetComponent<Smelter>();
				if ((Object)(object)component2 != (Object)null && component2.m_conversion != null)
				{
					float num2 = 0f;
					if ((Object)(object)component2.m_fuelItem != (Object)null)
					{
						num2 = component2.m_fuelPerProduct * Mathf.Max(1, PriceOf(((Object)((Component)component2.m_fuelItem).gameObject).name));
					}
					foreach (ItemConversion item2 in component2.m_conversion)
					{
						AddConversion(item2?.m_to, item2?.m_from, ModConfig.MerchantConversionMarkup.Value, num2 + 2f, 1f, component2.m_name);
					}
				}
				CookingStation component3 = prefab.GetComponent<CookingStation>();
				if ((Object)(object)component3 != (Object)null && component3.m_conversion != null)
				{
					foreach (ItemConversion item3 in component3.m_conversion)
					{
						AddConversion(item3?.m_to, item3?.m_from, 1.2f, 1f, 1f, "cooking");
					}
				}
				Fermenter component4 = prefab.GetComponent<Fermenter>();
				if ((Object)(object)component4 != (Object)null && component4.m_conversion != null)
				{
					foreach (ItemConversion item4 in component4.m_conversion)
					{
						AddConversion(item4?.m_to, item4?.m_from, 1.2f, 2f, Mathf.Max(1, item4?.m_producedItems ?? 1), "fermenter");
					}
				}
				CharacterDrop component5 = prefab.GetComponent<CharacterDrop>();
				Character component6 = prefab.GetComponent<Character>();
				if ((Object)(object)component5 != (Object)null && (Object)(object)component6 != (Object)null && component5.m_drops != null)
				{
					float num3 = Mathf.Max(1f, component6.m_health);
					foreach (Drop drop in component5.m_drops)
					{
						if (!((Object)(object)drop?.m_prefab == (Object)null))
						{
							string name3 = ((Object)drop.m_prefab).name;
							if (!_creatureHp.TryGetValue(name3, out var value3) || num3 < value3)
							{
								_creatureHp[name3] = num3;
							}
						}
					}
				}
				Pickable component7 = prefab.GetComponent<Pickable>();
				if ((Object)(object)component7 != (Object)null)
				{
					if ((Object)(object)component7.m_itemPrefab != (Object)null)
					{
						_gathered.Add(((Object)component7.m_itemPrefab).name);
					}
					AddTable(component7.m_extraDrops, _gathered);
				}
				AddTable(prefab.GetComponent<DropOnDestroyed>()?.m_dropWhenDestroyed, _gathered);
				AddTable(prefab.GetComponent<TreeBase>()?.m_dropWhenDestroyed, _gathered);
				AddTable(prefab.GetComponent<TreeLog>()?.m_dropWhenDestroyed, _gathered);
				AddTable(prefab.GetComponent<MineRock5>()?.m_dropItems, _mined);
				AddTable(prefab.GetComponent<MineRock>()?.m_dropItems, _mined);
			}
		}

		private static void AddConversion(ItemDrop to, ItemDrop from, float markup, float fee, float divide, string station)
		{
			if (!((Object)(object)to == (Object)null) && !((Object)(object)from == (Object)null))
			{
				string name = ((Object)((Component)to).gameObject).name;
				if (!_conversions.TryGetValue(name, out var value))
				{
					value = (_conversions[name] = new List<Conversion>());
				}
				value.Add(new Conversion
				{
					From = ((Object)((Component)from).gameObject).name,
					Markup = markup,
					Fee = fee,
					Divide = divide,
					Station = station
				});
			}
		}

		private static void AddTable(DropTable table, HashSet<string> into)
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (table?.m_drops == null)
			{
				return;
			}
			foreach (DropData drop in table.m_drops)
			{
				if ((Object)(object)drop.m_item != (Object)null)
				{
					into.Add(((Object)drop.m_item).name);
				}
			}
		}

		private static Dictionary<string, int> ParseTable(string raw)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			if (string.IsNullOrEmpty(raw))
			{
				return dictionary;
			}
			string[] array = raw.Split(new char[3] { ',', ';', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num > 0)
				{
					string text2 = text.Substring(0, num).Trim();
					if (int.TryParse(text.Substring(num + 1).Trim(), out var result) && text2.Length > 0)
					{
						dictionary[text2] = result;
					}
				}
			}
			return dictionary;
		}

		public static int PriceOf(string prefabName)
		{
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Invalid comparison between Unknown and I4
			EnsureBuilt();
			if (string.IsNullOrEmpty(prefabName))
			{
				return 1;
			}
			if (Cache.TryGetValue(prefabName, out var value))
			{
				return value;
			}
			if (_overrides != null && _overrides.TryGetValue(prefabName, out var value2))
			{
				return Store(prefabName, value2, Source.Override, "override na config");
			}
			if (MapItem.IsMap(prefabName))
			{
				return Store(prefabName, Mathf.Max(1, ModConfig.MapPrice.Value), Source.Override, "item do mod (MapPrice)");
			}
			if (CustomItems.IsCustom(prefabName))
			{
				return Store(prefabName, Mathf.Max(1, CustomItems.PriceOf(prefabName)), Source.Override, "item do mod");
			}
			if (Visiting.Contains(prefabName))
			{
				Sources[prefabName] = Source.Cycle;
				return Mathf.Max(1, Mathf.RoundToInt(ModConfig.MerchantUnknownBase.Value));
			}
			Visiting.Add(prefabName);
			try
			{
				if (_basePrices != null && _basePrices.TryGetValue(prefabName, out var value3))
				{
					return Store(prefabName, Scaled(value3), Source.Base, "materia-prima (BasePrices)");
				}
				if (_traderPrices != null && _traderPrices.TryGetValue(prefabName, out var value4))
				{
					return Store(prefabName, Scaled(value4), Source.VanillaValue, $"preco de vendedor vanilla {value4}");
				}
				float num = float.MaxValue;
				Source source = Source.Unknown;
				string why = "";
				if (_recipes != null && _recipes.TryGetValue(prefabName, out var value5))
				{
					foreach (Recipe item in value5)
					{
						float num2 = 0f;
						List<string> list = new List<string>();
						Requirement[] resources = item.m_resources;
						foreach (Requirement val in resources)
						{
							if (!((Object)(object)val?.m_resItem == (Object)null) && val.m_amount > 0)
							{
								string name = ((Object)((Component)val.m_resItem).gameObject).name;
								int num3 = PriceOf(name);
								num2 += (float)(num3 * val.m_amount);
								list.Add($"{val.m_amount}x {name}@{num3}");
							}
						}
						int num4 = Mathf.Max(1, item.m_amount);
						float num5 = ModConfig.MerchantCraftBaseFee.Value + (float)Mathf.Max(0, item.m_minStationLevel - 1) * ModConfig.MerchantStationLevelFee.Value;
						float num6 = (num2 * ModConfig.MerchantCraftMarkup.Value + num5) / (float)num4;
						if (num6 < num)
						{
							num = num6;
							source = Source.Recipe;
							why = string.Format("receita [{0}] /{1}", string.Join(", ", list), num4) + (((Object)(object)item.m_craftingStation != (Object)null) ? $" @ {item.m_craftingStation.m_name} nv{item.m_minStationLevel}" : "");
						}
					}
				}
				if (_conversions != null && _conversions.TryGetValue(prefabName, out var value6))
				{
					foreach (Conversion item2 in value6)
					{
						int num7 = PriceOf(item2.From);
						float num8 = (float)num7 / item2.Divide * item2.Markup + item2.Fee;
						if (num8 < num)
						{
							num = num8;
							source = Source.Conversion;
							why = $"{item2.Station}: {item2.From}@{num7}" + ((item2.Divide > 1f) ? $" /{item2.Divide:0}" : "");
						}
					}
				}
				if (source != Source.Unknown)
				{
					return Store(prefabName, Mathf.Max(1, Mathf.CeilToInt(num)), source, why);
				}
				ObjectDB instance = ObjectDB.instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					GameObject itemPrefab = instance.GetItemPrefab(prefabName);
					obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				}
				SharedData val2 = ((ItemDrop)(obj?)).m_itemData?.m_shared;
				if (val2 != null && val2.m_value > 0)
				{
					return Store(prefabName, Scaled(val2.m_value * 2), Source.VanillaValue, $"valor vanilla {val2.m_value} x2");
				}
				if (_creatureHp != null && _creatureHp.TryGetValue(prefabName, out var value7))
				{
					float num9 = Mathf.Pow(value7, ModConfig.MerchantCreatureDropExponent.Value);
					if (val2 != null && (int)val2.m_itemType == 13)
					{
						num9 *= ModConfig.MerchantTrophyMultiplier.Value;
					}
					return Store(prefabName, Scaled(Mathf.CeilToInt(num9)), Source.CreatureDrop, $"drop de criatura com {value7:0} de vida");
				}
				if (_mined != null && _mined.Contains(prefabName))
				{
					return Store(prefabName, Scaled(Mathf.RoundToInt(ModConfig.MerchantMinedBase.Value)), Source.Mined, "minerado");
				}
				if (_gathered != null && _gathered.Contains(prefabName))
				{
					return Store(prefabName, Scaled(Mathf.RoundToInt(ModConfig.MerchantGatheredBase.Value)), Source.Gathered, "coletado");
				}
				return Store(prefabName, Scaled(Mathf.RoundToInt(ModConfig.MerchantUnknownBase.Value)), Source.Unknown, "SEM ORIGEM CONHECIDA (revisar)");
			}
			finally
			{
				Visiting.Remove(prefabName);
			}
		}

		private static int Scaled(int v)
		{
			return Mathf.Max(1, Mathf.RoundToInt((float)v * ModConfig.MerchantPriceMultiplier.Value));
		}

		private static int Store(string name, int price, Source source, string why)
		{
			if (source == Source.Recipe || source == Source.Conversion)
			{
				price = Mathf.Max(1, price);
			}
			Cache[name] = price;
			Sources[name] = source;
			Explain[name] = why;
			return price;
		}

		public static string SourceOf(string name)
		{
			if (!Sources.TryGetValue(name, out var value))
			{
				return "?";
			}
			return value.ToString();
		}

		public static string WhyOf(string name)
		{
			if (!Explain.TryGetValue(name, out var value))
			{
				return "";
			}
			return value;
		}
	}
	public class MerchantSellUI : MonoBehaviour
	{
		private enum Tab
		{
			Sell,
			Repair,
			Quests,
			Bank
		}

		private const float PanelWidth = 540f;

		private Tab _tab;

		private Vector2 _scroll;

		private static bool Active
		{
			get
			{
				if (ModConfig.MerchantEnabled.Value && (Object)(object)StoreGui.instance != (Object)null && StoreGui.IsVisible() && MerchantSpawner.IsMerchant(StoreGui.instance.m_trader))
				{
					return (Object)(object)Player.m_localPlayer != (Object)null;
				}
				return false;
			}
		}

		private static int CurrentTier
		{
			get
			{
				if (!((Object)(object)StoreGui.instance != (Object)null))
				{
					return -1;
				}
				return MerchantSpawner.TierOf(StoreGui.instance.m_trader);
			}
		}

		public static int UnitBuyPrice(ItemData item)
		{
			if (item?.m_shared == null)
			{
				return 0;
			}
			if (item.m_shared.m_value > 0)
			{
				return item.m_shared.m_value;
			}
			string prefabName = (((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : item.m_shared.m_name);
			int num = MerchantPricing.PriceOf(prefabName);
			float value = ModConfig.MerchantBuyRatio.Value;
			int currentTier = CurrentTier;
			if (ModConfig.CitiesEnabled.Value && currentTier > 0 && BiomeTiers.TierOf(prefabName) == currentTier)
			{
				value = ModConfig.LocalBuyRatio.Value;
			}
			return Mathf.Max(1, Mathf.FloorToInt((float)num * Mathf.Clamp01(value)));
		}

		private static int BasePriceOf(ItemData item)
		{
			if (!((Object)(object)item?.m_dropPrefab != (Object)null))
			{
				return 0;
			}
			return MerchantPricing.PriceOf(((Object)item.m_dropPrefab).name);
		}

		public static int RepairCost(ItemData item)
		{
			float maxDurability = item.GetMaxDurability();
			if (maxDurability <= 0f)
			{
				return 0;
			}
			float num = Mathf.Clamp01(1f - item.m_durability / maxDurability);
			if (num <= 0.001f)
			{
				return 0;
			}
			return Mathf.Max(1, Mathf.CeilToInt((float)BasePriceOf(item) * num * ModConfig.RepairCostRatio.Value));
		}

		public static int UpgradeCost(ItemData item)
		{
			return Mathf.Max(1, Mathf.CeilToInt((float)(BasePriceOf(item) * item.m_quality) * ModConfig.UpgradeCostFactor.Value));
		}

		public static int MaxUpgradeQuality(ItemData item)
		{
			return item.m_shared.m_maxQuality + Mathf.Max(0, ModConfig.ExtraQualityLevels.Value);
		}

		private static bool CanSell(ItemData item)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			if (item?.m_shared == null || (Object)(object)item.m_dropPrefab == (Object)null)
			{
				return false;
			}
			if (item.m_equipped)
			{
				return false;
			}
			if (item.m_shared.m_questItem)
			{
				return false;
			}
			if (((Object)item.m_dropPrefab).name == "Coins")
			{
				return false;
			}
			if (item.m_shared.m_value > 0)
			{
				return true;
			}
			if (!ModConfig.MerchantBuysMaterials.Value && (int)item.m_shared.m_itemType == 1)
			{
				return false;
			}
			string[] array = (ModConfig.MerchantNoBuyPattern.Value ?? "").Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length != 0 && ((text[0] == '=') ? string.Equals(((Object)item.m_dropPrefab).name, text.Substring(1), StringComparison.OrdinalIgnoreCase) : (((Object)item.m_dropPrefab).name.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0)))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsEquipment(ItemData item)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			if (item?.m_shared != null && (Object)(object)item.m_dropPrefab != (Object)null && item.m_shared.m_maxQuality > 1 && EquipmentDrops.ChanceFor(item.m_shared.m_itemType) > 0f && (int)item.m_shared.m_itemType != 9)
			{
				return (int)item.m_shared.m_itemType != 23;
			}
			return false;
		}

		private static int Coins(Player p)
		{
			return ((Humanoid)p).GetInventory().CountItems(StoreGui.instance.m_coinPrefab.m_itemData.m_shared.m_name, -1, true);
		}

		private static bool Pay(Player p, int amount)
		{
			if (amount <= 0)
			{
				return true;
			}
			Inventory inventory = ((Humanoid)p).GetInventory();
			string name = StoreGui.instance.m_coinPrefab.m_itemData.m_shared.m_name;
			if (inventory.CountItems(name, -1, true) < amount)
			{
				((Character)p).Message((MessageType)2, "Moedas insuficientes.", 0, (Sprite)null);
				return false;
			}
			inventory.RemoveItem(name, amount, -1, true);
			return true;
		}

		private void OnGUI()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				GUISkin skin = GUI.skin;
				Matrix4x4 matrix = GUI.matrix;
				GUI.skin = MmoUI.Skin;
				float num = Mathf.Clamp((float)Screen.height / 1080f, 0.75f, 2.5f);
				GUI.matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(num, num, 1f));
				float num2 = (float)Screen.width / num;
				float num3 = (float)Screen.height / num;
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(num2 - 540f - 24f, 90f, 540f, Mathf.Min(780f, num3 - 180f));
				GUILayout.Window(((Object)this).GetInstanceID(), val, new WindowFunction(Draw), "MERCADOR", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(540f),
					GUILayout.Height(((Rect)(ref val)).height)
				});
				GUI.matrix = matrix;
				GUI.skin = skin;
			}
		}

		private void Draw(int id)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (((localPlayer != null) ? ((Humanoid)localPlayer).GetInventory() : null) != null && !((Object)(object)StoreGui.instance == (Object)null))
			{
				string arg = ColorUtility.ToHtmlStringRGB(MmoUI.GoldC);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				TabButton("VENDER", Tab.Sell);
				TabButton("REPARAR / MELHORAR", Tab.Repair);
				if (ModConfig.QuestsEnabled.Value && !ModConfig.CitiesEnabled.Value)
				{
					TabButton("MISSOES", Tab.Quests);
				}
				if (ModConfig.BankEnabled.Value)
				{
					TabButton("COFRE", Tab.Bank);
				}
				GUILayout.FlexibleSpace();
				GUILayout.Label($"<b><color=#{arg}>{Coins(localPlayer)}</color></b> moedas", Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
				GUILayout.Space(6f);
				switch (_tab)
				{
				case Tab.Sell:
					DrawSell(localPlayer);
					break;
				case Tab.Repair:
					DrawRepair(localPlayer);
					break;
				case Tab.Quests:
					DrawQuests(localPlayer);
					break;
				case Tab.Bank:
					DrawBank(localPlayer);
					break;
				}
			}
		}

		private void DrawBank(Player player)
		{
			//IL_0000: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			string text = ColorUtility.ToHtmlStringRGB(MmoUI.MutedC);
			Inventory val = PlayerBank.Get(player);
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (val == null || inventory == null)
			{
				return;
			}
			GUILayout.Label($"<size=12><color=#{text}>Cofre pessoal: {val.NrOfItems()}/{val.GetWidth() * val.GetHeight()} slots. O que esta aqui nao pesa e fica salvo no seu personagem.</color></size>", Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			_scroll = GUILayout.BeginScrollView(_scroll, Array.Empty<GUILayoutOption>());
			GUILayout.Label("<b>No cofre</b>", Array.Empty<GUILayoutOption>());
			List<ItemData> allItems = val.GetAllItems();
			if (allItems.Count == 0)
			{
				GUILayout.Label("<size=12><color=#" + text + ">Vazio.</color></size>", Array.Empty<GUILayoutOption>());
			}
			foreach (ItemData item in new List<ItemData>(allItems))
			{
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) });
				DrawIcon(item, 24f);
				GUILayout.Space(6f);
				GUILayout.Label("<size=13>" + NameOf(item) + "</size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(300f) });
				GUILayout.FlexibleSpace();
				if (GUILayout.Button("Retirar", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(100f),
					GUILayout.Height(24f)
				}) && !PlayerBank.Withdraw(player, item, out var message) && message != null)
				{
					((Character)player).Message((MessageType)2, message, 0, (Sprite)null);
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.Space(10f);
			GUILayout.Label("<b>Na mochila</b>", Array.Empty<GUILayoutOption>());
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (!allItem.m_equipped)
				{
					list.Add(allItem);
				}
			}
			list.Sort((ItemData a, ItemData b) => string.Compare(Localization.instance.Localize(a.m_shared.m_name), Localization.instance.Localize(b.m_shared.m_name), StringComparison.OrdinalIgnoreCase));
			if (list.Count == 0)
			{
				GUILayout.Label("<size=12><color=#" + text + ">Nada para guardar.</color></size>", Array.Empty<GUILayoutOption>());
			}
			foreach (ItemData item2 in list)
			{
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) });
				DrawIcon(item2, 24f);
				GUILayout.Space(6f);
				GUILayout.Label("<size=13>" + NameOf(item2) + "</size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(300f) });
				GUILayout.FlexibleSpace();
				if (GUILayout.Button("Guardar", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(100f),
					GUILayout.Height(24f)
				}) && !PlayerBank.Deposit(player, item2, out var message2) && message2 != null)
				{
					((Character)player).Message((MessageType)2, message2, 0, (Sprite)null);
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
		}

		private void TabButton(string label, Tab tab)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			bool num = _tab == tab;
			string text = ColorUtility.ToHtmlStringRGB(MmoUI.GoldC);
			if (GUILayout.Button(num ? ("<b><color=#" + text + ">" + label + "</color></b>") : label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) }))
			{
				_tab = tab;
				_scroll = Vector2.zero;
			}
		}

		private void DrawSell(Player player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = ((Humanoid)player).GetInventory();
			string text = ColorUtility.ToHtmlStringRGB(MmoUI.MutedC);
			string arg = ColorUtility.ToHtmlStringRGB(MmoUI.BonusC);
			int num = Mathf.RoundToInt(Mathf.Clamp01(ModConfig.MerchantBuyRatio.Value) * 100f);
			GUILayout.Label(string.Format(arg2: ModConfig.MerchantBuysMaterials.Value ? "" : " Nao compra materia-prima (joias sim, pelo valor cheio).", format: "<size=12><color=#{0}>O mercador paga <b>{1}%</b> do valor base. Itens equipados nao aparecem.{2}</color></size>", arg0: text, arg1: num), Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (CanSell(allItem))
				{
					list.Add(allItem);
				}
			}
			list.Sort((ItemData a, ItemData b) => string.Compare(Localization.instance.Localize(a.m_shared.m_name), Localization.instance.Localize(b.m_shared.m_name), StringComparison.OrdinalIgnoreCase));
			if (list.Count == 0)
			{
				GUILayout.Label("<color=#" + text + ">Nada para vender.</color>", Array.Empty<GUILayoutOption>());
				return;
			}
			_scroll = GUILayout.BeginScrollView(_scroll, Array.Empty<GUILayoutOption>());
			foreach (ItemData item in list)
			{
				int num2 = UnitBuyPrice(item);
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) });
				DrawIcon(item, 24f);
				GUILayout.Space(6f);
				GUILayout.Label("<size=13>" + NameOf(item) + "</size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(236f) });
				GUILayout.Label($"<size=13><color=#{arg}>{num2}</color><size=11><color=#{text}> /un</color></size></size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(64f) });
				GUILayout.FlexibleSpace();
				if (GUILayout.Button("1", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(32f),
					GUILayout.Height(24f)
				}))
				{
					Sell(player, item, 1);
				}
				GUI.enabled = item.m_stack > 1;
				if (GUILayout.Button($"Tudo ({num2 * item.m_stack})", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(116f),
					GUILayout.Height(24f)
				}))
				{
					Sell(player, item, item.m_stack);
				}
				GUI.enabled = true;
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
		}

		private static void Sell(Player player, ItemData item, int amount)
		{
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			StoreGui instance = StoreGui.instance;
			Inventory inventory = ((Humanoid)player).GetInventory();
			if ((Object)(object)instance == (Object)null || inventory == null || item == null)
			{
				return;
			}
			amount = Mathf.Clamp(amount, 1, item.m_stack);
			int num = UnitBuyPrice(item) * amount;
			ItemDrop coinPrefab = instance.m_coinPrefab;
			string name = ((Object)((Component)coinPrefab).gameObject).name;
			int num2 = Mathf.Max(1, coinPrefab.m_itemData.m_shared.m_maxStackSize);
			string name2 = ((Object)item.m_dropPrefab).name;
			int quality = item.m_quality;
			int variant = item.m_variant;
			float durability = item.m_durability;
			long crafterID = item.m_crafterID;
			string crafterName = item.m_crafterName;
			string arg = ((amount > 1) ? $"{amount}x {Localization.instance.Localize(item.m_shared.m_name)}" : Localization.instance.Localize(item.m_shared.m_name));
			Sprite val = ((item.m_shared.m_icons.Length != 0) ? item.m_shared.m_icons[0] : null);
			inventory.RemoveItem(item, amount);
			int num3 = num;
			int num4 = 0;
			while (num3 > 0)
			{
				int num5 = Mathf.Min(num2, num3);
				if (inventory.AddItem(name, num5, coinPrefab.m_itemData.m_quality, coinPrefab.m_itemData.m_variant, 0L, "", false) == null)
				{
					break;
				}
				num3 -= num5;
				num4 += num5;
			}
			if (num3 > 0)
			{
				if (num4 > 0)
				{
					inventory.RemoveItem(name, num4, -1, true);
				}
				ItemData val2 = inventory.AddItem(name2, amount, quality, variant, crafterID, crafterName, false);
				if (val2 != null)
				{
					val2.m_durability = durability;
				}
				((Character)player).Message((MessageType)2, "Sem espaco na mochila para as moedas.", 0, (Sprite)null);
				return;
			}
			Trader trader = instance.m_trader;
			if (trader != null)
			{
				trader.OnSold();
			}
			EffectList sellEffects = instance.m_sellEffects;
			if (sellEffects != null)
			{
				sellEffects.Create(((Component)instance).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
			}
			((Character)player).Message((MessageType)1, $"Vendido: {arg} por {num} moedas", 0, val);
			instance.FillList();
		}

		private void DrawRepair(Player player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = ((Humanoid)player).GetInventory();
			string text = ColorUtility.ToHtmlStringRGB(MmoUI.MutedC);
			ColorUtility.ToHtmlStringRGB(MmoUI.BonusC);
			GUILayout.Label($"<size=12><color=#{text}>Reparo: preco x desgaste x {ModConfig.RepairCostRatio.Value:0.##}. " + $"Melhoria: ate q{{max}}+{ModConfig.ExtraQualityLevels.Value}, preco x qualidade x {ModConfig.UpgradeCostFactor.Value:0.##}. " + "O bonus de atributo do item sobe com a qualidade.</color></size>", Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (IsEquipment(allItem))
				{
					list.Add(allItem);
				}
			}
			list.Sort((ItemData a, ItemData b) => (b.m_equipped ? 1 : 0) - (a.m_equipped ? 1 : 0));
			if (list.Count == 0)
			{
				GUILayout.Label("<color=#" + text + ">Nenhum equipamento na mochila.</color>", Array.Empty<GUILayoutOption>());
				return;
			}
			_scroll = GUILayout.BeginScrollView(_scroll, Array.Empty<GUILayoutOption>());
			foreach (ItemData item in list)
			{
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) });
				DrawIcon(item, 24f);
				GUILayout.Space(6f);
				string text2 = (item.m_equipped ? (" <size=11><color=#" + text + ">(equipado)</color></size>") : "");
				float maxDurability = item.GetMaxDurability();
				string text3 = ((item.m_shared.m_useDurability && maxDurability > 0f) ? $" <size=11><color=#{text}>{item.m_durability / maxDurability * 100f:0}%</color></size>" : "");
				GUILayout.Label("<size=13>" + NameOf(item) + text2 + text3 + "</size>", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(250f) });
				GUILayout.FlexibleSpace();
				int num = (item.m_shared.m_useDurability ? RepairCost(item) : 0);
				GUI.enabled = num > 0;
				if (GUILayout.Button((num > 0) ? $"Reparar ({num})" : "Inteiro", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(110f),
					GUILayout.Height(24f)
				}) && Pay(player, num))
				{
					item.m_durability = item.GetMaxDurability();
					((Character)player).Message((MessageType)1, $"Reparado: {NameOf(item)} por {num} moedas", 0, (Sprite)null);
					StoreGui.instance.FillList();
				}
				int num2 = MaxUpgradeQuality(item);
				GUI.enabled = item.m_quality < num2;
				int num3 = UpgradeCost(item);
				if (GUILayout.Button((item.m_quality < num2) ? $"q{item.m_quality + 1} ({num3})" : $"q{item.m_quality} max", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(104f),
					GUILayout.Height(24f)
				}) && Pay(player, num3))
				{
					item.m_quality++;
					item.m_durability = item.GetMaxDurability();
					MmoUI.RefreshStats(player);
					((Character)player).Message((MessageType)1, $"{NameOf(item)} melhorado para q{item.m_quality} por {num3} moedas", 0, (Sprite)null);
					StoreGui.instance.FillList();
				}
				GUI.enabled = true;
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
		}

		private void DrawQuests(Player player)
		{
			int tier = Mathf.Clamp((PlayerProgress.Get(player)?.Level ?? 1) / 10 + 1, 1, 7);
			QuestListUI.Draw(player, tier, $"Dia {QuestSystem.CurrentDay()}. Aceite, cumpra e volte para concluir. Trocam a cada dia do mundo e seguem a sua faixa de level.");
		}

		private static string NameOf(ItemData item)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string arg = ColorUtility.ToHtmlStringRGB(MmoUI.MutedC);
			string text = Localization.instance.Localize(item.m_shared.m_name);
			string text2 = ((item.m_shared.m_maxQuality > 1) ? $" <size=11><color=#{arg}>q{item.m_quality}</color></size>" : "");
			string text3 = ((item.m_stack > 1) ? $" <color=#{arg}>x{item.m_stack}</color>" : "");
			return text + text2 + text3;
		}

		private static void DrawIcon(ItemData item, float size)
		{
			//IL_001a: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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)
			Rect rect = GUILayoutUtility.GetRect(size, size, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(size),
				GUILayout.Height(size)
			});
			Sprite val = null;
			try
			{
				val = item.GetIcon();
			}
			catch
			{
			}
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.texture == (Object)null))
			{
				Texture2D texture = val.texture;
				Rect textureRect = default(Rect);
				try
				{
					textureRect = val.textureRect;
				}
				catch
				{
					((Rect)(ref textureRect))..ctor(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height);
				}
				Rect val2 = default(Rect);
				((Rect)(ref val2))..ctor(((Rect)(ref textureRect)).x / (float)((Texture)texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)texture).height, ((Rect)(ref textureRect)).width / (float)((Texture)texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)texture).height);
				GUI.DrawTextureWithTexCoords(rect, (Texture)(object)texture, val2, true);
			}
		}
	}
	[HarmonyPatch(typeof(StoreGui), "UpdateSellButton")]
	internal static class StoreGui_UpdateSellButton_Patch
	{
		private static void Postfix(StoreGui __instance)
		{
			if (ModConfig.MerchantEnabled.Value && !((Object)(object)__instance?.m_sellButton == (Object)null) && MerchantSpawner.IsMerchant(__instance.m_trader))
			{
				((Selectable)__instance.m_sellButton).interactable = false;
			}
		}
	}
	internal static class PlayerBank
	{
		private const string Key = "mmo.bank";

		private static readonly ConditionalWeakTable<Player, Inventory> Cache = new ConditionalWeakTable<Player, Inventory>();

		public static int Rows => Mathf.Clamp(ModConfig.BankRows.Value, 1, 12);

		public static Inventory Get(Player player)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			if (Cache.TryGetValue(player, out var value))
			{
				return value;
			}
			value = new Inventory("MMO_Cofre", (Sprite)null, 8, Rows);
			if (player.m_customData.TryGetValue("mmo.bank", out var value2) && !string.IsNullOrEmpty(value2))
			{
				try
				{
					value.Load(new ZPackage(value2));
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[Cofre] falha ao carregar: " + ex.Message));
				}
			}
			Cache.Add(player, value);
			return value;
		}

		public static void Save(Player player)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)player == (Object)null) && Cache.TryGetValue(player, out var value))
			{
				ZPackage val = new ZPackage();
				value.Save(val);
				player.m_customData["mmo.bank"] = val.GetBase64();
			}
		}

		public static bool Deposit(Player player, ItemData item, out string message)
		{
			message = null;
			Inventory val = Get(player);
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (val == null || inventory == null || item == null)
			{
				return false;
			}
			if (item.m_equipped)
			{
				message = "Desequipe o item antes de guardar.";
				return false;
			}
			if (!val.CanAddItem(item, -1))
			{
				message = "O cofre esta cheio.";
				return false;
			}
			val.MoveItemToThis(inventory, item);
			Save(player);
			return true;
		}

		public static bool Withdraw(Player player, ItemData item, out string message)
		{
			message = null;
			Inventory val = Get(player);
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (val == null || inventory == null || item == null)
			{
				return false;
			}
			if (!inventory.CanAddItem(item, -1))
			{
				message = "Sem espaco na mochila.";
				return false;
			}
			inventory.MoveItemToThis(val, item);
			Save(player);
			return true;
		}
	}
}
namespace ValheimMMO.Items
{
	internal static class DropPending
	{
		private sealed class Pending
		{
			public string Prefab;

			public float Durability;

			public int Quality;

			public float Time;
		}

		private static readonly List<Pending> Queue = new List<Pending>();

		public static void Enqueue(string prefabName, float durabilityFraction, int quality)
		{
			Queue.Add(new Pending
			{
				Prefab = prefabName,
				Durability = durabilityFraction,
				Quality = quality,
				Time = Time.time
			});
		}

		internal static void Apply(ItemDrop drop)
		{
			if (Queue.Count == 0 || drop?.m_itemData == null)
			{
				return;
			}
			float now = Time.time;
			Queue.RemoveAll((Pending p) => now - p.Time > 240f);
			string name = ((Object)((Component)drop).gameObject).name.Replace("(Clone)", "");
			int num = Queue.FindIndex((Pending p) => p.Prefab == name);
			if (num >= 0)
			{
				Pending pending = Queue[num];
				Queue.RemoveAt(num);
				ItemData itemData = drop.m_itemData;
				if (pending.Quality > 1)
				{
					itemData.m_quality = Mathf.Min(pending.Quality, itemData.m_shared.m_maxQuality + Mathf.Max(0, ModConfig.ExtraQualityLevels.Value));
				}
				if (pending.Durability < 0.999f && itemData.m_shared.m_useDurability)
				{
					itemData.m_durability = Mathf.Max(1f, itemData.GetMaxDurability() * Mathf.Clamp01(pending.Durability));
				}
				if ((Object)(object)drop.m_nview != (Object)null && drop.m_nview.IsValid() && drop.m_nview.IsOwner())
				{
					drop.Save();
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemDrop), "Awake")]
	internal static class ItemDrop_Awake_DropPendingPatch
	{
		private static void Postfix(ItemDrop __instance)
		{
			DropPending.Apply(__instance);
		}
	}
	internal sealed class CustomItemDef
	{
		public string Prefab;

		public string Name;

		public string Description;

		public string Source;

		public string IconFrom;

		public int MaxStack = 10;

		public float Weight = 0.3f;

		public int Price = 50;

		public string Effect;

		public float Amount;

		public bool Consumed = true;
	}
	internal static class CustomItems
	{
		internal static readonly CustomItemDef[] Defs;

		private static readonly Dictionary<string, GameObject> Prefabs;

		private static readonly Dictionary<string, CustomItemDef> ByName;

		static CustomItems()
		{
			Defs = new CustomItemDef[6]
			{
				new CustomItemDef
				{
					Prefab = "MMO_PocaoVidaMenor",
					Name = "Pocao de Vida Menor",
					Description = "Cura 30% da vida maxima na hora. Compartilha recarga com as outras pocoes.",
					Source = "MeadHealthMinor",
					IconFrom = "MeadHealthMinor",
					Price = 40,
					Effect = "heal",
					Amount = 0.3f
				},
				new CustomItemDef
				{
					Prefab = "MMO_PocaoVida",
					Name = "Pocao de Vida",
					Description = "Cura 50% da vida maxima na hora. Compartilha recarga com as outras pocoes.",
					Source = "MeadHealthMedium",
					IconFrom = "MeadHealthMedium",
					Price = 120,
					Effect = "heal",
					Amount = 0.5f
				},
				new CustomItemDef
				{
					Prefab = "MMO_PocaoVidaGrande",
					Name = "Pocao de Vida Grande",
					Description = "Cura 80% da vida maxima na hora. Compartilha recarga com as outras pocoes.",
					Source = "MeadHealthMajor",
					IconFrom = "MeadHealthMajor",
					Price = 350,
					Effect = "heal",
					Amount = 0.8f
				},
				new CustomItemDef
				{
					Prefab = "MMO_PocaoStamina",
					Name = "Pocao de Vigor",
					Description = "Recupera 50% da stamina maxima na hora. Compartilha recarga com as outras pocoes.",
					Source = "MeadStaminaMinor",
					IconFrom = "MeadStaminaMinor",
					Price = 80,
					Effect = "stamina",
					Amount = 0.5f
				},
				new CustomItemDef
				{
					Prefab = "MMO_PocaoEitr",
					Name = "Pocao de Eitr",
					Description = "Recupera 50% do eitr maximo na hora. Compartilha recarga com as outras pocoes.",
					Source = "MeadEitrMinor",
					IconFrom = "MeadEitrMinor",
					Price = 120,
					Effect = "eitr",
					Amount = 0.5f
				},
				new CustomItemDef
				{
					Prefab = "MMO_PedraRetorno",
					Name = "Pedra de Retorno",
					Description = "Ao ser usada, teleporta voce para a sua cama. Nao e consumida. Recarga longa. Respeita as regras de portal para minerios.",
					Source = "MeadHealthMinor",
					IconFrom = "Ruby",
					MaxStack = 1,
					Weight = 1f,
					Price = 300,
					Effect = "return",
					Amount = 1800f,
					Consumed = false
				}
			};
			Prefabs = new Dictionary<string, GameObject>(StringComparer.Ordinal);
			ByName = new Dictionary<string, CustomItemDef>(StringComparer.Ordinal);
			CustomItemDef[] defs = Defs;
			foreach (CustomItemDef customItemDef in defs)
			{
				ByName[customItemDef.Prefab] = customItemDef;
			}
		}

		public static CustomItemDef DefFor(string prefabName)
		{
			if (prefabName == null || !ByName.TryGetValue(prefabName, out var value))
			{
				return null;
			}
			return value;
		}

		public static CustomItemDef DefFor(ItemData item)
		{
			if (!((Object)(object)item?.m_dropPrefab != (Object)null))
			{
				return null;
			}
			return DefFor(((Object)item.m_dropPrefab).name);
		}

		public static bool IsCustom(string prefabName)
		{
			if (prefabName != null)
			{
				return ByName.ContainsKey(prefabName);
			}
			return false;
		}

		public static int PriceOf(string prefabName)
		{
			return DefFor(prefabName)?.Price ?? 0;
		}

		private static GameObject Ensure(ObjectDB db, CustomItemDef def)
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			if (Prefabs.TryGetValue(def.Prefab, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if ((Object)(object)db == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = db.GetItemPrefab(def.Source);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[Itens] prefab base '" + def.Source + "' nao encontrado para " + def.Prefab + "."));
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(itemPrefab, PrefabHolder.Root);
			((Object)val).name = def.Prefab;
			ItemDrop component = val.GetComponent<ItemDrop>();
			SharedData shared = component.m_itemData.m_shared;
			shared.m_name = def.Name;
			shared.m_description = def.Description;
			shared.m_itemType = (ItemType)2;
			shared.m_maxStackSize = def.MaxStack;
			shared.m_weight = def.Weight;
			shared.m_value = 0;
			shared.m_questItem = false;
			shared.m_teleportable = true;
			shared.m_food = 0f;
			shared.m_foodStamina = 0f;
			shared.m_foodEitr = 0f;
			shared.m_foodRegen = 0f;
			shared.m_foodBurnTime = 0f;
			shared.m_consumeStatusEffect = null;
			shared.m_maxQuality = 1;
			if (!string.IsNullOrEmpty(def.IconFrom))
			{
				GameObject itemPrefab2 = db.GetItemPrefab(def.IconFrom);
				Sprite[] array = ((itemPrefab2 == null) ? null : itemPrefab2.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_icons);
				if (array != null && array.Length != 0 && (Object)(object)array[0] != (Object)null)
				{
					shared.m_icons = (Sprite[])(object)new Sprite[1] { array[0] };
				}
			}
			component.m_itemData.m_quality = 1;
			component.m_itemData.m_stack = 1;
			component.m_itemData.m_dropPrefab = val;
			Prefabs[def.Prefab] = val;
			return val;
		}

		internal static void RegisterInDb(ObjectDB db)
		{
			if ((Object)(object)db == (Object)null)
			{
				return;
			}
			int num = 0;
			CustomItemDef[] defs = Defs;
			foreach (CustomItemDef customItemDef in defs)
			{
				GameObject val = Ensure(db, customItemDef);
				if (!((Object)(object)val == (Object)null))
				{
					if (!db.m_items.Contains(val))
					{
						db.m_items.Add(val);
					}
					db.m_itemByHash[StringExtensionMethods.GetStableHashCode(customItemDef.Prefab)] = val;
					num++;
				}
			}
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				RegisterInScene(ZNetScene.instance);
			}
			if (num > 0)
			{
				Plugin.Log.LogInfo((object)$"[Itens] {num} itens do mod registrados.");
			}
		}

		internal static void RegisterInScene(ZNetScene scene)
		{
			if ((Object)(object)scene == (Object)null)
			{
				return;
			}
			CustomItemDef[] defs = Defs;
			foreach (CustomItemDef customItemDef in defs)
			{
				GameObject val = Ensure(ObjectDB.instance, customItemDef);
				if (!((Object)(object)val == (Object)null))
				{
					if (!scene.m_prefabs.Contains(val))
					{
						scene.m_prefabs.Add(val);
					}
					scene.m_namedPrefabs[StringExtensionMethods.GetStableHashCode(customItemDef.Prefab)] = val;
				}
			}
		}
	}
	internal static class ConsumableEffects
	{
		private const string PotionCdKey = "mmo.cd.potion";

		private const string ReturnCdKey = "mmo.cd.return";

		private static double Now()
		{
			if (!((Object)(object)ZNet.instance != (Object)null))
			{
				return Time.timeAsDouble;
			}
			return ZNet.instance.GetTimeSeconds();
		}

		private static double ReadCd(Player p, string key)
		{
			if (p.m_customData.TryGetValue(key, out var value) && double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return 0.0;
		}

		private static void WriteCd(Player p, string key, double readyAt)
		{
			p.m_customData[key] = readyAt.ToString("R", CultureInfo.InvariantCulture);
		}

		public static float PotionCooldownLeft(Player p)
		{
			return (float)Math.Max(0.0, ReadCd(p, "mmo.cd.potion") - Now());
		}

		public static float ReturnCooldownLeft(Player p)
		{
			return (float)Math.Max(0.0, ReadCd(p, "mmo.cd.return") - Now());
		}

		public static bool TryUse(Player player, ItemData item, out bool consumed)
		{
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			consumed = false;
			CustomItemDef customItemDef = CustomItems.DefFor(item);
			if (customItemDef == null)
			{
				return false;
			}
			switch (customItemDef.Effect)
			{
			case "heal":
			case "stamina":
			case "eitr":
			{
				float num2 = PotionCooldownLeft(player);
				if (num2 > 0f)
				{
					((Character)player).Message((MessageType)2, $"Pocao em recarga ({num2:0}s)", 0, (Sprite)null);
					return true;
				}
				if (customItemDef.Effect == "heal")
				{
					float num3 = ((Character)player).GetMaxHealth() * customItemDef.Amount;
					((Character)player).Heal(num3, true);
					((Character)player).Message((MessageType)1, $"+{num3:0} vida", 0, (Sprite)null);
				}
				else if (customItemDef.Effect == "stamina")
				{
					float num4 = ((Character)player).GetMaxStamina() * customItemDef.Amount;
					((Character)player).AddStamina(num4);
					((Character)player).Message((MessageType)1, $"+{num4:0} stamina", 0, (Sprite)null);
				}
				else
				{
					float num5 = ((Character)player).GetMaxEitr() * customItemDef.Amount;
					if (num5 <= 0f)
					{
						((Character)player).Message((MessageType)2, "Voce nao tem eitr para recuperar.", 0, (Sprite)null);
						return true;
					}
					((Character)player).AddEitr(num5);
					((Character)player).Message((MessageType)1, $"+{num5:0} eitr", 0, (Sprite)null);
				}
				WriteCd(player, "mmo.cd.potion", Now() + (double)Mathf.Max(1f, ModConfig.PotionCooldown.Value));
				consumed = customItemDef.Consumed;
				return true;
			}
			case "return":
			{
				float num = ReturnCooldownLeft(player);
				if (num > 0f)
				{
					((Character)player).Message((MessageType)2, $"Pedra de Retorno em recarga ({num / 60f:0} min)", 0, (Sprite)null);
					return true;
				}
				Game instance = Game.instance;
				PlayerProfile val = ((instance != null) ? instance.GetPlayerProfile() : null);
				if (val == null || !val.HaveCustomSpawnPoint())
				{
					((Character)player).Message((MessageType)2, "Voce nao tem uma cama reivindicada.", 0, (Sprite)null);
					return true;
				}
				if (!ModConfig.ReturnStoneIgnoresOre.Value && !((Humanoid)player).GetInventory().IsTeleportable())
				{
					((Character)player).Message((MessageType)2, "$msg_noteleport", 0, (Sprite)null);
					return true;
				}
				Vector3 customSpawnPoint = val.GetCustomSpawnPoint();
				((Character)player).TeleportTo(customSpawnPoint, ((Component)player).transform.rotation, true);
				WriteCd(player, "mmo.cd.return", Now() + (double)Mathf.Max(10f, customItemDef.Amount * ModConfig.ReturnStoneCooldownMultiplier.Value));
				((Character)player).Message((MessageType)2, "A pedra o leva para casa.", 0, (Sprite)null);
				consumed = false;
				return true;
			}
			default:
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	internal static class ObjectDB_Awake_CustomItemsPatch
	{
		private static void Postfix(ObjectDB __instance)
		{
			CustomItems.RegisterInDb(__instance);
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
	internal static class ObjectDB_CopyOtherDB_CustomItemsPatch
	{
		private static void Postfix(ObjectDB __instance)
		{
			CustomItems.RegisterInDb(__instance);
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	internal static class ZNetScene_Awake_CustomItemsPatch
	{
		private static void Postfix(ZNetScene __instance)
		{
			CustomItems.RegisterInScene(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "ConsumeItem")]
	internal static class Player_ConsumeItem_CustomItemsPatch
	{
		private static bool Prefix(Player __instance, Inventory inventory, ItemData item, ref bool __result)
		{
			if (!ConsumableEffects.TryUse(__instance, item, out var consumed))
			{
				return true;
			}
			if (consumed)
			{
				inventory.RemoveOneItem(item);
			}
			__result = consumed;
			return false;
		}
	}
	internal static class MapItem
	{
		public const string PrefabName = "MMO_MapaExplorador";

		private const string SourcePrefab = "MeadHealthMinor";

		private const string IconPiece = "piece_cartographytable";

		private static GameObject _prefab;

		private static readonly MethodInfo ExploreMethod = AccessTools.Method(typeof(Minimap), "Explore", new Type[2]
		{
			typeof(Vector3),
			typeof(float)
		}, (Type[])null);

		private static readonly MethodInfo IsExploredMethod = AccessTools.Method(typeof(Minimap), "IsExplored", new Type[1] { typeof(Vector3) }, (Type[])null);

		public static bool IsMap(ItemData item)
		{
			if ((Object)(object)item?.m_dropPrefab != (Object)null)
			{
				return ((Object)item.m_dropPrefab).name == "MMO_MapaExplorador";
			}
			return false;
		}

		public static bool IsMap(string prefabName)
		{
			return prefabName == "MMO_MapaExplorador";
		}

		private static GameObject EnsurePrefab(ObjectDB db)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_prefab != (Object)null)
			{
				return _prefab;
			}
			if ((Object)(object)db == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = db.GetItemPrefab("MeadHealthMinor");
			if ((Object)(object)itemPrefab == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[Mapa] prefab base 'MeadHealthMinor' nao encontrado; item nao criado.");
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(itemPrefab, PrefabHolder.Root);
			((Object)val).name = "MMO_MapaExplorador";
			ItemDrop component = val.GetComponent<ItemDrop>();
			SharedData shared = component.m_itemData.m_shared;
			shared.m_name = "Mapa do Explorador";
			shared.m_description = "Um mapa antigo e rabiscado. Ao ser lido, revela uma regiao ainda desconhecida do mundo e marca o local.";
			shared.m_itemType = (ItemType)2;
			shared.m_maxStackSize = 10;
			shared.m_weight = 0.3f;
			shared.m_value = 0;
			shared.m_questItem = false;
			shared.m_teleportable = true;
			shared.m_food = 0f;
			shared.m_foodStamina = 0f;
			shared.m_foodEitr = 0f;
			shared.m_foodRegen = 0f;
			shared.m_foodBurnTime = 0f;
			shared.m_consumeStatusEffect = null;
			shared.m_maxQuality = 1;
			ZNetScene instance = ZNetScene.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameObject prefab = instance.GetPrefab("piece_cartographytable");
				obj = ((prefab == null) ? null : prefab.GetComponent<Piece>()?.m_icon);
			}
			Sprite val2 = (Sprite)obj;
			if ((Object)(object)val2 != (Object)null)
			{
				shared.m_icons = (Sprite[])(object)new Sprite[1] { val2 };
			}
			component.m_itemData.m_quality = 1;
			component.m_itemData.m_stack = 1;
			component.m_itemData.m_dropPrefab = val;
			_prefab = val;
			Plugin.Log.LogInfo((object)"[Mapa] Item criado.");
			return _prefab;
		}

		internal static void RegisterInDb(ObjectDB db)
		{
			GameObject val = EnsurePrefab(db);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)db == (Object)null))
			{
				if (!db.m_items.Contains(val))
				{
					db.m_items.Add(val);
				}
				db.m_itemByHash[StringExtensionMethods.GetStableHashCode("MMO_MapaExplorador")] = val;
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					RegisterInScene(ZNetScene.instance);
				}
			}
		}

		internal static void RegisterInScene(ZNetScene scene)
		{
			GameObject val = EnsurePrefab(ObjectDB.instance);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)scene == (Object)null))
			{
				if (!scene.m_prefabs.Contains(val))
				{
					scene.m_prefabs.Add(val);
				}
				scene.m_namedPrefabs[StringExtensionMethods.GetStableHashCode("MMO_MapaExplorador")] = val;
			}
		}

		private static bool IsExplored(Minimap mm, Vector3 p)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (IsExploredMethod == null)
			{
				return false;
			}
			try
			{
				return (bool)IsExploredMethod.Invoke(mm, new object[1] { p });
			}
			catch
			{
				return false;
			}
		}

		public static bool Use(Player player)
		{
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: 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_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || ExploreMethod == null)
			{
				((Character)player).Message((MessageType)2, "O mapa esta ilegivel aqui.", 0, (Sprite)null);
				return false;
			}
			float num = Mathf.Max(500f, ModConfig.MapWorldRadius.Value);
			float num2 = Mathf.Max(50f, ModConfig.MapRevealRadius.Value);
			Vector3 val = Vector3.zero;
			bool flag = false;
			WorldGenerator instance2 = WorldGenerator.instance;
			Vector3 val2 = default(Vector3);
			for (int i = 0; i < 2; i++)
			{
				if (flag)
				{
					break;
				}
				for (int j = 0; j < 60; j++)
				{
					float num3 = Random.value * MathF.PI * 2f;
					float num4 = Mathf.Sqrt(Random.value) * num;
					((Vector3)(ref val2))..ctor(Mathf.Cos(num3) * num4, 0f, Mathf.Sin(num3) * num4);
					if (!IsExplored(instance, val2) && (i != 0 || instance2 == null || (int)instance2.GetBiome(val2) != 256))
					{
						val = val2;
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				float num5 = Random.value * MathF.PI * 2f;
				float num6 = Mathf.Sqrt(Random.value) * num;
				((Vector3)(ref val))..ctor(Mathf.Cos(num5) * num6, 0f, Mathf.Sin(num5) * num6);
			}
			try
			{
				ExploreMethod.Invoke(instance, new object[2] { val, num2 });
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[Mapa] Explore falhou: " + ex.Message));
				((Character)player).Message((MessageType)2, "O mapa esta ilegivel aqui.", 0, (Sprite)null);
				return false;
			}
			try
			{
				instance.AddPin(val, (PinType)3, "Mapa do Explorador", true, false, 0L, default(PlatformUserID));
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("[Mapa] Pin falhou: " + ex2.Message));
			}
			Vector3 val3 = val - ((Component)player).transform.position;
			Vector2 val4 = new Vector2(val3.x, val3.z);
			float num7 = ((Vector2)(ref val4)).magnitude / 1000f;
			((Character)player).Message((MessageType)2, $"O mapa revela uma regiao a {num7:0.0} km {Compass(val3)}", 0, (Sprite)null);
			return true;
		}

		private static string Compass(Vector3 d)
		{
			//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)
			float num = Mathf.Atan2(d.x, d.z) * 57.29578f;
			if (num < 0f)
			{
				num += 360f;
			}
			string[] obj = new string[8] { "ao norte", "a nordeste", "a leste", "a sudeste", "ao sul", "a sudoeste", "a oeste", "a noroeste" };
			int num2 = Mathf.RoundToInt(num / 45f) % 8;
			return obj[num2];
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	internal static class ObjectDB_Awake_MapItemPatch
	{
		private static void Postfix(ObjectDB __instance)
		{
			MapItem.RegisterInDb(__instance);
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
	internal static class ObjectDB_CopyOtherDB_MapItemPatch
	{
		private static void Postfix(ObjectDB __instance)
		{
			MapItem.RegisterInDb(__instance);
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	internal static class ZNetScene_Awake_MapItemPatch
	{
		private static void Postfix(ZNetScene __instance)
		{
			MapItem.RegisterInScene(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "ConsumeItem")]
	internal static class Player_ConsumeItem_MapPatch
	{
		private static bool Prefix(Player __instance, Inventory inventory, ItemData item, ref bool __result)
		{
			if (!MapItem.IsMap(item))
			{
				return true;
			}
			__result = MapItem.Use(__instance);
			if (__result)
			{
				inventory.RemoveOneItem(item);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CharacterDrop), "GenerateDropList")]
	internal static class CharacterDrop_GenerateDropList_MapPatch
	{
		private static void Postfix(CharacterDrop __instance, ref List<KeyValuePair<GameObject, int>> __result)
		{
			if (__result != null && !((Object)(object)__instance?.m_character == (Object)null) && __instance.m_character.IsBoss() && (WorldBoss.IsWorldBoss(__instance.m_character, out var _) || !(Random.value > ModConfig.MapBossDropChance.Value)))
			{
				ObjectDB instance = ObjectDB.instance;
				GameObject val = ((instance != null) ? instance.GetItemPrefab("MMO_MapaExplorador") : null);
				if (!((Object)(object)val == (Object)null))
				{
					__result.Add(new KeyValuePair<GameObject, int>(val, 1));
				}
			}
		}
	}
	internal static class PrefabHolder
	{
		private static GameObject _root;

		public static Transform Root
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)_root == (Object)null)
				{
					_root = new GameObject("ValheimMMO_Prefabs");
					_root.SetActive(false);
					Object.DontDestroyOnLoad((Object)(object)_root);
				}
				return _root.transform;
			}
		}
	}
}
namespace ValheimMMO.InventorySlots
{
	internal static class CarrySlots
	{
		public const int BaseRows = 4;

		public const float BaseCarryKg = 300f;

		private static float _lastWarn;

		public static int DesiredRows(Player player)
		{
			if (!ModConfig.SlotsEnabled.Value || (Object)(object)player == (Object)null)
			{
				return 4;
			}
			float num = Mathf.Max(8f, ModConfig.SlotsKgPerRow.Value);
			float num2 = player.GetMaxCarryWeight() - 300f;
			int num3 = ((!(num2 <= 0f)) ? Mathf.FloorToInt(num2 / num) : 0);
			return Mathf.Clamp(4 + num3, 4, Mathf.Max(4, ModConfig.SlotsMaxRows.Value));
		}

		public static void Apply(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return;
			}
			int num = DesiredRows(player);
			int height = inventory.m_height;
			if (height == num)
			{
				return;
			}
			if (num < height)
			{
				foreach (ItemData allItem in inventory.GetAllItems())
				{
					if (allItem.m_gridPos.y >= num && !EquipmentRow.IsVirtual(allItem))
					{
						if (Time.time - _lastWarn > 30f && (Object)(object)player == (Object)(object)Player.m_localPlayer)
						{
							_lastWarn = Time.time;
							((Character)player).Message((MessageType)1, "Peso maximo caiu: esvazie as ultimas linhas da mochila para elas fecharem.", 0, (Sprite)null);
						}
						return;
					}
				}
			}
			inventory.m_height = num;
			inventory.Changed();
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer && num > height)
			{
				((Character)player).Message((MessageType)1, $"Mochila: +{(num - height) * inventory.m_width} slots", 0, (Sprite)null);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateStats", new Type[] { typeof(float) })]
	internal static class Player_UpdateStats_SlotsPatch
	{
		private static float _timer;

		private static void Postfix(Player __instance, float dt)
		{
			_timer += dt;
			if (!(_timer < 1f))
			{
				_timer = 0f;
				CarrySlots.Apply(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "Load")]
	internal static class Player_Load_SlotsPatch
	{
		private static void Postfix(Player __instance)
		{
			Inventory val = ((__instance != null) ? ((Humanoid)__instance).GetInventory() : null);
			if (val == null)
			{
				return;
			}
			int num = val.m_height - 1;
			foreach (ItemData allItem in val.GetAllItems())
			{
				if (allItem.m_gridPos.y > num && !EquipmentRow.IsVirtual(allItem))
				{
					num = allItem.m_gridPos.y;
				}
			}
			int num2 = Mathf.Max(val.m_height, num + 1);
			int num3 = CarrySlots.DesiredRows(__instance);
			int num4 = Mathf.Max(num2, num3);
			if (num4 != val.m_height)
			{
				val.m_height = num4;
				if ((Object)(object)Game.instance != (Object)null)
				{
					val.Changed();
				}
			}
		}
	}
	internal static class EquipmentRow
	{
		public sealed class Slot
		{
			public string Name;

			public int X;

			public int Y;

			public Slot(string n, int x, int y)
			{
				Name = n;
				X = x;
				Y = y;
			}
		}

		public const int VirtualRow = 100;

		public const int OverflowRow = 102;

		public static readonly Slot[] Slots = new Slot[10]
		{
			new Slot("Arma", 0, 100),
			new Slot("Mao esq.", 1, 100),
			new Slot("Arco", 2, 100),
			new Slot("Flechas", 3, 100),
			new Slot("Capacete", 4, 100),
			new Slot("Peito", 5, 100),
			new Slot("Pernas", 6, 100),
			new Slot("Capa", 7, 100),
			new Slot("Utilitario", 0, 101),
			new Slot("Amuleto", 1, 101)
		};

		public static bool Enabled => ModConfig.EquipmentRowEnabled.Value;

		public static bool IsVirtual(ItemData item)
		{
			if (item != null)
			{
				return item.m_gridPos.y >= 100;
			}
			return false;
		}

		public static bool IsPlayerInventory(Inventory inv)
		{
			if (inv != null && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				return inv == ((Humanoid)Player.m_localPlayer).GetInventory();
			}
			return false;
		}

		public static Slot SlotFor(ItemData item)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected I4, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Invalid comparison between Unknown and I4
			if (item?.m_shared == null)
			{
				return null;
			}
			ItemType itemType = item.m_shared.m_itemType;
			switch (itemType - 3)
			{
			case 1:
				return Slots[2];
			case 0:
			case 11:
			case 19:
				if ((int)item.m_shared.m_skillType != 14)
				{
					return Slots[0];
				}
				return Slots[2];
			case 2:
			case 12:
				return Slots[1];
			case 6:
				return Slots[3];
			case 3:
				return Slots[4];
			case 4:
				return Slots[5];
			case 8:
				return Slots[6];
			case 14:
				return Slots[7];
			case 15:
				return Slots[8];
			case 21:
				return Slots[9];
			default:
				return null;
			}
		}

		public static ItemData ItemIn(Inventory inv, Slot slot)
		{
			if (inv == null)
			{
				return null;
			}
			return inv.GetItemAt(slot.X, slot.Y);
		}

		public static Vector2i FindBagSlot(Inventory inv)
		{
			//IL_0036: 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)
			for (int i = 0; i < inv.m_height; i++)
			{
				for (int j = 0; j < inv.m_width; j++)
				{
					if (inv.GetItemAt(j, i) == null)
					{
						return new Vector2i(j, i);
					}
				}
			}
			return new Vector2i(-1, -1);
		}

		private static Vector2i FindOverflowSlot(Inventory inv)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < inv.m_width; i++)
			{
				if (inv.GetItemAt(i, 102) == null)
				{
					return new Vector2i(i, 102);
				}
			}
			return new Vector2i(inv.m_width, 102);
		}

		public static void PlaceInSlot(Inventory inv, ItemData item)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (!Enabled || inv == null || item == null || !IsPlayerInventory(inv))
			{
				return;
			}
			Slot slot = SlotFor(item);
			if (slot == null || (item.m_gridPos.x == slot.X && item.m_gridPos.y == slot.Y))
			{
				return;
			}
			ItemData val = ItemIn(inv, slot);
			if (val != null && val != item)
			{
				if (val.m_equipped)
				{
					return;
				}
				MoveToBagOrOverflow(inv, val);
			}
			item.m_gridPos = new Vector2i(slot.X, slot.Y);
			inv.Changed();
		}

		public static void ReturnToBag(Inventory inv, ItemData item)
		{
			if (Enabled && inv != null && item != null && IsPlayerInventory(inv) && IsVirtual(item))
			{
				MoveToBagOrOverflow(inv, item);
				inv.Changed();
			}
		}

		private static void MoveToBagOrOverflow(Inventory inv, ItemData item)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Vector2i val = FindBagSlot(inv);
			if (val.x >= 0)
			{
				item.m_gridPos = val;
			}
			else if (item.m_gridPos.y != 102)
			{
				item.m_gridPos = FindOverflowSlot(inv);
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, "Mochila cheia: " + Localization.instance.Localize(item.m_shared.m_name) + " ficou no painel de equipamento.", 0, (Sprite)null);
				}
			}
		}

		public static bool TryStore(Inventory inv, ItemData item)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Vector2i val = FindBagSlot(inv);
			if (val.x < 0)
			{
				return false;
			}
			item.m_gridPos = val;
			inv.Changed();
			return true;
		}

		public static void Validate(Player player)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (!Enabled || (Object)(object)player == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return;
			}
			bool flag = false;
			foreach (ItemData item in new List<ItemData>(inventory.GetAllItems()))
			{
				if (item.m_equipped)
				{
					Slot slot = SlotFor(item);
					if (slot == null || (item.m_gridPos.x == slot.X && item.m_gridPos.y == slot.Y))
					{
						continue;
					}
					ItemData val = ItemIn(inventory, slot);
					if (val == null || !val.m_equipped)
					{
						if (val != null)
						{
							MoveToBagOrOverflow(inventory, val);
						}
						item.m_gridPos = new Vector2i(slot.X, slot.Y);
						flag = true;
					}
				}
				else if (IsVirtual(item))
				{
					Vector2i val2 = FindBagSlot(inventory);
					if (val2.x >= 0)
					{
						item.m_gridPos = val2;
						flag = true;
					}
					else if (item.m_gridPos.y != 102)
					{
						item.m_gridPos = FindOverflowSlot(inventory);
						flag = true;
					}
				}
			}
			if (flag)
			{
				inventory.Changed();
			}
		}

		public static List<ItemData> OverflowItems(Inventory inv)
		{
			List<ItemData> list = new List<ItemData>();
			if (inv == null)
			{
				return list;
			}
			foreach (ItemData allItem in inv.GetAllItems())
			{
				if (IsVirtual(allItem) && !allItem.m_equipped)
				{
					list.Add(allItem);
				}
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(Humanoid), "EquipItem")]
	internal static class Humanoid_EquipItem_RowPatch
	{
		private static void Postfix(Humanoid __instance, ItemData item, bool __result)
		{
			if (__result)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val != null && !((Object)(object)val != (Object)(object)Player.m_localPlayer))
				{
					EquipmentRow.PlaceInSlot(((Humanoid)val).GetInventory(), item);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
	internal static class Humanoid_UnequipItem_RowPatch
	{
		private static void Postfix(Humanoid __instance, ItemData item)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if (val != null && !((Object)(object)val != (Object)(object)Player.m_localPlayer) && item != null && !item.m_equipped)
			{
				EquipmentRow.ReturnToBag(((Humanoid)val).GetInventory(), item);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
	internal static class InventoryGrid_UpdateGui_RowPatch
	{
		private static readonly List<ItemData> Hidden = new List<ItemData>();

		private static Inventory _inv;

		private static void Prefix(InventoryGrid __instance)
		{
			_inv = null;
			Inventory inventory = __instance.m_inventory;
			if (inventory == null || !EquipmentRow.Enabled)
			{
				return;
			}
			Hidden.Clear();
			foreach (ItemData item in inventory.m_inventory)
			{
				if (EquipmentRow.IsVirtual(item))
				{
					Hidden.Add(item);
				}
			}
			if (Hidden.Count == 0)
			{
				return;
			}
			_inv = inventory;
			foreach (ItemData item2 in Hidden)
			{
				inventory.m_inventory.Remove(item2);
			}
		}

		private static void Postfix()
		{
			if (_inv == null)
			{
				return;
			}
			foreach (ItemData item in Hidden)
			{
				if (!_inv.m_inventory.Contains(item))
				{
					_inv.m_inventory.Add(item);
				}
			}
			Hidden.Clear();
			_inv = null;
		}

		private static Exception Finalizer(Exception __exception)
		{
			Postfix();
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
	{
		typeof(ItemData),
		typeof(int),
		typeof(int),
		typeof(int)
	})]
	internal static class Inventory_AddItemAt_RowPatch
	{
		private static bool Prefix(Inventory __instance, ItemData item, int amount, int x, int y, ref bool __result)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (item == null)
			{
				return true;
			}
			if (y < 100)
			{
				if (y >= __instance.m_height && x >= 0 && x < __instance.m_width && y < 40)
				{
					__instance.m_height = y + 1;
				}
				return true;
			}
			amount = Mathf.Min(amount, item.m_stack);
			if (__instance.GetItemAt(x, y) != null)
			{
				y = 102;
				x = 0;
				while (__instance.GetItemAt(x, y) != null)
				{
					x++;
				}
			}
			ItemData val = item.Clone();
			val.m_stack = amount;
			val.m_gridPos = new Vector2i(x, y);
			__instance.m_inventory.Add(val);
			item.m_stack -= amount;
			__instance.Changed();
			__result = true;
			return false;
		}
	}
	[HarmonyPatch(typeof(Inventory), "GetEmptySlots")]
	internal static class Inventory_GetEmptySlots_RowPatch
	{
		private static void Postfix(Inventory __instance, ref int __result)
		{
			if (!EquipmentRow.Enabled)
			{
				return;
			}
			int num = 0;
			foreach (ItemData item in __instance.m_inventory)
			{
				if (EquipmentRow.IsVirtual(item))
				{
					num++;
				}
			}
			if (num > 0)
			{
				__result = Mathf.Min(__instance.m_width * __instance.m_height, __result + num);
			}
		}
	}
	[HarmonyPatch(typeof(Inventory), "HaveEmptySlot")]
	internal static class Inventory_HaveEmptySlot_RowPatch
	{
		private static void Postfix(Inventory __instance, ref bool __result)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!__result && EquipmentRow.Enabled)
			{
				__result = EquipmentRow.FindBagSlot(__instance).x >= 0;
			}
		}
	}
	[HarmonyPatch(typeof(Inventory), "MoveInventoryToGrave")]
	internal static class Inventory_MoveInventoryToGrave_RowPatch
	{
		private static void Postfix(Inventory __instance)
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData item in __instance.m_inventory)
			{
				if (EquipmentRow.IsVirtual(item))
				{
					list.Add(item);
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			Vector2i val = default(Vector2i);
			foreach (ItemData item2 in list)
			{
				((Vector2i)(ref val))..ctor(-1, -1);
				for (int i = 0; i < __instance.m_height; i++)
				{
					if (val.x >= 0)
					{
						break;
					}
					for (int j = 0; j < __instance.m_width; j++)
					{
						if (__instance.GetItemAt(j, i) == null)
						{
							((Vector2i)(ref val))..ctor(j, i);
							break;
						}
					}
				}
				if (val.x < 0)
				{
					__instance.m_height++;
					((Vector2i)(ref val))..ctor(0, __instance.m_height - 1);
				}
				item2.m_gridPos = val;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateStats", new Type[] { typeof(float) })]
	internal static class Player_UpdateStats_RowPatch
	{
		private static float _timer;

		private static void Postfix(Player __instance, float dt)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				_timer += dt;
				if (!(_timer < 1f))
				{
					_timer = 0f;
					EquipmentRow.Validate(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateInventory")]
	internal static class InventoryGui_UpdateInventory_ResizePatch
	{
		private static float _basePanelHeight = -1f;

		private static float _baseGridHeight = -1f;

		private static int _lastRows = -1;

		private static InventoryGui _gui;

		private static void Postfix(InventoryGui __instance, Player player)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			Inventory val = ((player != null) ? ((Humanoid)player).GetInventory() : null);
			RectTransform val2 = __instance?.m_player;
			InventoryGrid val3 = __instance?.m_playerGrid;
			if (val == null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)val3).transform;
			RectTransform val4 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (!((Object)(object)val4 == (Object)null))
			{
				if ((Object)(object)_gui != (Object)(object)__instance)
				{
					_gui = __instance;
					_lastRows = -1;
					Rect rect = val2.rect;
					_basePanelHeight = ((Rect)(ref rect)).height;
					rect = val4.rect;
					_baseGridHeight = ((Rect)(ref rect)).height;
				}
				int height = val.GetHeight();
				if (height != _lastRows)
				{
					_lastRows = height;
					float num = (float)Mathf.Max(0, height - 4) * val3.m_elementSpace;
					val2.SetSizeWithCurrentAnchors((Axis)1, _basePanelHeight + num);
					val4.SetSizeWithCurrentAnchors((Axis)1, _baseGridHeight + num);
					val3.ResetView();
				}
			}
		}
	}
}
namespace ValheimMMO.Hunger
{
	[HarmonyPatch(typeof(Player), "UpdateStats", new Type[] { typeof(float) })]
	internal static class Player_UpdateStats_HungerPatch
	{
		private static void Postfix(Player __instance, float dt)
		{
			HungerSystem.Tick(__instance, dt);
		}
	}
	[HarmonyPatch(typeof(Player), "EatFood")]
	internal static class Player_EatFood_Patch
	{
		private static bool Prefix(Player __instance, ItemData item, ref bool __result)
		{
			if (!ModConfig.HungerEnabled.Value)
			{
				return true;
			}
			__result = HungerSystem.CanEatNow(__instance, item, showMessage: true);
			return false;
		}

		private static void Postfix(Player __instance, ItemData item, bool __result)
		{
			if (__result)
			{
				HungerSystem.Eat(__instance, item);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "CanEat")]
	internal static class Player_CanEat_Patch
	{
		private static bool Prefix(Player __instance, ItemData item, bool showMessages, ref bool __result)
		{
			if (!ModConfig.HungerEnabled.Value)
			{
				return true;
			}
			__result = HungerSystem.CanEatNow(__instance, item, showMessages);
			return false;
		}
	}
	[HarmonyPatch(typeof(SEMan), "ModifyHealthRegen")]
	internal static class SEMan_ModifyHealthRegen_Patch
	{
		private static void Postfix(SEMan __instance, ref float regenMultiplier)
		{
			if (TryGetTrackedPlayer(__instance, out var player))
			{
				PlayerProgress playerProgress = PlayerProgress.Get(player);
				if (playerProgress != null && !(playerProgress.Satiety < 0f))
				{
					regenMultiplier *= HungerSystem.HealthRegenMultiplier(HungerSystem.StateOf(playerProgress.Satiety));
				}
			}
		}

		internal static bool TryGetTrackedPlayer(SEMan seman, out Player player)
		{
			player = null;
			if (!ModConfig.HungerEnabled.Value)
			{
				return false;
			}
			Character obj = seman?.m_character;
			Player val = (Player)(object)((obj is Player) ? obj : null);
			if (val != null && (Object)(object)val == (Object)(object)Player.m_localPlayer)
			{
				player = val;
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(SEMan), "ModifyStaminaRegen")]
	internal static class SEMan_ModifyStaminaRegen_Patch
	{
		private static void Postfix(SEMan __instance, ref float staminaMultiplier)
		{
			if (SEMan_ModifyHealthRegen_Patch.TryGetTrackedPlayer(__instance, out var player))
			{
				PlayerProgress playerProgress = PlayerProgress.Get(player);
				if (playerProgress != null && !(playerProgress.Satiety < 0f))
				{
					staminaMultiplier *= HungerSystem.StaminaRegenMultiplier(HungerSystem.StateOf(playerProgress.Satiety));
				}
			}
		}
	}
	[HarmonyPatch(typeof(SEMan), "ModifyEitrRegen")]
	internal static class SEMan_ModifyEitrRegen_Patch
	{
		private static void Postfix(SEMan __instance, ref float eitrMultiplier)
		{
			if (SEMan_ModifyHealthRegen_Patch.TryGetTrackedPlayer(__instance, out var player))
			{
				PlayerProgress playerProgress = PlayerProgress.Get(player);
				if (playerProgress != null && !(playerProgress.Satiety < 0f))
				{
					eitrMultiplier *= HungerSystem.EitrRegenMultiplier(HungerSystem.StateOf(playerProgress.Satiety));
				}
			}
		}
	}
	internal static class HungerStatusIcon
	{
		private const string BuffName = "MMO_BemAlimentado";

		private const string DebuffName = "MMO_Fome";

		private static SE_Stats _buff;

		private static SE_Stats _debuff;

		private static bool _iconsSet;

		private static SE_Stats Make(string name, string display, string tooltip)
		{
			SE_Stats obj = ScriptableObject.CreateInstance<SE_Stats>();
			((Object)obj).name = name;
			((StatusEffect)obj).m_name = display;
			((StatusEffect)obj).m_tooltip = tooltip;
			((StatusEffect)obj).m_ttl = 0f;
			((StatusEffect)obj).m_category = "mmo_hunger";
			return obj;
		}

		internal static void Register(ObjectDB db)
		{
			if (!((Object)(object)db == (Object)null))
			{
				if ((Object)(object)_buff == (Object)null)
				{
					_buff = Make("MMO_BemAlimentado", "Bem alimentado", $"Saciedade alta. +{(ModConfig.WellFedRegenMult.Value - 1f) * 100f:0}% de regeneracao de vida e stamina.");
				}
				if ((Object)(object)_debuff == (Object)null)
				{
					_debuff = Make("MMO_Fome", "Com fome", "Regeneracao reduzida. Coma algo.");
				}
				if (!db.m_StatusEffects.Contains((StatusEffect)(object)_buff))
				{
					db.m_StatusEffects.Add((StatusEffect)(object)_buff);
				}
				if (!db.m_StatusEffects.Contains((StatusEffect)(object)_debuff))
				{
					db.m_StatusEffects.Add((StatusEffect)(object)_debuff);
				}
			}
		}

		private static void EnsureIcons()
		{
			if (_iconsSet)
			{
				return;
			}
			Hud instance = Hud.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				Image foodIcon = instance.m_foodIcon;
				obj = ((foodIcon != null) ? foodIcon.sprite : null);
			}
			if (!((Object)obj == (Object)null))
			{
				Sprite sprite = Hud.instance.m_foodIcon.sprite;
				if ((Object)(object)_buff != (Object)null)
				{
					((StatusEffect)_buff).m_icon = sprite;
				}
				if ((Object)(object)_debuff != (Object)null)
				{
					((StatusEffect)_debuff).m_icon = sprite;
				}
				_iconsSet = true;
			}
		}

		internal static void Apply(Player player, HungerState state)
		{
			if (!ModConfig.HungerStatusIcons.Value || (Object)(object)player == (Object)null || (Object)(object)_buff == (Object)null || (Object)(object)_debuff == (Object)null)
			{
				return;
			}
			EnsureIcons();
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null)
			{
				return;
			}
			bool num = state == HungerState.WellFed;
			bool flag = state == HungerState.Hungry || state == HungerState.Starving || state == HungerState.Starved;
			int num2 = ((StatusEffect)_buff).NameHash();
			int num3 = ((StatusEffect)_debuff).NameHash();
			if (num && !sEMan.HaveStatusEffect(num2))
			{
				sEMan.AddStatusEffect(num2, false, 0, 0f);
			}
			if (!num && sEMan.HaveStatusEffect(num2))
			{
				sEMan.RemoveStatusEffect(num2, true);
			}
			if (flag && !sEMan.HaveStatusEffect(num3))
			{
				sEMan.AddStatusEffect(num3, false, 0, 0f);
			}
			if (!flag && sEMan.HaveStatusEffect(num3))
			{
				sEMan.RemoveStatusEffect(num3, true);
			}
			if (flag)
			{
				StatusEffect statusEffect = sEMan.GetStatusEffect(num3);
				if ((Object)(object)statusEffect != (Object)null)
				{
					statusEffect.m_name = HungerSystem.DisplayName(state);
					StatusEffect val = statusEffect;
					val.m_tooltip = state switch
					{
						HungerState.Hungry => "Regeneracao de vida e stamina reduzida. Coma algo.", 
						HungerState.Starving => "Sem regeneracao de vida. Stamina e eitr lentos. Coma agora.", 
						_ => "Voce esta morrendo de fome. Perdendo vida.", 
					};
				}
			}
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	internal static class ObjectDB_Awake_HungerIconPatch
	{
		private static void Postfix(ObjectDB __instance)
		{
			HungerStatusIcon.Register(__instance);
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
	internal static class ObjectDB_CopyOtherDB_HungerIconPatch
	{
		private static void Postfix(ObjectDB __instance)
		{
			HungerStatusIcon.Register(__instance);
		}
	}
	public enum HungerState
	{
		WellFed,
		Fed,
		Hungry,
		Starving,
		Starved
	}
	public static class HungerSystem
	{
		private static float _damageTimer;

		private static float _saveTimer;

		private static HungerState _lastState = HungerState.Fed;

		public static float Max => Mathf.Max(1f, ModConfig.HungerMax.Value);

		public static HungerState StateOf(float satiety)
		{
			if (satiety <= 0f)
			{
				return HungerState.Starved;
			}
			if (satiety < ModConfig.StarvingThreshold.Value)
			{
				return HungerState.Starving;
			}
			if (satiety < ModConfig.HungryThreshold.Value)
			{
				return HungerState.Hungry;
			}
			if (satiety >= ModConfig.WellFedThreshold.Value)
			{
				return HungerState.WellFed;
			}
			return HungerState.Fed;
		}

		public static string DisplayName(HungerState s)
		{
			return s switch
			{
				HungerState.WellFed => "Bem alimentado", 
				HungerState.Fed => "Saciado", 
				HungerState.Hungry => "Com fome", 
				HungerState.Starving => "Faminto", 
				HungerState.Starved => "Inanicao", 
				_ => "", 
			};
		}

		public static Color ColorOf(HungerState s)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(s switch
			{
				HungerState.WellFed => new Color(0.45f, 0.9f, 0.4f), 
				HungerState.Fed => new Color(0.55f, 0.78f, 0.35f), 
				HungerState.Hungry => new Color(0.9f, 0.75f, 0.25f), 
				HungerState.Starving => new Color(0.88f, 0.42f, 0.15f), 
				_ => new Color(0.8f, 0.18f, 0.18f), 
			});
		}

		public static void Tick(Player player, float dt)
		{
			if (!ModConfig.HungerEnabled.Value || (Object)(object)player == (Object)null || dt <= 0f)
			{
				return;
			}
			PlayerProgress playerProgress = PlayerProgress.Get(player);
			if (playerProgress != null)
			{
				if (playerProgress.Satiety < 0f)
				{
					playerProgress.Satiety = Max;
				}
				float num = Max / Mathf.Max(1f, ModConfig.HungerDrainMinutes.Value * 60f);
				playerProgress.Satiety = Mathf.Clamp(playerProgress.Satiety - num * dt, 0f, Max);
				HungerState hungerState = StateOf(playerProgress.Satiety);
				if (hungerState != _lastState)
				{
					AnnounceStateChange(player, _lastState, hungerState);
					_lastState = hungerState;
				}
				HungerStatusIcon.Apply(player, hungerState);
				if (hungerState == HungerState.Starved)
				{
					ApplyStarvationDamage(player, dt);
				}
				else
				{
					_damageTimer = 0f;
				}
				_saveTimer += dt;
				if (_saveTimer >= 5f)
				{
					_saveTimer = 0f;
					playerProgress.SaveTo(player);
				}
			}
		}

		private static void AnnounceStateChange(Player player, HungerState from, HungerState to)
		{
			if (to > from)
			{
				((Character)player).Message((MessageType)2, to switch
				{
					HungerState.Hungry => "Voce esta com fome", 
					HungerState.Starving => "Voce esta faminto", 
					HungerState.Starved => "Voce esta morrendo de fome", 
					_ => "", 
				}, 0, (Sprite)null);
			}
		}

		private static void ApplyStarvationDamage(Player player, float dt)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			float num = Mathf.Max(0.5f, ModConfig.StarvationDamageInterval.Value);
			_damageTimer += dt;
			if (_damageTimer < num)
			{
				return;
			}
			_damageTimer = 0f;
			float value = ModConfig.StarvationDamage.Value;
			if (value <= 0f)
			{
				return;
			}
			if (!ModConfig.StarvationCanKill.Value && ((Character)player).GetHealth() - value <= 1f)
			{
				if (((Character)player).GetHealth() > 1f)
				{
					((Character)player).SetHealth(1f);
				}
				return;
			}
			HitData val = new HitData
			{
				m_damage = 
				{
					m_damage = value
				},
				m_point = ((Character)player).GetCenterPoint(),
				m_dir = Vector3.up,
				m_hitType = (HitType)14
			};
			((Character)player).Damage(val);
		}

		public static float SatietyFrom(ItemData item)
		{
			if (item?.m_shared == null)
			{
				return 0f;
			}
			return item.m_shared.m_foodBurnTime * ModConfig.SatietyPerBurnSecond.Value;
		}

		public static bool CanEatNow(Player player, ItemData item, bool showMessage)
		{
			if (!ModConfig.HungerEnabled.Value || (Object)(object)player == (Object)null || item == null)
			{
				return true;
			}
			PlayerProgress playerProgress = PlayerProgress.Get(player);
			if (playerProgress == null)
			{
				return true;
			}
			if (playerProgress.Satiety < Max - 0.5f)
			{
				return true;
			}
			if (showMessage)
			{
				((Character)player).Message((MessageType)2, "Voce esta saciado.", 0, (Sprite)null);
			}
			return false;
		}

		public static void Eat(Player player, ItemData item)
		{
			if (!ModConfig.HungerEnabled.Value)
			{
				return;
			}
			PlayerProgress playerProgress = PlayerProgress.Get(player);
			if (playerProgress != null)
			{
				if (playerProgress.Satiety < 0f)
				{
					playerProgress.Satiety = 0f;
				}
				float num = SatietyFrom(item);
				float satiety = playerProgress.Satiety;
				playerProgress.Satiety = Mathf.Clamp(playerProgress.Satiety + num, 0f, Max);
				playerProgress.SaveTo(player);
				float num2 = playerProgress.Satiety - satiety;
				((Character)player).Message((MessageType)2, $"+{num2:0} saciedade  ({playerProgress.Satiety:0}/{Max:0})", 0, (Sprite)null);
			}
		}

		public static float HealthRegenMultiplier(HungerState s)
		{
			return s switch
			{
				HungerState.WellFed => ModConfig.WellFedRegenMult.Value, 
				HungerState.Hungry => ModConfig.HungryHealthRegenMult.Value, 
				HungerState.Starving => ModConfig.StarvingHealthRegenMult.Value, 
				HungerState.Starved => 0f, 
				_ => 1f, 
			};
		}

		public static float StaminaRegenMultiplier(HungerState s)
		{
			return s switch
			{
				HungerState.WellFed => ModConfig.WellFedRegenMult.Value, 
				HungerState.Hungry => ModConfig.HungryStaminaRegenMult.Value, 
				HungerState.Starving => ModConfig.StarvingStaminaRegenMult.Value, 
				HungerState.Starved => ModConfig.StarvingStaminaRegenMult.Value * 0.5f, 
				_ => 1f, 
			};
		}

		public static float EitrRegenMultiplier(HungerState s)
		{
			return s switch
			{
				HungerState.Starving => ModConfig.StarvingEitrRegenMult.Value, 
				HungerState.Starved => ModConfig.StarvingEitrRegenMult.Value * 0.5f, 
				_ => 1f, 
			};
		}
	}
}
namespace ValheimMMO.Dungeons
{
	internal static class BossRaids
	{
		private sealed class BossRef
		{
			public string Key;

			public string Prefab;

			public string Title;

			public int Order;
		}

		private const string Prefix = "mmo_bossraid_";

		private const string CooldownKey = "mmo_bossraid_cd";

		private static readonly BossRef[] Bosses = new BossRef[7]
		{
			new BossRef
			{
				Key = "defeated_eikthyr",
				Prefab = "Eikthyr",
				Title = "Eikthyr",
				Order = 1
			},
			new BossRef
			{
				Key = "defeated_gdking",
				Prefab = "gd_king",
				Title = "O Anciao",
				Order = 2
			},
			new BossRef
			{
				Key = "defeated_bonemass",
				Prefab = "Bonemass",
				Title = "Bonemass",
				Order = 3
			},
			new BossRef
			{
				Key = "defeated_dragon",
				Prefab = "Dragon",
				Title = "Moder",
				Order = 4
			},
			new BossRef
			{
				Key = "defeated_goblinking",
				Prefab = "GoblinKing",
				Title = "Yagluth",
				Order = 5
			},
			new BossRef
			{
				Key = "defeated_queen",
				Prefab = "SeekerQueen",
				Title = "A Rainha",
				Order = 6
			},
			new BossRef
			{
				Key = "defeated_fader",
				Prefab = "Fader",
				Title = "Fader",
				Order = 7
			}
		};

		private static float _timer;

		private const string RpcKilled = "ValheimMMO_BossRaidKilled";

		internal static void Inject(RandEventSystem sys)
		{
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Expected O, but got Unknown
			if (!ModConfig.BossRaidEnabled.Value || (Object)(object)sys == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			foreach (RandomEvent @event in sys.m_events)
			{
				if (@event != null && @event.m_name.StartsWith("mmo_bossraid_"))
				{
					return;
				}
			}
			List<RandomEvent> list = new List<RandomEvent>();
			HashSet<string> hashSet = new HashSet<string>();
			foreach (RandomEvent event2 in sys.m_events)
			{
				if (event2 == null || !event2.m_enabled || !event2.m_random || !event2.m_name.StartsWith("army_"))
				{
					continue;
				}
				BossRef bossRef = null;
				foreach (string requiredGlobalKey in event2.m_requiredGlobalKeys)
				{
					BossRef[] bosses = Bosses;
					foreach (BossRef bossRef2 in bosses)
					{
						if (string.Equals(bossRef2.Key, requiredGlobalKey, StringComparison.OrdinalIgnoreCase) && (bossRef == null || bossRef2.Order > bossRef.Order))
						{
							bossRef = bossRef2;
						}
					}
				}
				if (bossRef != null && !hashSet.Contains(bossRef.Prefab))
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(bossRef.Prefab);
					if (!((Object)(object)prefab == (Object)null) && !((Object)(object)prefab.GetComponent<Character>() == (Object)null))
					{
						RandomEvent val = event2.Clone();
						val.m_name = "mmo_bossraid_" + bossRef.Prefab;
						val.m_startMessage = bossRef.Title + " retorna para se vingar!";
						val.m_endMessage = "";
						val.m_duration = Mathf.Max(event2.m_duration, ModConfig.BossRaidMinDuration.Value);
						val.m_notRequiredGlobalKeys = new List<string>(event2.m_notRequiredGlobalKeys) { "mmo_bossraid_cd" };
						val.m_biome = (Biome)(-1);
						SpawnData val2 = ((event2.m_spawn.Count > 0) ? event2.m_spawn[0] : null);
						SpawnData item = new SpawnData
						{
							m_name = "MMO " + bossRef.Title,
							m_enabled = true,
							m_prefab = prefab,
							m_maxSpawned = 1,
							m_groupSizeMin = 1,
							m_groupSizeMax = 1,
							m_spawnChance = 100f,
							m_spawnInterval = 1f,
							m_spawnDistance = 40f,
							m_spawnRadiusMin = (val2?.m_spawnRadiusMin ?? 0f),
							m_spawnRadiusMax = (val2?.m_spawnRadiusMax ?? 0f),
							m_biome = (Biome)(-1),
							m_biomeArea = (BiomeArea)3,
							m_spawnAtDay = true,
							m_spawnAtNight = true,
							m_minAltitude = -1000f,
							m_maxAltitude = 1000f,
							m_minTilt = 0f,
							m_maxTilt = 60f,
							m_groupRadius = 5f
						};
						val.m_spawn = new List<SpawnData>(event2.m_spawn) { item };
						list.Add(val);
						hashSet.Add(bossRef.Prefab);
					}
				}
			}
			foreach (RandomEvent item2 in list)
			{
				sys.m_events.Add(item2);
			}
			if (list.Count > 0)
			{
				Plugin.Log.LogInfo((object)string.Format("[Raid de boss] {0} eventos criados: {1}", list.Count, string.Join(", ", list.ConvertAll((RandomEvent c) => c.m_name))));
			}
		}

		internal static void OnEventStarted(RandomEvent ev)
		{
			if (ev != null && ev.m_name.StartsWith("mmo_bossraid_") && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && !((Object)(object)ZoneSystem.instance == (Object)null) && !((Object)(object)EnvMan.instance == (Object)null))
			{
				ZoneSystem.instance.SetGlobalKey(string.Format("{0} {1}", "mmo_bossraid_cd", EnvMan.instance.GetDay()));
				Plugin.Log.LogInfo((object)$"[Raid de boss] {ev.m_name} iniciado; proximo possivel em {ModConfig.BossRaidCooldownDays.Value} dia(s).");
			}
		}

		internal static void Register()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				instance.Register<string>("ValheimMMO_BossRaidKilled", (Action<long, string>)OnBossKilledServer);
			}
		}

		internal static void OnCharacterDeath(Character c)
		{
			if ((Object)(object)c == (Object)null || c.IsPlayer() || (Object)(object)RandEventSystem.instance == (Object)null)
			{
				return;
			}
			RandomEvent currentRandomEvent = RandEventSystem.instance.GetCurrentRandomEvent();
			if (currentRandomEvent == null || !currentRandomEvent.m_name.StartsWith("mmo_bossraid_"))
			{
				return;
			}
			string text = ((Object)((Component)c).gameObject).name.Replace("(Clone)", "");
			if (string.Equals(currentRandomEvent.m_name, "mmo_bossraid_" + text, StringComparison.OrdinalIgnoreCase))
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance != null)
				{
					instance.InvokeRoutedRPC("ValheimMMO_BossRaidKilled", new object[1] { currentRandomEvent.m_name });
				}
			}
		}

		private static void OnBossKilledServer(long sender, string eventName)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (Object)(object)RandEventSystem.instance == (Object)null)
			{
				return;
			}
			RandomEvent currentRandomEvent = RandEventSystem.instance.GetCurrentRandomEvent();
			if (currentRandomEvent != null && !(currentRandomEvent.m_name != eventName))
			{
				RandEventSystem.instance.ResetRandomEvent();
				Plugin.Log.LogInfo((object)("[Raid de boss] " + eventName + ": boss derrotado, evento encerrado."));
				MessageHud instance = MessageHud.instance;
				if (instance != null)
				{
					instance.ShowMessage((MessageType)2, "A vinganca foi contida!", 0, (Sprite)null, false);
				}
			}
		}

		internal static void ServerTick(float dt)
		{
			if (!ModConfig.BossRaidEnabled.Value || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)EnvMan.instance == (Object)null)
			{
				return;
			}
			_timer += dt;
			if (!(_timer < 60f))
			{
				_timer = 0f;
				string s = default(string);
				if (ZoneSystem.instance.GetGlobalKey("mmo_bossraid_cd", ref s) && int.TryParse(s, out var result) && EnvMan.instance.GetDay() >= result + Mathf.Max(0, ModConfig.BossRaidCooldownDays.Value))
				{
					ZoneSystem.instance.RemoveGlobalKey("mmo_bossraid_cd");
				}
			}
		}
	}
	[HarmonyPatch(typeof(RandEventSystem), "Start")]
	internal static class RandEventSystem_Start_BossRaidPatch
	{
		private static void Postfix(RandEventSystem __instance)
		{
			BossRaids.Inject(__instance);
		}
	}
	[HarmonyPatch(typeof(Game), "Start")]
	internal static class Game_Start_BossRaidPatch
	{
		private static void Postfix()
		{
			BossRaids.Register();
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	internal static class Character_OnDeath_BossRaidPatch
	{
		private static void Prefix(Character __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.m_nview == (Object)null) && __instance.m_nview.IsValid() && __instance.m_nview.IsOwner())
			{
				BossRaids.OnCharacterDeath(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(RandEventSystem), "SetRandomEvent")]
	internal static class RandEventSystem_SetRandomEvent_BossRaidPatch
	{
		private static void Postfix(RandomEvent ev)
		{
			BossRaids.OnEventStarted(ev);
		}
	}
	[HarmonyPatch(typeof(ZNet), "Update")]
	internal static class ZNet_Update_BossRaidPatch
	{
		private static void Postfix()
		{
			BossRaids.ServerTick(Time.deltaTime);
		}
	}
	internal sealed class BossScaling : MonoBehaviour
	{
		private const string ZdoBaseHp = "mmo_boss_basehp";

		private const string ZdoPlayers = "mmo_boss_players";

		private Character _c;

		private float _timer;

		internal static void Attach(Character c)
		{
			if (!((Object)(object)c == (Object)null) && ModConfig.BossScalingEnabled.Value && (Object)(object)((Component)c).GetComponent<BossScaling>() == (Object)null)
			{
				((Component)c).gameObject.AddComponent<BossScaling>();
			}
		}

		private void Awake()
		{
			_c = ((Component)this).GetComponent<Character>();
		}

		private void Update()
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			_timer += Time.deltaTime;
			if (_timer < 5f)
			{
				return;
			}
			_timer = 0f;
			if ((Object)(object)_c == (Object)null || (Object)(object)_c.m_nview == (Object)null || !_c.m_nview.IsValid() || !_c.m_nview.IsOwner() || _c.IsDead())
			{
				return;
			}
			ZDO zDO = _c.m_nview.GetZDO();
			float num = zDO.GetFloat("mmo_boss_basehp", 0f);
			if (num <= 0f)
			{
				num = _c.GetMaxHealth();
				zDO.Set("mmo_boss_basehp", num);
			}
			int num2 = CountPlayersNear(((Component)this).transform.position, ModConfig.BossScaleRadius.Value);
			if (num2 < 1)
			{
				num2 = 1;
			}
			float num3 = num * (1f + ModConfig.BossScalePerPlayer.Value * (float)(num2 - 1));
			float maxHealth = _c.GetMaxHealth();
			if (!(Mathf.Abs(num3 - maxHealth) < 1f))
			{
				float num4 = ((maxHealth > 0f) ? Mathf.Clamp01(_c.GetHealth() / maxHealth) : 1f);
				_c.SetMaxHealth(num3);
				_c.SetHealth(num3 * num4);
				int num5 = zDO.GetInt("mmo_boss_players", 1);
				zDO.Set("mmo_boss_players", num2);
				if (num5 != num2)
				{
					Plugin.Log.LogInfo((object)$"[Boss] {_c.m_name}: {num2} jogador(es) no raio, vida maxima {maxHealth:0} -> {num3:0}.");
				}
			}
		}

		private static int CountPlayersNear(Vector3 pos, float radius)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			float num2 = radius * radius;
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if ((Object)(object)allPlayer != (Object)null && !((Character)allPlayer).IsDead())
				{
					Vector3 val = ((Component)allPlayer).transform.position - pos;
					if (((Vector3)(ref val)).sqrMagnitude <= num2)
					{
						num++;
					}
				}
			}
			return num;
		}
	}
	[HarmonyPatch(typeof(Character), "Awake")]
	internal static class Character_Awake_BossScalingPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(Character __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !__instance.IsPlayer() && __instance.m_boss && (ModConfig.BossScaleVanilla.Value || DungeonBosses.IsDungeonBoss(__instance, out var _) || WorldBoss.IsWorldBoss(__instance, out var _)))
			{
				BossScaling.Attach(__instance);
			}
		}
	}
	internal sealed class DungeonTier
	{
		public int Id;

		public string Title;

		public Theme Themes;

		public string Creature;

		public bool EquipsItems;

		public string[] WeaponChoices;

		public string Shield;

		public string BossEvent;

		public float Health;

		public string GoldReferenceItem;

		public bool IsCamp;
	}
	internal static class DungeonBosses
	{
		internal sealed class DeferredEquip : MonoBehaviour
		{
			public string Items;

			private void Start()
			{
				Humanoid component = ((Component)this).GetComponent<Humanoid>();
				if ((Object)(object)component != (Object)null && (Object)(object)((Character)component).m_nview != (Object)null && ((Character)component).m_nview.IsValid())
				{
					GiveItems(component, Items);
				}
				Object.Destroy((Object)(object)this);
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Awake")]
		private static class ItemDrop_Awake_CoinStackPatch
		{
			private static void Postfix(ItemDrop __instance)
			{
				if (_pendingStacks.Count != 0 && !((Object)(object)__instance == (Object)null) && !(((Object)((Component)__instance).gameObject).name.Replace("(Clone)", "") != "Coins"))
				{
					int stack = _pendingStacks.Dequeue();
					__instance.m_itemData.m_stack = stack;
					if ((Object)(object)__instance.m_nview != (Object)null && __instance.m_nview.IsValid())
					{
						__instance.Save();
					}
				}
			}
		}

		public const string ZdoTier = "mmo_dboss";

		public const string ZdoItems = "mmo_dboss_items";

		public const string ZdoDungeon = "mmo_dboss_dungeon";

		public const string DngTier = "mmo_dtier";

		public const string DngPos = "mmo_dboss_pos";

		public const string DngItems = "mmo_dboss_items";

		public const string DngDeadDay = "mmo_dboss_dead_day";

		internal static readonly DungeonTier[] Tiers = new DungeonTier[6]
		{
			new DungeonTier
			{
				Id = 1,
				Title = "Senhor da Cripta",
				Themes = (Theme)9,
				Creature = "Skeleton",
				EquipsItems = true,
				WeaponChoices = new string[2] { "SwordBronze", "MaceBronze" },
				Shield = "ShieldBronzeBuckler",
				BossEvent = "boss_gdking",
				Health = 800f,
				GoldReferenceItem = "SwordBronze"
			},
			new DungeonTier
			{
				Id = 2,
				Title = "Rei Afogado",
				Themes = (Theme)2,
				Creature = "Draugr_Elite",
				EquipsItems = true,
				WeaponChoices = new string[2] { "SwordIron", "AxeIron" },
				Shield = "ShieldBanded",
				BossEvent = "boss_bonemass",
				Health = 1600f,
				GoldReferenceItem = "SwordIron"
			},
			new DungeonTier
			{
				Id = 3,
				Title = "Anciao do Gelo",
				Themes = (Theme)4,
				Creature = "Fenring_Cultist",
				EquipsItems = false,
				WeaponChoices = Array.Empty<string>(),
				BossEvent = "boss_moder",
				Health = 2500f,
				GoldReferenceItem = "ArmorWolfChest"
			},
			new DungeonTier
			{
				Id = 4,
				Title = "Chefe Fuling",
				Themes = (Theme)16,
				Creature = "Goblin",
				EquipsItems = true,
				WeaponChoices = new string[2] { "SwordBlackmetal", "MaceNeedle" },
				Shield = "ShieldBlackmetal",
				BossEvent = "boss_goblinking",
				Health = 3500f,
				GoldReferenceItem = "SwordBlackmetal",
				IsCamp = true
			},
			new DungeonTier
			{
				Id = 5,
				Title = "Mestre de Forja",
				Themes = (Theme)128,
				Creature = "Dverger",
				EquipsItems = true,
				WeaponChoices = new string[2] { "CrossbowArbalest", "StaffFireball" },
				BossEvent = "boss_seekerqueen",
				Health = 4500f,
				GoldReferenceItem = "StaffFireball"
			},
			new DungeonTier
			{
				Id = 6,
				Title = "Campeao Carbonizado",
				Themes = (Theme)12288,
				Creature = "Charred_Melee",
				EquipsItems = true,
				WeaponChoices = new string[1] { "THSwordSlayer" },
				BossEvent = "boss_fader",
				Health = 5500f,
				GoldReferenceItem = "THSwordSlayer",
				IsCamp = true
			}
		};

		private static readonly Queue<int> _pendingStacks = new Queue<int>();

		public static DungeonTier TierFor(Theme themes)
		{
			//IL_000f: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			DungeonTier[] tiers = Tiers;
			foreach (DungeonTier dungeonTier in tiers)
			{
				if ((dungeonTier.Themes & themes) != 0)
				{
					return dungeonTier;
				}
			}
			return null;
		}

		public static DungeonTier TierById(int id)
		{
			DungeonTier[] tiers = Tiers;
			foreach (DungeonTier dungeonTier in tiers)
			{
				if (dungeonTier.Id == id)
				{
					return dungeonTier;
				}
			}
			return null;
		}

		public static bool IsDungeonBoss(Character c, out DungeonTier tier)
		{
			tier = null;
			ZDO val = (((Object)(object)c?.m_nview != (Object)null && c.m_nview.IsValid()) ? c.m_nview.GetZDO() : null);
			if (val == null)
			{
				return false;
			}
			int num = val.GetInt("mmo_dboss", 0);
			if (num <= 0)
			{
				return false;
			}
			tier = TierById(num);
			return tier != null;
		}

		public static bool SpawnFor(DungeonGenerator gen, List<Room> rooms)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.DungeonBossesEnabled.Value || (Object)(object)gen == (Object)null || rooms == null || rooms.Count == 0)
			{
				return false;
			}
			DungeonTier dungeonTier = TierFor(gen.m_themes);
			if (dungeonTier == null)
			{
				return false;
			}
			if (dungeonTier.IsCamp && !ModConfig.DungeonIncludeCamps.Value)
			{
				return false;
			}
			Room val = null;
			foreach (Room room in rooms)
			{
				if ((Object)(object)room != (Object)null && room.m_entrance)
				{
					val = room;
					break;
				}
			}
			Vector3 val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform.position : ((Component)rooms[0]).transform.position);
			Room val3 = null;
			float num = -1f;
			foreach (Room room2 in rooms)
			{
				if (!((Object)(object)room2 == (Object)null) && !room2.m_entrance && !room2.m_endCap)
				{
					Vector3 val4 = ((Component)room2).transform.position - val2;
					float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
					if (sqrMagnitude > num)
					{
						num = sqrMagnitude;
						val3 = room2;
					}
				}
			}
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = rooms[rooms.Count - 1];
			}
			Vector3 val5 = ((Component)val3).transform.position + Vector3.up * 1.5f;
			RaycastHit val6 = default(RaycastHit);
			if (Physics.Raycast(val5 + Vector3.up * 2f, Vector3.down, ref val6, 12f, LayerMask.GetMask(new string[4] { "piece", "terrain", "static_solid", "Default" })))
			{
				val5 = ((RaycastHit)(ref val6)).point + Vector3.up * 0.2f;
			}
			string error;
			return Spawn(dungeonTier, val5, out error, null, gen.m_nview);
		}

		public static bool Spawn(DungeonTier tier, Vector3 pos, out string error, string presetItems = null, ZNetView dungeonView = null)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			error = null;
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(tier.Creature) : null);
			if ((Object)(object)val == (Object)null)
			{
				error = "criatura '" + tier.Creature + "' nao encontrada";
				return false;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, pos, Quaternion.Euler(0f, Random.Range(0f, 360f), 0f));
			Character component = val2.GetComponent<Character>();
			ZNetView component2 = val2.GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || !component2.IsValid())
			{
				error = "prefab sem Character/ZNetView";
				Object.Destroy((Object)(object)val2);
				return false;
			}
			string text = presetItems;
			if (text == null)
			{
				text = "";
				if (tier.EquipsItems && tier.WeaponChoices.Length != 0)
				{
					string text2 = tier.WeaponChoices[Random.Range(0, tier.WeaponChoices.Length)];
					text = (string.IsNullOrEmpty(tier.Shield) ? text2 : (text2 + "|" + tier.Shield));
				}
			}
			ZDO zDO = component2.GetZDO();
			zDO.Set("mmo_dboss", tier.Id);
			zDO.Set("mmo_dboss_items", text);
			zDO.Persistent = true;
			if ((Object)(object)dungeonView != (Object)null && dungeonView.IsValid())
			{
				ZDO zDO2 = dungeonView.GetZDO();
				zDO.Set("mmo_dboss_dungeon", zDO2.m_uid);
				zDO2.Set("mmo_dtier", tier.Id);
				zDO2.Set("mmo_dboss_pos", pos);
				zDO2.Set("mmo_dboss_items", text);
				zDO2.Set("mmo_dboss_dead_day", 0);
				if ((Object)(object)((Component)dungeonView).GetComponent<DungeonResetter>() == (Object)null)
				{
					((Component)dungeonView).gameObject.AddComponent<DungeonResetter>();
				}
			}
			int num = Mathf.Clamp(ModConfig.DungeonBossStars.Value, 0, 2);
			component.SetLevel(num + 1);
			float num2 = tier.Health * Mathf.Max(0.1f, ModConfig.DungeonBossHpMultiplier.Value);
			component.SetMaxHealth(num2);
			component.SetHealth(num2);
			ApplyPresentation(component, tier);
			Humanoid val3 = (Humanoid)(object)((component is Humanoid) ? component : null);
			if (val3 != null)
			{
				GiveItems(val3, text);
			}
			Plugin.Log.LogInfo((object)$"[Dungeon] Boss '{tier.Title}' ({tier.Creature}) em {pos}, vida {num2:0}, itens '{text}'.");
			return true;
		}

		internal static void ApplyPresentation(Character c, DungeonTier tier)
		{
			c.m_boss = true;
			c.m_name = tier.Title;
			c.m_bossEvent = tier.BossEvent;
			BossScaling.Attach(c);
		}

		internal static void GiveItems(Humanoid h, string items)
		{
			if ((Object)(object)h == (Object)null || string.IsNullOrEmpty(items))
			{
				return;
			}
			Inventory inventory = h.GetInventory();
			if (inventory == null)
			{
				return;
			}
			int num = Mathf.Max(1, ModConfig.DungeonBossItemQuality.Value);
			string[] array = items.Split('|');
			foreach (string text in array)
			{
				if (string.IsNullOrEmpty(text) || inventory.ContainsItemByName(text))
				{
					continue;
				}
				ItemData val = inventory.AddItem(text, 1, num, 0, 0L, "", false);
				if (val == null)
				{
					Plugin.Log.LogWarning((object)("[Dungeon] Nao foi possivel dar '" + text + "' ao boss."));
					continue;
				}
				try
				{
					h.EquipItem(val, false);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[Dungeon] Equipar '" + text + "' em " + ((Character)h).m_name + ": " + ex.Message));
				}
			}
		}

		internal static void GiveItemsDeferred(Humanoid h, string items)
		{
			if (!((Object)(object)h == (Object)null) && !string.IsNullOrEmpty(items))
			{
				(((Component)h).gameObject.GetComponent<DeferredEquip>() ?? ((Component)h).gameObject.AddComponent<DeferredEquip>()).Items = items;
			}
		}

		public static int GoldFor(DungeonTier tier)
		{
			int num = MerchantPricing.PriceOf(tier.GoldReferenceItem);
			return Mathf.Max(10, Mathf.RoundToInt((float)num * ModConfig.DungeonBossGoldRatio.Value));
		}

		internal static void DropGold(Character c, DungeonTier tier)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab("Coins") : null);
			if (!((Object)(object)val == (Object)null))
			{
				int num = GoldFor(tier);
				int num2 = Mathf.Max(1, val.GetComponent<ItemDrop>()?.m_itemData.m_shared.m_maxStackSize ?? 999);
				List<KeyValuePair<GameObject, int>> list = new List<KeyValuePair<GameObject, int>>();
				while (num > 0)
				{
					int num3 = Mathf.Min(num2, num);
					list.Add(new KeyValuePair<GameObject, int>(val, 1));
					num -= num3;
					_pendingStacks.Enqueue(num3);
				}
				CharacterDrop.DropItems(list, c.GetCenterPoint(), 0.7f);
			}
		}
	}
	[HarmonyPatch(typeof(DungeonGenerator), "Generate", new Type[]
	{
		typeof(int),
		typeof(SpawnMode)
	})]
	internal static class DungeonGenerator_Generate_Patch
	{
		internal static SpawnMode CurrentMode;

		internal static bool Generating;

		private static void Prefix(SpawnMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			CurrentMode = mode;
			Generating = true;
		}

		private static void Postfix()
		{
			Generating = false;
		}
	}
	[HarmonyPatch(typeof(DungeonGenerator), "Save")]
	internal static class DungeonGenerator_Save_Patch
	{
		private static void Postfix(DungeonGenerator __instance)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (!DungeonGenerator_Generate_Patch.Generating || (int)DungeonGenerator_Generate_Patch.CurrentMode != 0)
			{
				return;
			}
			try
			{
				DungeonBosses.SpawnFor(__instance, new List<Room>(DungeonGenerator.m_placedRooms));
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"[Dungeon] Falha ao spawnar boss: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(Character), "Awake")]
	internal static class Character_Awake_DungeonBossPatch
	{
		private static void Postfix(Character __instance)
		{
			if (DungeonBosses.IsDungeonBoss(__instance, out var tier))
			{
				DungeonBosses.ApplyPresentation(__instance, tier);
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "Awake")]
	internal static class Humanoid_Awake_DungeonBossPatch
	{
		private static void Postfix(Humanoid __instance)
		{
			if (DungeonBosses.IsDungeonBoss((Character)(object)__instance, out var _))
			{
				string items = ((Character)__instance).m_nview.GetZDO().GetString("mmo_dboss_items", "");
				DungeonBosses.GiveItemsDeferred(__instance, items);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	internal static class Character_OnDeath_DungeonBossPatch
	{
		private static void Prefix(Character __instance)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid() || !__instance.m_nview.IsOwner() || !DungeonBosses.IsDungeonBoss(__instance, out var tier))
			{
				return;
			}
			if (!tier.EquipsItems)
			{
				DungeonBosses.DropGold(__instance, tier);
			}
			ZDOID zDOID = __instance.m_nview.GetZDO().GetZDOID("mmo_dboss_dungeon");
			if (((ZDOID)(ref zDOID)).IsNone())
			{
				return;
			}
			DungeonGenerator[] array = Object.FindObjectsByType<DungeonGenerator>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				ZNetView nview = array[i].m_nview;
				if (!((Object)(object)nview == (Object)null) && nview.IsValid() && !(nview.GetZDO().m_uid != zDOID))
				{
					nview.GetZDO().Set("mmo_dboss_dead_day", Mathf.Max(1, (!((Object)(object)EnvMan.instance != (Object)null)) ? 1 : EnvMan.instance.GetDay()));
					Plugin.Log.LogInfo((object)$"[Dungeon] Boss '{tier.Title}' morto; reset em {ModConfig.DungeonResetDays.Value} dia(s).");
					break;
				}
			}
		}
	}
	internal sealed class DungeonResetter : MonoBehaviour
	{
		private DungeonGenerator _gen;

		private float _timer;

		private void Awake()
		{
			_gen = ((Component)this).GetComponent<DungeonGenerator>();
		}

		private void Update()
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			_timer += Time.deltaTime;
			if (_timer < 15f)
			{
				return;
			}
			_timer = 0f;
			int value = ModConfig.DungeonResetDays.Value;
			if (value <= 0 || (Object)(object)_gen == (Object)null)
			{
				return;
			}
			ZNetView nview = _gen.m_nview;
			if ((Object)(object)nview == (Object)null || !nview.IsValid() || !nview.IsOwner())
			{
				return;
			}
			ZDO zDO = nview.GetZDO();
			int num = zDO.GetInt("mmo_dtier", 0);
			int num2 = zDO.GetInt("mmo_dboss_dead_day", 0);
			if (num <= 0 || num2 <= 0 || (Object)(object)EnvMan.instance == (Object)null || EnvMan.instance.GetDay() < num2 + value)
			{
				return;
			}
			DungeonTier dungeonTier = DungeonBosses.TierById(num);
			if (dungeonTier != null)
			{
				Vector3 vec = zDO.GetVec3("mmo_dboss_pos", ((Component)this).transform.position);
				string presetItems = zDO.GetString("mmo_dboss_items", "");
				if (DungeonBosses.Spawn(dungeonTier, vec, out var error, presetItems, nview))
				{
					zDO.Set("mmo_dboss_dead_day", 0);
					Plugin.Log.LogInfo((object)("[Dungeon] Boss '" + dungeonTier.Title + "' renasceu."));
				}
				else
				{
					Plugin.Log.LogWarning((object)("[Dungeon] Reset falhou: " + error));
					zDO.Set("mmo_dboss_dead_day", 0);
				}
			}
		}
	}
	[HarmonyPatch(typeof(DungeonGenerator), "Load")]
	internal static class DungeonGenerator_Load_ResetPatch
	{
		private static void Postfix(DungeonGenerator __instance)
		{
			ZNetView val = __instance?.m_nview;
			if (!((Object)(object)val == (Object)null) && val.IsValid() && val.GetZDO().GetInt("mmo_dtier", 0) > 0 && (Object)(object)((Component)__instance).GetComponent<DungeonResetter>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<DungeonResetter>();
			}
		}
	}
	[HarmonyPatch(typeof(DungeonGenerator), "Spawn")]
	internal static class DungeonGenerator_Spawn_LateBossPatch
	{
		private static void Postfix(DungeonGenerator __instance)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.DungeonBossesEnabled.Value)
			{
				return;
			}
			ZNetView val = __instance?.m_nview;
			if ((Object)(object)val == (Object)null || !val.IsValid() || !val.IsOwner() || val.GetZDO().GetInt("mmo_dtier", 0) > 0)
			{
				return;
			}
			List<Room> list = new List<Room>(((Component)__instance).GetComponentsInChildren<Room>());
			if (list.Count != 0 && DungeonBosses.SpawnFor(__instance, list))
			{
				Plugin.Log.LogInfo((object)$"[Dungeon] Boss adicionado a dungeon antiga ({list.Count} salas) em {((Component)__instance).transform.position}.");
				if ((Object)(object)((Component)__instance).GetComponent<DungeonResetter>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<DungeonResetter>();
				}
			}
		}
	}
	internal sealed class WorldBossDef
	{
		public int Tier;

		public string Title;

		public string Creature;

		public string BossEvent;

		public float Health;

		public Biome Biomes;
	}
	internal static class WorldBoss
	{
		public const string ZdoTag = "mmo_wboss";

		private const string KeyNext = "mmo_wboss_next";

		private const string KeyAlive = "mmo_wboss_alive";

		private const string RpcSpawn = "ValheimMMO_WorldBossSpawn";

		private const string RpcAnnounce = "ValheimMMO_WorldBossAnnounce";

		private const string RpcDead = "ValheimMMO_WorldBossDead";

		internal static readonly WorldBossDef[] Defs = new WorldBossDef[6]
		{
			new WorldBossDef
			{
				Tier = 1,
				Title = "Troll Anciao",
				Creature = "Troll",
				BossEvent = "boss_gdking",
				Health = 3000f,
				Biomes = (Biome)9
			},
			new WorldBossDef
			{
				Tier = 2,
				Title = "Abominacao Primordial",
				Creature = "Abomination",
				BossEvent = "boss_bonemass",
				Health = 6000f,
				Biomes = (Biome)2
			},
			new WorldBossDef
			{
				Tier = 3,
				Title = "Colosso de Pedra",
				Creature = "StoneGolem",
				BossEvent = "boss_moder",
				Health = 8000f,
				Biomes = (Biome)4
			},
			new WorldBossDef
			{
				Tier = 4,
				Title = "Berserker Fuling",
				Creature = "GoblinBrute",
				BossEvent = "boss_goblinking",
				Health = 10000f,
				Biomes = (Biome)16
			},
			new WorldBossDef
			{
				Tier = 5,
				Title = "Devorador da Nevoa",
				Creature = "SeekerBrute",
				BossEvent = "boss_seekerqueen",
				Health = 12000f,
				Biomes = (Biome)512
			},
			new WorldBossDef
			{
				Tier = 6,
				Title = "Morgen Ancia",
				Creature = "Morgen",
				BossEvent = "boss_fader",
				Health = 15000f,
				Biomes = (Biome)32
			}
		};

		private static PinData _pin;

		private static float _timer;

		public static WorldBossDef ForBiome(Biome biome)
		{
			//IL_000f: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			WorldBossDef[] defs = Defs;
			foreach (WorldBossDef worldBossDef in defs)
			{
				if ((worldBossDef.Biomes & biome) != 0)
				{
					return worldBossDef;
				}
			}
			return Defs[0];
		}

		public static WorldBossDef ByTier(int tier)
		{
			WorldBossDef[] defs = Defs;
			foreach (WorldBossDef worldBossDef in defs)
			{
				if (worldBossDef.Tier == tier)
				{
					return worldBossDef;
				}
			}
			return null;
		}

		public static bool IsWorldBoss(Character c, out WorldBossDef def)
		{
			def = null;
			ZDO val = (((Object)(object)c?.m_nview != (Object)null && c.m_nview.IsValid()) ? c.m_nview.GetZDO() : null);
			if (val == null)
			{
				return false;
			}
			int num = val.GetInt("mmo_wboss", 0);
			if (num <= 0)
			{
				return false;
			}
			def = ByTier(num);
			return def != null;
		}

		public static int GoldFor(WorldBossDef def)
		{
			return Mathf.Max(1, Mathf.RoundToInt((float)(ModConfig.WorldBossGoldBase.Value * def.Tier)));
		}

		internal static void Register()
		{
			if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register("ValheimMMO_WorldBossSpawn", (Action<long>)OnSpawnRequest);
				ZRoutedRpc.instance.Register<string, Vector3>("ValheimMMO_WorldBossAnnounce", (Action<long, string, Vector3>)OnAnnounce);
				ZRoutedRpc.instance.Register<string>("ValheimMMO_WorldBossDead", (Action<long, string>)OnDead);
			}
		}

		private static int Today()
		{
			if (!((Object)(object)EnvMan.instance != (Object)null))
			{
				return 0;
			}
			return EnvMan.instance.GetDay();
		}

		private static int ReadDayKey(string key)
		{
			string s = default(string);
			if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey(key, ref s) && int.TryParse(s, out var result))
			{
				return result;
			}
			return -1;
		}

		private static void WriteDayKey(string key, int day)
		{
			ZoneSystem instance = ZoneSystem.instance;
			if (instance != null)
			{
				instance.SetGlobalKey($"{key} {day}");
			}
		}

		internal static void ServerTick(float dt)
		{
			if (!ModConfig.WorldBossEnabled.Value || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)EnvMan.instance == (Object)null)
			{
				return;
			}
			_timer += dt;
			if (_timer < 30f)
			{
				return;
			}
			_timer = 0f;
			int num = Mathf.Max(1, ModConfig.WorldBossIntervalDays.Value);
			int num2 = Today();
			int num3 = ReadDayKey("mmo_wboss_next");
			if (num3 < 0)
			{
				WriteDayKey("mmo_wboss_next", num2 + num);
				return;
			}
			int num4 = ReadDayKey("mmo_wboss_alive");
			if ((num4 >= 0 && num2 < num4 + num * 2) || num2 < num3)
			{
				return;
			}
			List<ZNetPeer> peers = ZNet.instance.GetPeers();
			List<long> list = new List<long>();
			foreach (ZNetPeer item in peers)
			{
				if (item != null && item.IsReady())
				{
					list.Add(item.m_uid);
				}
			}
			if (!ZNet.instance.IsDedicated() && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				list.Add(ZRoutedRpc.instance.GetServerPeerID());
			}
			if (list.Count != 0)
			{
				long num5 = list[Random.Range(0, list.Count)];
				WriteDayKey("mmo_wboss_next", num2 + num);
				WriteDayKey("mmo_wboss_alive", num2);
				if (num5 == ZRoutedRpc.instance.GetServerPeerID())
				{
					OnSpawnRequest(0L);
				}
				else
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(num5, "ValheimMMO_WorldBossSpawn", Array.Empty<object>());
				}
			}
		}

		internal static void SpawnNow()
		{
			OnSpawnRequest(0L);
		}

		private static void OnSpawnRequest(long sender)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_0098: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			float num = Random.value * MathF.PI * 2f;
			float num2 = Random.Range(150f, 200f);
			Vector3 val = ((Component)localPlayer).transform.position + new Vector3(Mathf.Cos(num) * num2, 0f, Mathf.Sin(num) * num2);
			float num3 = default(float);
			if (ZoneSystem.instance.GetGroundHeight(val, ref num3))
			{
				val.y = num3 + 0.5f;
			}
			WorldBossDef worldBossDef = ForBiome((Biome)((WorldGenerator.instance == null) ? 1 : ((int)WorldGenerator.instance.GetBiome(val))));
			GameObject prefab = ZNetScene.instance.GetPrefab(worldBossDef.Creature);
			if ((Object)(object)prefab == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[Chefe mundial] criatura '" + worldBossDef.Creature + "' nao encontrada."));
				return;
			}
			GameObject val2 = Object.Instantiate<GameObject>(prefab, val, Quaternion.identity);
			Character component = val2.GetComponent<Character>();
			ZNetView component2 = val2.GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || !component2.IsValid())
			{
				Object.Destroy((Object)(object)val2);
				return;
			}
			component2.GetZDO().Set("mmo_wboss", worldBossDef.Tier);
			component2.GetZDO().Persistent = true;
			component.SetLevel(3);
			float num4 = worldBossDef.Health * Mathf.Max(0.1f, ModConfig.WorldBossHpMultiplier.Value);
			component.SetMaxHealth(num4);
			component.SetHealth(num4);
			ApplyPresentation(component, worldBossDef);
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ValheimMMO_WorldBossAnnounce", new object[2] { worldBossDef.Title, val });
			Plugin.Log.LogInfo((object)$"[Chefe mundial] {worldBossDef.Title} ({worldBossDef.Creature}) em {val}, vida {num4:0}.");
		}

		internal static void ApplyPresentation(Character c, WorldBossDef def)
		{
			c.m_boss = true;
			c.m_name = def.Title;
			c.m_bossEvent = def.BossEvent;
			BossScaling.Attach(c);
		}

		private static void OnAnnounce(long sender, string title, Vector3 pos)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				((Character)localPlayer).Message((MessageType)2, "Um chefe mundial despertou: " + title + "!", 0, (Sprite)null);
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				if (_pin != null)
				{
					instance.RemovePin(_pin);
				}
				_pin = instance.AddPin(pos, (PinType)9, title, false, false, 0L, default(PlatformUserID));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Chefe mundial] pin: " + ex.Message));
			}
		}

		private static void OnDead(long sender, string title)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, title + " foi derrotado!", 0, (Sprite)null);
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance != (Object)null && _pin != null)
			{
				try
				{
					instance.RemovePin(_pin);
				}
				catch
				{
				}
				_pin = null;
			}
		}

		internal static void OnKilled(Character c, WorldBossDef def)
		{
			ZoneSystem instance = ZoneSystem.instance;
			if (instance != null)
			{
				instance.RemoveGlobalKey("mmo_wboss_alive");
			}
			ZRoutedRpc instance2 = ZRoutedRpc.instance;
			if (instance2 != null)
			{
				instance2.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ValheimMMO_WorldBossDead", new object[1] { def.Title });
			}
		}
	}
	[HarmonyPatch(typeof(Game), "Start")]
	internal static class Game_Start_WorldBossPatch
	{
		private static void Postfix()
		{
			WorldBoss.Register();
		}
	}
	[HarmonyPatch(typeof(ZNet), "Update")]
	internal static class ZNet_Update_WorldBossPatch
	{
		private static void Postfix()
		{
			WorldBoss.ServerTick(Time.deltaTime);
		}
	}
	[HarmonyPatch(typeof(Character), "Awake")]
	internal static class Character_Awake_WorldBossPatch
	{
		private static void Postfix(Character __instance)
		{
			if (WorldBoss.IsWorldBoss(__instance, out var def))
			{
				WorldBoss.ApplyPresentation(__instance, def);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	internal static class Character_OnDeath_WorldBossPatch
	{
		private static void Prefix(Character __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.m_nview == (Object)null) && __instance.m_nview.IsValid() && __instance.m_nview.IsOwner() && WorldBoss.IsWorldBoss(__instance, out var def))
			{
				WorldBoss.OnKilled(__instance, def);
			}
		}
	}
}
namespace ValheimMMO.Drops
{
	public static class EquipmentDrops
	{
		private static string[] _blacklistCache = Array.Empty<string>();

		private static string _blacklistRaw;

		private static Dictionary<string, string> _remap;

		private static string _remapRaw;

		private static readonly HashSet<string> _loggedSkips = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static Dictionary<string, string> Remap
		{
			get
			{
				string text = ModConfig.CreatureItemRemap.Value ?? "";
				if (_remap == null || text != _remapRaw)
				{
					_remapRaw = text;
					_remap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
					string[] array = text.Split(new char[3] { ',', ';', '\n' }, StringSplitOptions.RemoveEmptyEntries);
					foreach (string text2 in array)
					{
						int num = text2.IndexOf('=');
						if (num > 0)
						{
							string text3 = text2.Substring(0, num).Trim();
							string text4 = text2.Substring(num + 1).Trim();
							if (text3.Length > 0 && text4.Length > 0)
							{
								_remap[text3] = text4;
							}
						}
					}
				}
				return _remap;
			}
		}

		public static float ChanceFor(ItemType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected I4, but got Unknown
			switch (type - 3)
			{
			case 0:
			case 1:
			case 11:
			case 19:
				return ModConfig.WeaponDropChance.Value;
			case 2:
				return ModConfig.ShieldDropChance.Value;
			case 3:
			case 4:
			case 8:
			case 9:
			case 14:
				return ModConfig.ArmorDropChance.Value;
			case 12:
			case 16:
				return ModConfig.ToolDropChance.Value;
			case 6:
			case 20:
				return ModConfig.AmmoDropChance.Value;
			default:
				return 0f;
			}
		}

		private static bool IsBlacklisted(string prefabName)
		{
			string text = ModConfig.EquipDropPrefabBlacklist.Value ?? "";
			if (text != _blacklistRaw)
			{
				_blacklistRaw = text;
				_blacklistCache = text.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
				for (int i = 0; i < _blacklistCache.Length; i++)
				{
					_blacklistCache[i] = _blacklistCache[i].Trim();
				}
			}
			string[] blacklistCache = _blacklistCache;
			foreach (string text2 in blacklistCache)
			{
				if (text2.Length > 0 && string.Equals(text2, prefabName, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsDroppable(string prefabName)
		{
			return (Object)(object)DroppablePrefab(prefabName) != (Object)null;
		}

		public static GameObject DroppablePrefab(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName) || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(prefabName);
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			if ((Object)(object)prefab.GetComponent<ZNetView>() == (Object)null)
			{
				return null;
			}
			if ((Object)(object)prefab.GetComponent<ItemDrop>() == (Object)null)
			{
				return null;
			}
			return prefab;
		}

		public static string RemapFor(string prefabName)
		{
			if (prefabName == null || !Remap.TryGetValue(prefabName, out var value))
			{
				return null;
			}
			return value;
		}

		public static List<KeyValuePair<string, float>> RemapChoices(string prefabName)
		{
			List<KeyValuePair<string, float>> list = new List<KeyValuePair<string, float>>();
			string text = RemapFor(prefabName);
			if (text == null)
			{
				return list;
			}
			string[] array = text.Split('|');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				float result = 1f;
				int num = text2.IndexOf('*');
				if (num > 0)
				{
					if (!float.TryParse(text2.Substring(num + 1).Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out result))
					{
						result = 1f;
					}
					text2 = text2.Substring(0, num).Trim();
				}
				if (text2.Length > 0)
				{
					list.Add(new KeyValuePair<string, float>(text2, Mathf.Max(0f, result)));
				}
			}
			return list;
		}

		public static string PickRemap(string prefabName, int stars)
		{
			List<KeyValuePair<string, float>> list = RemapChoices(prefabName);
			if (list.Count == 0)
			{
				return null;
			}
			if (list.Count == 1)
			{
				return list[0].Key;
			}
			float num = 0f;
			foreach (KeyValuePair<string, float> item in list)
			{
				num += item.Value;
			}
			if (num <= 0f)
			{
				return list[0].Key;
			}
			float num2 = list[0].Value / num + (float)Mathf.Max(0, stars) * ModConfig.RemapStarBias.Value;
			num2 = Mathf.Clamp01(num2);
			float value = Random.value;
			if (value < num2)
			{
				return list[0].Key;
			}
			float num3 = num - list[0].Value;
			float num4 = (value - num2) / Mathf.Max(0.0001f, 1f - num2) * num3;
			for (int i = 1; i < list.Count; i++)
			{
				num4 -= list[i].Value;
				if (num4 <= 0f)
				{
					return list[i].Key;
				}
			}
			return list[list.Count - 1].Key;
		}

		public static GameObject ResolveDroppable(GameObject dropPrefab, int stars = 0)
		{
			if ((Object)(object)dropPrefab == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			if (RemapFor(((Object)dropPrefab).name) != null)
			{
				string text = PickRemap(((Object)dropPrefab).name, stars);
				GameObject val = DroppablePrefab(text);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
				LogSkipOnce(((Object)dropPrefab).name + ":" + text, "remap para '" + text + "' nao e um item de jogador valido (sem ZNetView/ItemDrop ou inexistente)");
				return null;
			}
			GameObject val2 = DroppablePrefab(((Object)dropPrefab).name);
			if ((Object)(object)val2 != (Object)null)
			{
				if (!ModConfig.DropOnlyPlayerItems.Value || IsPlayerItem(val2))
				{
					return val2;
				}
				LogSkipOnce(((Object)dropPrefab).name, "item de criatura sem receita -- para um de-para, adicione em CreatureItemRemap");
				return null;
			}
			LogSkipOnce(((Object)dropPrefab).name, "item interno da criatura sem entrada em CreatureItemRemap");
			return null;
		}

		public static bool IsPlayerItem(GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			string name = ((Object)prefab).name;
			if (CustomItems.IsCustom(name) || MapItem.IsMap(name))
			{
				return true;
			}
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)ObjectDB.instance.GetRecipe(component.m_itemData) != (Object)null)
			{
				return true;
			}
			Trader[] array = Resources.FindObjectsOfTypeAll<Trader>();
			foreach (Trader val in array)
			{
				if (val.m_items == null)
				{
					continue;
				}
				foreach (TradeItem item in val.m_items)
				{
					if ((Object)(object)item?.m_prefab != (Object)null && ((Object)((Component)item.m_prefab).gameObject).name == name)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static void LogSkipOnce(string name, string why)
		{
			if (ModConfig.LogSkippedInternalItems.Value && _loggedSkips.Add(name))
			{
				Plugin.Log.LogInfo((object)("[Drops] Ignorando '" + name + "': " + why + "."));
			}
		}

		public static List<KeyValuePair<GameObject, int>> BuildFor(Character character, List<KeyValuePair<GameObject, int>> existing)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Invalid comparison between Unknown and I4
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Invalid comparison between Unknown and I4
			List<KeyValuePair<GameObject, int>> list = new List<KeyValuePair<GameObject, int>>();
			if (!ModConfig.EquipmentDropsEnabled.Value)
			{
				return list;
			}
			if ((Object)(object)character == (Object)null || character.IsPlayer())
			{
				return list;
			}
			DungeonTier tier;
			bool flag = DungeonBosses.IsDungeonBoss(character, out tier);
			if (!flag && ModConfig.ExcludeBossesFromEquipDrops.Value && character.IsBoss())
			{
				return list;
			}
			Humanoid val = (Humanoid)(object)((character is Humanoid) ? character : null);
			if (val == null)
			{
				return list;
			}
			Inventory inventory = val.GetInventory();
			if (inventory == null)
			{
				return list;
			}
			int num = Math.Max(0, character.GetLevel() - 1);
			int num2 = ((!ModConfig.DropsScaleWithStars.Value) ? 1 : (1 + num));
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem?.m_shared == null || (Object)(object)allItem.m_dropPrefab == (Object)null)
				{
					continue;
				}
				float num3 = ChanceFor(allItem.m_shared.m_itemType);
				if (num3 <= 0f || IsBlacklisted(((Object)allItem.m_dropPrefab).name))
				{
					continue;
				}
				GameObject val2 = ResolveDroppable(allItem.m_dropPrefab, num);
				if ((Object)(object)val2 == (Object)null || IsBlacklisted(((Object)val2).name) || (!flag && Random.value > num3) || AlreadyListed(existing, val2) || AlreadyListed(list, val2))
				{
					continue;
				}
				int num4;
				int num5;
				if ((int)allItem.m_shared.m_itemType != 9)
				{
					num4 = (((int)allItem.m_shared.m_itemType == 23) ? 1 : 0);
					if (num4 == 0)
					{
						num5 = num2;
						goto IL_0189;
					}
				}
				else
				{
					num4 = 1;
				}
				num5 = Math.Max(1, allItem.m_stack);
				goto IL_0189;
				IL_0189:
				int num6 = num5;
				list.Add(new KeyValuePair<GameObject, int>(val2, num6));
				if (num4 == 0)
				{
					for (int i = 0; i < num6; i++)
					{
						float durabilityFraction = (flag ? 1f : Random.Range(ModConfig.DropDurabilityMin.Value, ModConfig.DropDurabilityMax.Value));
						DropPending.Enqueue(((Object)val2).name, durabilityFraction, (!flag) ? 1 : allItem.m_quality);
					}
				}
			}
			return list;
		}

		private static bool AlreadyListed(List<KeyValuePair<GameObject, int>> list, GameObject prefab)
		{
			if (list == null)
			{
				return false;
			}
			foreach (KeyValuePair<GameObject, int> item in list)
			{
				if ((Object)(object)item.Key == (Object)(object)prefab)
				{
					return true;
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CharacterDrop), "GenerateDropList")]
	internal static class CharacterDrop_GenerateDropList_Patch
	{
		private static void Postfix(CharacterDrop __instance, ref List<KeyValuePair<GameObject, int>> __result)
		{
			if (__result != null)
			{
				List<KeyValuePair<GameObject, int>> list = EquipmentDrops.BuildFor(__instance.m_character, __result);
				if (list.Count > 0)
				{
					__result.AddRange(list);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	internal static class Character_OnDeath_DropFallbackPatch
	{
		private static void Prefix(Character __instance)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance == (Object)null) && !__instance.IsPlayer() && !((Object)(object)__instance.m_nview == (Object)null) && __instance.m_nview.IsOwner() && !((Object)(object)((Component)__instance).GetComponent<CharacterDrop>() != (Object)null))
			{
				List<KeyValuePair<GameObject, int>> list = EquipmentDrops.BuildFor(__instance, null);
				if (list.Count != 0)
				{
					CharacterDrop.DropItems(list, __instance.GetCenterPoint(), 0.5f);
				}
			}
		}
	}
}
namespace ValheimMMO.Config
{
	public static class ModConfig
	{
		public static ConfigEntry<int> MaxLevel;

		public static ConfigEntry<int> PointsPerLevel;

		public static ConfigEntry<float> XpCurveFactor;

		public static ConfigEntry<float> XpCurveExponent;

		public static ConfigEntry<float> XpKillFactor;

		public static ConfigEntry<float> XpKillExponent;

		public static ConfigEntry<float> XpStarBonus;

		public static ConfigEntry<float> XpBossMultiplier;

		public static ConfigEntry<bool> XpRequiresOwnDamage;

		public static ConfigEntry<float> XpNearbyRadius;

		public static ConfigEntry<float> XpGlobalRate;

		public static ConfigEntry<float> GrowthHealthPerLevel;

		public static ConfigEntry<float> GrowthStaminaPerLevel;

		public static ConfigEntry<float> GrowthEitrPerLevel;

		public static ConfigEntry<float> HealthPerVitality;

		public static ConfigEntry<float> StaminaPerEndurance;

		public static ConfigEntry<float> EitrPerSpirit;

		public static ConfigEntry<float> CarryPerConditioning;

		public static ConfigEntry<float> GrowthCarryPerLevel;

		public static ConfigEntry<bool> ItemBonusesEnabled;

		public static ConfigEntry<bool> ShowItemBonusTooltip;

		public static ConfigEntry<float> ArmorToAttribute;

		public static ConfigEntry<float> BlockToAttribute;

		public static ConfigEntry<float> MeleeDamageToAttribute;

		public static ConfigEntry<float> RangedDamageToAttribute;

		public static ConfigEntry<float> MagicStaffBase;

		public static ConfigEntry<float> MagicStaffPerQuality;

		public static ConfigEntry<float> HeavyArmorMovementThreshold;

		public static ConfigEntry<bool> FoodGivesNoStats;

		public static ConfigEntry<float> DeathXpLossPercent;

		public static ConfigEntry<bool> DeathCanDelevel;

		public static ConfigEntry<bool> RespecEnabled;

		public static ConfigEntry<int> RespecMinComfort;

		public static ConfigEntry<bool> RespecRequiresShelter;

		public static ConfigEntry<bool> HungerEnabled;

		public static ConfigEntry<float> HungerMax;

		public static ConfigEntry<float> HungerDrainMinutes;

		public static ConfigEntry<float> SatietyPerBurnSecond;

		public static ConfigEntry<float> HungryThreshold;

		public static ConfigEntry<float> StarvingThreshold;

		public static ConfigEntry<float> HungryHealthRegenMult;

		public static ConfigEntry<float> HungryStaminaRegenMult;

		public static ConfigEntry<float> StarvingHealthRegenMult;

		public static ConfigEntry<float> StarvingStaminaRegenMult;

		public static ConfigEntry<float> StarvingEitrRegenMult;

		public static ConfigEntry<float> WellFedThreshold;

		public static ConfigEntry<float> WellFedRegenMult;

		public static ConfigEntry<float> StarvationDamage;

		public static ConfigEntry<float> StarvationDamageInterval;

		public static ConfigEntry<bool> StarvationCanKill;

		public static ConfigEntry<bool> EquipmentDropsEnabled;

		public static ConfigEntry<float> WeaponDropChance;

		public static ConfigEntry<float> ShieldDropChance;

		public static ConfigEntry<float> ArmorDropChance;

		public static ConfigEntry<float> ToolDropChance;

		public static ConfigEntry<float> AmmoDropChance;

		public static ConfigEntry<bool> DropsScaleWithStars;

		public static ConfigEntry<bool> ExcludeBossesFromEquipDrops;

		public static ConfigEntry<string> EquipDropPrefabBlacklist;

		public static ConfigEntry<string> CreatureItemRemap;

		public static ConfigEntry<bool> LogSkippedInternalItems;

		public static ConfigEntry<bool> DropOnlyPlayerItems;

		public static ConfigEntry<float> RemapStarBias;

		public static ConfigEntry<KeyboardShortcut> OpenPanelKey;

		public static ConfigEntry<bool> ShowHungerBar;

		public static ConfigEntry<bool> ShowXpBar;

		public static ConfigEntry<bool> ShowXpGainMessages;

		public static ConfigEntry<float> HungerBarOffsetX;

		public static ConfigEntry<float> HungerBarOffsetY;

		public static ConfigEntry<float> HungerBarWidth;

		public static ConfigEntry<float> XpBarOffsetX;

		public static ConfigEntry<float> XpBarOffsetY;

		public static ConfigEntry<float> XpBarWidth;

		public static ConfigEntry<bool> PanelOpensWithInventory;

		public static ConfigEntry<bool> SlotsEnabled;

		public static ConfigEntry<float> SlotsKgPerRow;

		public static ConfigEntry<int> SlotsMaxRows;

		public static ConfigEntry<bool> MerchantEnabled;

		public static ConfigEntry<string> MerchantPrefab;

		public static ConfigEntry<string> MerchantName;

		public static ConfigEntry<float> MerchantOffsetX;

		public static ConfigEntry<float> MerchantOffsetZ;

		public static ConfigEntry<float> MerchantPriceMultiplier;

		public static ConfigEntry<float> MerchantCraftMarkup;

		public static ConfigEntry<float> MerchantCraftBaseFee;

		public static ConfigEntry<float> MerchantStationLevelFee;

		public static ConfigEntry<float> MerchantConversionMarkup;

		public static ConfigEntry<float> MerchantCreatureDropExponent;

		public static ConfigEntry<float> MerchantTrophyMultiplier;

		public static ConfigEntry<float> MerchantGatheredBase;

		public static ConfigEntry<float> MerchantMinedBase;

		public static ConfigEntry<float> MerchantUnknownBase;

		public static ConfigEntry<int> MerchantMaterialStack;

		public static ConfigEntry<int> MerchantConsumableStack;

		public static ConfigEntry<bool> MerchantExcludeQuestItems;

		public static ConfigEntry<string> MerchantExcludePattern;

		public static ConfigEntry<string> MerchantBasePrices;

		public static ConfigEntry<string> MerchantPriceOverrides;

		public static ConfigEntry<bool> MerchantBuysItems;

		public static ConfigEntry<float> MerchantBuyRatio;

		public static ConfigEntry<bool> MerchantBuysMaterials;

		public static ConfigEntry<string> MerchantNoBuyPattern;

		public static ConfigEntry<int> MerchantInflationEveryDays;

		public static ConfigEntry<float> MerchantInflationPercent;

		public static ConfigEntry<float> MerchantInflationMaxMultiplier;

		public static ConfigEntry<bool> DungeonBossesEnabled;

		public static ConfigEntry<bool> DungeonIncludeCamps;

		public static ConfigEntry<float> DungeonBossHpMultiplier;

		public static ConfigEntry<int> DungeonBossStars;

		public static ConfigEntry<int> DungeonBossItemQuality;

		public static ConfigEntry<float> DungeonBossGoldRatio;

		public static ConfigEntry<float> XpDungeonBossMultiplier;

		public static ConfigEntry<float> DungeonBossMusicRange;

		public static ConfigEntry<float> PotionCooldown;

		public static ConfigEntry<float> ReturnStoneCooldownMultiplier;

		public static ConfigEntry<bool> ReturnStoneIgnoresOre;

		public static ConfigEntry<int> DungeonResetDays;

		public static ConfigEntry<bool> ShowPlayerLevels;

		public static ConfigEntry<bool> EquipmentRowEnabled;

		public static ConfigEntry<bool> VersionCheckEnabled;

		public static ConfigEntry<bool> VersionCheckExact;

		public static ConfigEntry<bool> ConfigSyncEnabled;

		public static ConfigEntry<bool> CityBuildings;

		public static ConfigEntry<float> CityRoofYawFix;

		public static ConfigEntry<float> CityMinDistance;

		public static ConfigEntry<float> CityMaxDistance;

		public static ConfigEntry<float> CityKeepAwayFromSpawn;

		public static ConfigEntry<bool> PvpEnabled;

		public static ConfigEntry<bool> StealthHidesName;

		public static ConfigEntry<float> KarmaPerKill;

		public static ConfigEntry<float> KarmaDeathLoss;

		public static ConfigEntry<float> KarmaDecayPerMinute;

		public static ConfigEntry<float> KarmaMonsterFactor;

		public static ConfigEntry<float> WantedThreshold;

		public static ConfigEntry<float> OutlawThreshold;

		public static ConfigEntry<float> BountyPerKarma;

		public static ConfigEntry<float> KarmaMax;

		public static ConfigEntry<bool> GuardsEnabled;

		public static ConfigEntry<int> GuardsPerCity;

		public static ConfigEntry<int> GuardStars;

		public static ConfigEntry<float> GuardHpMultiplier;

		public static ConfigEntry<bool> GuardScaleWithPlayers;

		public static ConfigEntry<bool> CitiesEnabled;

		public static ConfigEntry<string> CityAnchors;

		public static ConfigEntry<int> SpawnMerchantTier;

		public static ConfigEntry<bool> CitySellsLowerTiers;

		public static ConfigEntry<float> ImportMarkupPerTier;

		public static ConfigEntry<float> LocalBuyRatio;

		public static ConfigEntry<bool> CityPlaza;

		public static ConfigEntry<bool> CitySafeZone;

		public static ConfigEntry<float> CitySafeRadius;

		public static ConfigEntry<bool> CityPortals;

		public static ConfigEntry<bool> CityLevelTerrain;

		public static ConfigEntry<float> CityLevelRadius;

		public static ConfigEntry<string> MaterialTiers;

		public static ConfigEntry<bool> WorldBossEnabled;

		public static ConfigEntry<int> WorldBossIntervalDays;

		public static ConfigEntry<float> WorldBossHpMultiplier;

		public static ConfigEntry<int> WorldBossGoldBase;

		public static ConfigEntry<bool> BankEnabled;

		public static ConfigEntry<int> BankRows;

		public static ConfigEntry<bool> BossRaidEnabled;

		public static ConfigEntry<int> BossRaidCooldownDays;

		public static ConfigEntry<float> BossRaidMinDuration;

		public static ConfigEntry<bool> BossScalingEnabled;

		public static ConfigEntry<float> BossScalePerPlayer;

		public static ConfigEntry<float> BossScaleRadius;

		public static ConfigEntry<bool> BossScaleVanilla;

		public static ConfigEntry<float> DropDurabilityMin;

		public static ConfigEntry<float> DropDurabilityMax;

		public static ConfigEntry<bool> HungerStatusIcons;

		public static ConfigEntry<float> RepairCostRatio;

		public static ConfigEntry<float> UpgradeCostFactor;

		public static ConfigEntry<int> ExtraQualityLevels;

		public static ConfigEntry<bool> QuestsEnabled;

		public static ConfigEntry<float> QuestRewardMultiplier;

		public static ConfigEntry<int> QuestMaxActive;

		public static ConfigEntry<bool> QuestTrackerEnabled;

		public static ConfigEntry<float> QuestTrackerOffsetX;

		public static ConfigEntry<float> QuestTrackerOffsetY;

		public static ConfigEntry<int> MapPrice;

		public static ConfigEntry<float> MapRevealRadius;

		public static ConfigEntry<float> MapWorldRadius;

		public static ConfigEntry<float> MapBossDropChance;

		public static ConfigEntry<bool> BowTweaksEnabled;

		public static ConfigEntry<float> BowDrawTimeMultiplier;

		public static ConfigEntry<float> BowDrawStaminaMultiplier;

		public static ConfigEntry<float> BowAttackStaminaMultiplier;

		public static ConfigEntry<float> BowProjectileSpeedMultiplier;

		public static ConfigEntry<float> BowDamageMultiplier;

		public static ConfigEntry<float> CrossbowReloadMultiplier;

		public static void Bind(ConfigFile cfg)
		{
			//IL_0770: Unknown result type (might be due to invalid IL or missing references)
			MaxLevel = cfg.Bind<int>("1 - Progressao", "MaxLevel", 60, "Level maximo alcancavel.");
			PointsPerLevel = cfg.Bind<int>("1 - Progressao", "PointsPerLevel", 3, "Pontos de atributo concedidos por level.");
			XpCurveFactor = cfg.Bind<float>("1 - Progressao", "XpCurveFactor", 50f, "A na formula: XP_para_proximo_level = A * level^B.");
			XpCurveExponent = cfg.Bind<float>("1 - Progressao", "XpCurveExponent", 1.5f, "B na formula: XP_para_proximo_level = A * level^B.");
			XpKillFactor = cfg.Bind<float>("2 - XP por abate", "XpKillFactor", 2f, "K na formula: XP = K * vidaBase^E * multEstrela * multBoss.");
			XpKillExponent = cfg.Bind<float>("2 - XP por abate", "XpKillExponent", 0.75f, "E na formula de XP. Abaixo de 1 impede que criaturas gigantes dominem a curva.");
			XpStarBonus = cfg.Bind<float>("2 - XP por abate", "XpStarBonus", 0.5f, "Bonus de XP por estrela da criatura. 0.5 = mais 50 por cento por estrela.");
			XpBossMultiplier = cfg.Bind<float>("2 - XP por abate", "XpBossMultiplier", 5f, "Multiplicador de XP para bosses.");
			XpRequiresOwnDamage = cfg.Bind<bool>("2 - XP por abate", "XpRequiresOwnDamage", true, "Exige que voce tenha causado dano na criatura para receber XP. Se false, todo jogador dentro de XpNearbyRadius da morte recebe.");
			XpNearbyRadius = cfg.Bind<float>("2 - XP por abate", "XpNearbyRadius", 60f, "Raio em metros para XP de proximidade, usado apenas quando XpRequiresOwnDamage = false.");
			XpGlobalRate = cfg.Bind<float>("2 - XP por abate", "XpGlobalRate", 1f, "Multiplicador global de XP. Use para acelerar ou desacelerar o servidor inteiro.");
			GrowthHealthPerLevel = cfg.Bind<float>("3 - Crescimento automatico por level", "HealthPerLevel", 1.5f, "Vida maxima ganha por level, sem gastar ponto.");
			GrowthStaminaPerLevel = cfg.Bind<float>("3 - Crescimento automatico por level", "StaminaPerLevel", 1.6f, "Stamina maxima ganha por level, sem gastar ponto.");
			GrowthEitrPerLevel = cfg.Bind<float>("3 - Crescimento automatico por level", "EitrPerLevel", 0.8f, "Eitr maximo ganho por level, sem gastar ponto.");
			HealthPerVitality = cfg.Bind<float>("4 - Ganho por ponto distribuido", "HealthPerVitality", 1f, "Vida maxima por ponto de Vitalidade.");
			StaminaPerEndurance = cfg.Bind<float>("4 - Ganho por ponto distribuido", "StaminaPerEndurance", 0.9f, "Stamina maxima por ponto de Resistencia.");
			EitrPerSpirit = cfg.Bind<float>("4 - Ganho por ponto distribuido", "EitrPerSpirit", 1f, "Eitr maximo por ponto de Espirito.");
			CarryPerConditioning = cfg.Bind<float>("4 - Ganho por ponto distribuido", "CarryKgPerConditioning", 4f, "Quilos de carga por ponto de Condicionamento. Base do jogo: 300 kg; cinto Megingjord: +150.");
			GrowthCarryPerLevel = cfg.Bind<float>("3 - Crescimento automatico por level", "CarryKgPerLevel", 1f, "Quilos de carga ganhos por level, sem gastar ponto.");
			ItemBonusesEnabled = cfg.Bind<bool>("12 - Atributos em itens", "Enabled", true, "Itens equipados concedem pontos de atributo derivados dos proprios stats (armor, bloqueio, dano).");
			ShowItemBonusTooltip = cfg.Bind<bool>("12 - Atributos em itens", "ShowInTooltip", true, "Mostra o bonus no tooltip do item.");
			ArmorToAttribute = cfg.Bind<float>("12 - Atributos em itens", "ArmorToAttribute", 0.25f, "Pontos por unidade de armor em capacete/peito/pernas/capa. Ex.: carapaca 32 -> 8.");
			BlockToAttribute = cfg.Bind<float>("12 - Atributos em itens", "BlockToAttribute", 0.1f, "Pontos de Vitalidade por unidade de bloqueio de escudos. Ex.: metal negro 78 -> 8.");
			MeleeDamageToAttribute = cfg.Bind<float>("12 - Atributos em itens", "MeleeDamageToAttribute", 0.08f, "Pontos de Resistencia por unidade de dano total de armas corpo a corpo. Ex.: espada de bronze 35 -> 3.");
			RangedDamageToAttribute = cfg.Bind<float>("12 - Atributos em itens", "RangedDamageToAttribute", 0.06f, "Pontos de Resistencia por unidade de dano de arcos e bestas. Menor porque besta tem dano por tiro alto.");
			MagicStaffBase = cfg.Bind<float>("12 - Atributos em itens", "MagicStaffBase", 6f, "Pontos de Espirito de um cajado na qualidade 1. O dano do cajado esta no projetil, entao nao serve de base.");
			MagicStaffPerQuality = cfg.Bind<float>("12 - Atributos em itens", "MagicStaffPerQuality", 2f, "Pontos de Espirito extras por nivel de qualidade do cajado.");
			HeavyArmorMovementThreshold = cfg.Bind<float>("12 - Atributos em itens", "HeavyArmorMovementThreshold", -0.05f, "Armadura com penalidade de movimento igual ou pior que isto conta como pesada (Vitalidade). Acima disso, leve (Resistencia).");
			FoodGivesNoStats = cfg.Bind<bool>("5 - Comida", "FoodGivesNoStats", true, "Comida deixa de dar vida, stamina e eitr maximos. Desligue para rodar o mod em modo aditivo.");
			DeathXpLossPercent = cfg.Bind<float>("6 - Morte", "XpLossPercent", 10f, "Percentual do XP do level atual perdido ao morrer.");
			DeathCanDelevel = cfg.Bind<bool>("6 - Morte", "CanDelevel", true, "Se a perda de XP pode regredir o level. Pontos excedentes sao devolvidos automaticamente.");
			RespecEnabled = cfg.Bind<bool>("7 - Respec", "Enabled", true, "Permite redistribuir pontos ja gastos.");
			RespecRequiresShelter = cfg.Bind<bool>("7 - Respec", "RequiresShelter", true, "Respec exige estar sob abrigo.");
			RespecMinComfort = cfg.Bind<int>("7 - Respec", "MinComfort", 1, "Nivel minimo de conforto para dar respec. 0 desativa a exigencia.");
			HungerEnabled = cfg.Bind<bool>("8 - Fome", "Enabled", true, "Ativa o sistema de fome.");
			HungerMax = cfg.Bind<float>("8 - Fome", "Max", 100f, "Saciedade maxima.");
			HungerDrainMinutes = cfg.Bind<float>("8 - Fome", "DrainMinutes", 30f, "Minutos para ir de saciedade cheia a zero.");
			SatietyPerBurnSecond = cfg.Bind<float>("8 - Fome", "SatietyPerBurnSecond", 0.05f, "Saciedade ganha por segundo de m_foodBurnTime da comida. Comida melhor dura mais, logo enche mais.");
			HungryThreshold = cfg.Bind<float>("8 - Fome", "HungryThreshold", 60f, "Abaixo desta saciedade entra o estado Com Fome.");
			StarvingThreshold = cfg.Bind<float>("8 - Fome", "StarvingThreshold", 30f, "Abaixo desta saciedade entra o estado Faminto.");
			HungryHealthRegenMult = cfg.Bind<float>("8 - Fome", "HungryHealthRegen", 0.5f, "Multiplicador de regeneracao de vida no estado Com Fome.");
			HungryStaminaRegenMult = cfg.Bind<float>("8 - Fome", "HungryStaminaRegen", 0.8f, "Multiplicador de regeneracao de stamina no estado Com Fome.");
			StarvingHealthRegenMult = cfg.Bind<float>("8 - Fome", "StarvingHealthRegen", 0f, "Multiplicador de regeneracao de vida no estado Faminto.");
			StarvingStaminaRegenMult = cfg.Bind<float>("8 - Fome", "StarvingStaminaRegen", 0.5f, "Multiplicador de regeneracao de stamina no estado Faminto.");
			StarvingEitrRegenMult = cfg.Bind<float>("8 - Fome", "StarvingEitrRegen", 0.5f, "Multiplicador de regeneracao de eitr no estado Faminto.");
			WellFedThreshold = cfg.Bind<float>("8 - Fome", "WellFedThreshold", 90f, "Saciedade a partir da qual o estado Bem Alimentado da bonus de regeneracao.");
			WellFedRegenMult = cfg.Bind<float>("8 - Fome", "WellFedRegen", 1.1f, "Multiplicador de regeneracao de vida e stamina no estado Bem Alimentado.");
			StarvationDamage = cfg.Bind<float>("8 - Fome", "StarvationDamage", 1f, "Dano por tick com a saciedade zerada.");
			StarvationDamageInterval = cfg.Bind<float>("8 - Fome", "StarvationDamageInterval", 5f, "Segundos entre ticks de dano de inanicao.");
			StarvationCanKill = cfg.Bind<bool>("8 - Fome", "CanKill", true, "Se a inanicao pode matar o personagem.");
			EquipmentDropsEnabled = cfg.Bind<bool>("9 - Drop de equipamento", "Enabled", true, "Criaturas dropam o equipamento que estavam efetivamente usando.");
			WeaponDropChance = cfg.Bind<float>("9 - Drop de equipamento", "WeaponDropChance", 1f, "Chance de dropar a arma equipada. 1.0 = sempre.");
			ShieldDropChance = cfg.Bind<float>("9 - Drop de equipamento", "ShieldDropChance", 1f, "Chance de dropar o escudo equipado.");
			ArmorDropChance = cfg.Bind<float>("9 - Drop de equipamento", "ArmorDropChance", 1f, "Chance de dropar cada peca de armadura equipada.");
			ToolDropChance = cfg.Bind<float>("9 - Drop de equipamento", "ToolDropChance", 1f, "Chance de dropar ferramentas e tochas equipadas.");
			AmmoDropChance = cfg.Bind<float>("9 - Drop de equipamento", "AmmoDropChance", 0.5f, "Chance de dropar municao, como flechas.");
			DropsScaleWithStars = cfg.Bind<bool>("9 - Drop de equipamento", "ScaleWithStars", false, "Criaturas com estrela dropam multiplas copias do equipamento.");
			ExcludeBossesFromEquipDrops = cfg.Bind<bool>("9 - Drop de equipamento", "ExcludeBosses", true, "Bosses ficam de fora desta regra e mantem apenas a drop table original.");
			EquipDropPrefabBlacklist = cfg.Bind<string>("9 - Drop de equipamento", "PrefabBlacklist", "", "Nomes de prefab de item que nunca devem dropar, separados por virgula.");
			CreatureItemRemap = cfg.Bind<string>("9 - Drop de equipamento", "CreatureItemRemap", "skeleton_sword=SwordBronze*70|Club*30,skeleton_sword2=SwordBronze*70|Club*30,skeleton_mace=MaceBronze*70|Club*30,skeleton_bow=BowFineWood*70|Bow*30,skeleton_bow2=BowFineWood*70|Bow*30,draugr_sword=SwordIron*70|SwordBronze*30,draugr_axe=AxeIron*60|AxeBronze*30|AxeStone*10,draugr_bow=BowHuntsman*70|BowFineWood*30,GoblinSword=SwordBlackmetal*70|SwordIron*30,GoblinClub=MaceNeedle*70|MaceIron*30,GoblinSpear=SpearWolfFang*70|SpearElderbark*30,GoblinTorch=Torch,DvergerArbalest=CrossbowArbalest,DvergerStaffFire=StaffFireball,DvergerStaffIce=StaffIceShards,GoblinShield=ShieldBlackmetal,GoblinShoulders=ArmorPaddedCuirass,GoblinLoin=ArmorPaddedGreaves,GoblinHelmet=HelmetPadded,GoblinBrute_Attack=AtgeirBlackmetal*70|SledgeIron*30,GoblinShaman_attack_poke=StaffFireball,Fenring_attack_claw=FistFenrirClaw,Fenring_attack_fireclaw=FistFenrirClaw,Fenring_attack_iceclaw=FistFenrirClaw,DvergerStaffHeal=StaffShield,DvergerStaffNova=StaffIceShards,DvergerSuitArbalest=ArmorCarapaceChest,DvergerSuitFire=ArmorMageChest,DvergerSuitIce=ArmorMageChest,DvergerSuitSupport=ArmorMageChest,charred_greatsword_swing=THSwordSlayer,charred_bow=BowAshlands,charred_magestaff_fire=StaffClusterbomb,Charred_Helmet=HelmetFlametal,Charred_Breastplate=ArmorFlametalChest", "Armas internas de criatura nao sao itens de jogador (sem ZNetView), entao nao podem cair no chao. Este mapa traduz 'prefab_da_criatura=PrefabDoJogador'. Itens internos sem entrada sao ignorados. Nomes de criatura vem do mmo_dumpequip; nomes de item de jogador podem ser conferidos com mmo_dumpitems. O proprio mmo_dumpequip marca '(remap invalido!)' quando o alvo nao existe.");
			LogSkippedInternalItems = cfg.Bind<bool>("9 - Drop de equipamento", "LogSkippedInternalItems", true, "Loga uma vez cada item interno ignorado por falta de remap, para ajudar a preencher o mapa.");
			RemapStarBias = cfg.Bind<float>("9 - Drop de equipamento", "RemapStarBias", 0.15f, "Quanto cada estrela da criatura soma a chance do PRIMEIRO alvo do remap (o tier mais alto da linha). 0.15: esqueleto 2* dropa sempre bronze.");
			DropOnlyPlayerItems = cfg.Bind<bool>("9 - Drop de equipamento", "DropOnlyPlayerItems", true, "So dropa itens que o jogador consegue usar (com receita, do mod ou vendido por mercador vanilla). Item de criatura com rede mas sem receita (GoblinArmor, GoblinShield...) e ignorado, a menos que tenha um de-para em CreatureItemRemap.");
			OpenPanelKey = cfg.Bind<KeyboardShortcut>("10 - Interface", "OpenPanelKey", new KeyboardShortcut((KeyCode)112, Array.Empty<KeyCode>()), "Tecla que abre o painel de atributos.");
			ShowHungerBar = cfg.Bind<bool>("10 - Interface", "ShowHungerBar", true, "Desenha a barra de saciedade no HUD, no estilo da barra de stamina do jogo.");
			ShowXpBar = cfg.Bind<bool>("10 - Interface", "ShowXpBar", true, "Desenha a barra de XP no HUD.");
			ShowXpGainMessages = cfg.Bind<bool>("10 - Interface", "ShowXpGainMessages", true, "Mostra o XP ganho no canto da tela ao matar criaturas.");
			HungerBarOffsetX = cfg.Bind<float>("10 - Interface", "HungerBarOffsetX", 0f, "Deslocamento horizontal da barra de saciedade em relacao a barra de stamina.");
			HungerBarOffsetY = cfg.Bind<float>("10 - Interface", "HungerBarOffsetY", 42f, "Deslocamento vertical da barra de saciedade em relacao a barra de stamina. Positivo = acima.");
			HungerBarWidth = cfg.Bind<float>("10 - Interface", "HungerBarWidth", 160f, "Largura da barra de saciedade em pixels.");
			XpBarOffsetX = cfg.Bind<float>("10 - Interface", "XpBarOffsetX", 0f, "Deslocamento horizontal da barra de XP (0 = centro).");
			XpBarOffsetY = cfg.Bind<float>("10 - Interface", "XpBarOffsetY", 82f, "Altura da barra de XP a partir da base da tela. Fica entre a barra de dicas e a de stamina.");
			XpBarWidth = cfg.Bind<float>("10 - Interface", "XpBarWidth", 440f, "Largura da barra de XP em pixels.");
			PanelOpensWithInventory = cfg.Bind<bool>("10 - Interface", "PanelOpensWithInventory", true, "O painel de atributos aparece junto com o inventario, no espaco central. A tecla OpenPanelKey continua funcionando fora do inventario.");
			SlotsEnabled = cfg.Bind<bool>("13 - Slots por peso", "Enabled", true, "Linhas extras de mochila conforme o peso maximo. 300 kg = 24 slots uteis (12,5 kg/slot).");
			SlotsKgPerRow = cfg.Bind<float>("13 - Slots por peso", "KgPerRow", 96f, "Quilos acima de 300 para ganhar uma linha (8 slots). 96 kg = 12 kg por slot.");
			SlotsMaxRows = cfg.Bind<int>("13 - Slots por peso", "MaxRows", 8, "Total maximo de linhas do inventario (vanilla = 4). O grid rola quando passa do painel.");
			MerchantEnabled = cfg.Bind<bool>("14 - Mercador", "Enabled", true, "Spawna um mercador ao lado das pedras iniciais (StartTemple) que vende todos os itens por moedas.");
			MerchantPrefab = cfg.Bind<string>("14 - Mercador", "Prefab", "Haldor", "Prefab de Trader usado como mercador.");
			MerchantName = cfg.Bind<string>("14 - Mercador", "Name", "Mercador", "Nome exibido do mercador.");
			MerchantOffsetX = cfg.Bind<float>("14 - Mercador", "OffsetX", 9f, "Deslocamento em X a partir do centro do StartTemple.");
			MerchantOffsetZ = cfg.Bind<float>("14 - Mercador", "OffsetZ", 0f, "Deslocamento em Z a partir do centro do StartTemple.");
			MerchantPriceMultiplier = cfg.Bind<float>("14 - Mercador", "PriceMultiplier", 1f, "Multiplicador global aplicado as materias-primas (propaga pela cadeia de receitas).");
			MerchantCraftMarkup = cfg.Bind<float>("14 - Mercador", "CraftMarkup", 1.15f, "Multiplicador sobre a soma dos insumos de uma receita (tempo de craft).");
			MerchantCraftBaseFee = cfg.Bind<float>("14 - Mercador", "CraftBaseFee", 5f, "Taxa fixa por item craftado.");
			MerchantStationLevelFee = cfg.Bind<float>("14 - Mercador", "StationLevelFee", 5f, "Taxa extra por nivel de estacao exigido acima de 1.");
			MerchantConversionMarkup = cfg.Bind<float>("14 - Mercador", "ConversionMarkup", 1.3f, "Multiplicador em conversoes de fornalha/alto-forno (alem do combustivel).");
			MerchantCreatureDropExponent = cfg.Bind<float>("14 - Mercador", "CreatureDropExponent", 0.6f, "Preco de drop de criatura = vida^expoente. 0.6: javali 10->4, greydwarf 40->9, troll 600->46, lox 1000->63.");
			MerchantTrophyMultiplier = cfg.Bind<float>("14 - Mercador", "TrophyMultiplier", 3f, "Trofeus custam este multiplo do drop comum da criatura.");
			MerchantGatheredBase = cfg.Bind<float>("14 - Mercador", "GatheredBase", 3f, "Preco de itens coletados (Pickable, arvores, destrutiveis) sem preco explicito.");
			MerchantMinedBase = cfg.Bind<float>("14 - Mercador", "MinedBase", 8f, "Preco de itens minerados sem preco explicito.");
			MerchantUnknownBase = cfg.Bind<float>("14 - Mercador", "UnknownBase", 25f, "Preco de itens sem origem conhecida. Aparecem marcados no mmo_dumpprices.");
			MerchantMaterialStack = cfg.Bind<int>("14 - Mercador", "MaterialStack", 10, "Materiais e municao sao vendidos em lotes deste tamanho.");
			MerchantConsumableStack = cfg.Bind<int>("14 - Mercador", "ConsumableStack", 5, "Comidas e pocoes sao vendidas em lotes deste tamanho.");
			MerchantExcludeQuestItems = cfg.Bind<bool>("14 - Mercador", "ExcludeQuestItems", true, "Nao vende itens de missao (m_questItem).");
			MerchantExcludePattern = cfg.Bind<string>("14 - Mercador", "ExcludePattern", "Cheat,Coins,PlayerUnarmed,CapeTest,ShieldKnight,ShieldIronSquare,_shoot,TurretBoltBone,TrophyDraugrFem,TrophyForestTroll,HildirKey,DvergrKeyFragment,VegvisirShard,Chest_hildir,=AtgeirWood,=AxeWood,=BattleaxeWood,=KnifeWood,=MaceWood,=SledgeWood,=SpearWood,=THSwordWood,=PickaxeStone,=Flametal,=FlametalOre,=SwordIronFire,=DvergerArbalest,Pot_Shard", "Itens que nunca sao vendidos, separados por virgula. Sem '=' compara trecho do nome; com '=' exige nome exato (ex.: '=Flametal' exclui o item legado sem excluir FlametalNew). Padrao: itens de dev e chaves de missao.");
			MerchantBasePrices = cfg.Bind<string>("14 - Mercador", "BasePrices", "Wood=2,Stone=1,Resin=2,Flint=2,Feathers=3,LeatherScraps=3,DeerHide=4,BoneFragments=3,Honey=4,Raspberry=2,Blueberries=2,Mushroom=2,MushroomYellow=4,MushroomBlue=6,Cloudberry=6,Dandelion=2,Thistle=4,Carrot=3,Turnip=4,Onion=5,Barley=8,Flax=8,CarrotSeeds=2,TurnipSeeds=3,OnionSeeds=4,FineWood=4,RoundLog=4,ElderBark=8,YggdrasilWood=12,Blackwood=16,CopperOre=6,TinOre=6,IronScrap=15,SilverOre=40,BlackMetalScrap=60,FlametalOreNew=120,Coal=3,Tar=15,Sap=20,Guck=8,Chitin=20,Crystal=25,Obsidian=12,BlackMarble=8,Grausten=10,TrollHide=12,WolfPelt=30,LoxPelt=45,Bloodbag=10,Entrails=10,Ooze=12,FreezeGland=25,WolfFang=25,Needle=40,ScaleHide=45,Carapace=55,Mandible=50,RoyalJelly=60,Softtissue=25,MushroomMagecap=30,MushroomJotunPuffs=30,JuteRed=20,JuteBlue=45,CharredBone=70,MoltenCore=140,CelestialFeather=150,Bonemawtooth=120,Amber=10,AmberPearl=40,Ruby=60,SilverNecklace=90,Coins=1,BronzeScrap=20,IronOre=15,DragonEgg=300,ChickenEgg=60,AsksvinEgg=150,Fish1=10,Fish2=15,Fish3=20,Fish4_cave=25,Fish5=30,Fish6=35,Fish7=40,Fish8=45,Fish9=50,Fish10=55,Fish11=60,Fish12=80,FeastMeadows=60,FeastBlackforest=90,FeastSwamps=130,FeastMountains=170,FeastPlains=220,FeastOceans=250,FeastMistlands=300,FeastAshlands=400,HelmetMidsummerCrown=50,HelmetPointyHat=50,TorchMist=40,AxeHead1=25,AxeHead2=25,BonemawSerpentScale=80,FishAnglerRaw=60,Larva=15,WolfClaw=30", "Precos de materias-primas (prefab=moedas). Tudo o que deriva delas via receita e calculado automaticamente. Nomes nao existentes nesta build sao ignorados.");
			MerchantPriceOverrides = cfg.Bind<string>("14 - Mercador", "PriceOverrides", "", "Preco final forcado por item (prefab=moedas). Ganha de qualquer calculo.");
			MerchantBuysItems = cfg.Bind<bool>("14 - Mercador", "BuysItems", true, "O mercador compra qualquer item da mochila (painel VENDER ao lado da loja).");
			MerchantBuyRatio = cfg.Bind<float>("14 - Mercador", "BuyRatio", 0.2f, "Fracao do valor BASE (sem inflacao) que o mercador paga. 0.2 = paga 20 por cento (80 por cento a menos).");
			MerchantBuysMaterials = cfg.Bind<bool>("14 - Mercador", "BuysMaterials", false, "Se o mercador compra itens do tipo Material (madeira, pedra, minerios, couros, lingotes). Desligado por padrao: coleta nao pode virar ouro infinito.");
			MerchantNoBuyPattern = cfg.Bind<string>("14 - Mercador", "NoBuyPattern", "", "Itens adicionais que o mercador nunca compra (trecho do nome, ou '=Nome' exato), separados por virgula.");
			MerchantInflationEveryDays = cfg.Bind<int>("14 - Mercador", "InflationEveryDays", 10, "Inflacao: a cada tantos dias do mundo os precos sobem InflationPercent. 0 desliga.");
			MerchantInflationPercent = cfg.Bind<float>("14 - Mercador", "InflationPercent", 5f, "Percentual de aumento por periodo. Composto: multiplicador = (1 + p)^(dia / InflationEveryDays).");
			MerchantInflationMaxMultiplier = cfg.Bind<float>("14 - Mercador", "InflationMaxMultiplier", 4f, "Teto do multiplicador de inflacao. Com 5 por cento a cada 10 dias, 4x e atingido por volta do dia 285.");
			DungeonBossesEnabled = cfg.Bind<bool>("16 - Dungeons", "Enabled", true, "Toda dungeon gerada recebe um boss na sala mais funda.");
			DungeonIncludeCamps = cfg.Bind<bool>("16 - Dungeons", "IncludeCamps", true, "Aldeias Fuling e ruinas das Cinzas (geradas pelo mesmo sistema) tambem recebem boss.");
			DungeonBossHpMultiplier = cfg.Bind<float>("16 - Dungeons", "HpMultiplier", 1f, "Multiplicador sobre a vida alvo por tier (800 / 1600 / 2500 / 3500 / 4500 / 5500).");
			DungeonBossStars = cfg.Bind<int>("16 - Dungeons", "Stars", 2, "Estrelas do boss (0-2). Cada estrela aumenta o dano como no jogo.");
			DungeonBossItemQuality = cfg.Bind<int>("16 - Dungeons", "ItemQuality", 2, "Qualidade do item que o boss humanoide equipa e dropa. 2 = um passo acima do craftavel.");
			DungeonBossGoldRatio = cfg.Bind<float>("16 - Dungeons", "GoldRatio", 0.4f, "Boss que nao equipa item dropa ouro = preco do item de referencia do tier x este valor.");
			XpDungeonBossMultiplier = cfg.Bind<float>("16 - Dungeons", "XpMultiplier", 2f, "Multiplicador de XP de boss de dungeon (bosses invocados usam XpBossMultiplier).");
			DungeonBossMusicRange = cfg.Bind<float>("16 - Dungeons", "MusicRange", 45f, "Distancia em metros para o evento de boss (musica/clima) ligar.");
			PotionCooldown = cfg.Bind<float>("17 - Pocoes e utilitarios", "PotionCooldown", 20f, "Segundos de recarga compartilhada entre todas as pocoes (vida, vigor, eitr).");
			ReturnStoneCooldownMultiplier = cfg.Bind<float>("17 - Pocoes e utilitarios", "ReturnStoneCooldownMultiplier", 1f, "Multiplica a recarga base da Pedra de Retorno (30 min).");
			ReturnStoneIgnoresOre = cfg.Bind<bool>("17 - Pocoes e utilitarios", "ReturnStoneIgnoresOre", false, "Se true, a Pedra de Retorno teleporta mesmo carregando minerios (ignora regra de portal).");
			DungeonResetDays = cfg.Bind<int>("16 - Dungeons", "ResetDays", 5, "Dias do mundo apos a morte para o boss de dungeon renascer na mesma sala. 0 = nunca.");
			ShowPlayerLevels = cfg.Bind<bool>("10 - Interface", "ShowPlayerLevels", true, "Mostra 'Lv N' ao lado do nome dos jogadores.");
			EquipmentRowEnabled = cfg.Bind<bool>("13 - Slots por peso", "EquipmentRow", true, "A ultima linha da mochila e reservada para o equipamento vestido: equipar move a peca para la e libera o slot. Armas/escudos equipados a partir da hotbar ficam na hotbar (troca por tecla continua funcionando).");
			VersionCheckEnabled = cfg.Bind<bool>("18 - Rede", "VersionCheck", true, "Servidor recusa clientes sem o mod (mostra 'versao incompativel' para eles).");
			VersionCheckExact = cfg.Bind<bool>("18 - Rede", "VersionCheckExact", true, "Exige a MESMA versao do mod no cliente e no servidor.");
			ConfigSyncEnabled = cfg.Bind<bool>("18 - Rede", "ConfigSync", true, "Servidor envia sua config aos clientes na conexao (exceto secoes de interface e rede). Aplicada so em memoria; o .cfg local do cliente nao e alterado.");
			PvpEnabled = cfg.Bind<bool>("22 - PvP e karma", "Enabled", true, "Karma por matar jogadores, nome de procurado, guardas hostis a procurados e cidades fechadas para eles.");
			StealthHidesName = cfg.Bind<bool>("22 - PvP e karma", "StealthHidesName", true, "Jogador agachado nao mostra a barra de nome/vida para os outros.");
			KarmaPerKill = cfg.Bind<float>("22 - PvP e karma", "KarmaPerKill", 10f, "Karma ganho ao matar um jogador limpo (karma abaixo de WantedThreshold).");
			KarmaDeathLoss = cfg.Bind<float>("22 - PvP e karma", "KarmaDeathLoss", 10f, "Karma perdido ao morrer (nao zera).");
			KarmaDecayPerMinute = cfg.Bind<float>("22 - PvP e karma", "KarmaDecayPerMinute", 0.5f, "Karma perdido por minuto ONLINE. 0.5: um assassinato limpa em 20 min.");
			KarmaMonsterFactor = cfg.Bind<float>("22 - PvP e karma", "KarmaMonsterFactor", 0.02f, "Karma perdido por monstro = fator x vida^0.6 (boss x5). 0.02: greydwarf 0.18, troll 0.93, lox 1.26.");
			WantedThreshold = cfg.Bind<float>("22 - PvP e karma", "WantedThreshold", 10f, "A partir deste karma o jogador e PROCURADO: nome vermelho, guardas atacam, cidade fecha, mata-lo nao da karma.");
			OutlawThreshold = cfg.Bind<float>("22 - PvP e karma", "OutlawThreshold", 30f, "A partir deste karma o jogador e FORA DA LEI (so muda o rotulo; recompensa ja cresce com o karma).");
			BountyPerKarma = cfg.Bind<float>("22 - PvP e karma", "BountyPerKarma", 5f, "Ouro pago a quem mata um procurado = karma da vitima x este valor.");
			KarmaMax = cfg.Bind<float>("22 - PvP e karma", "KarmaMax", 100f, "Teto do karma.");
			GuardsEnabled = cfg.Bind<bool>("22 - PvP e karma", "Guards", true, "Guardas nas cidades: criatura humanoide do bioma com faccao de jogador, arma do tier, posto fixo. Atacam procurados e monstros.");
			GuardsPerCity = cfg.Bind<int>("22 - PvP e karma", "GuardsPerCity", 4, "Guardas por cidade. Repostos no dia seguinte a morte.");
			GuardStars = cfg.Bind<int>("22 - PvP e karma", "GuardStars", 3, "Estrelas do guarda (0-3).");
			GuardHpMultiplier = cfg.Bind<float>("22 - PvP e karma", "GuardHpMultiplier", 1f, "Vida do guarda = vida do boss de dungeon do tier (800/1600/2500/3500/4500/5500 x HpMultiplier das dungeons) x este valor. 1 = cada guarda e um boss.");
			GuardScaleWithPlayers = cfg.Bind<bool>("22 - PvP e karma", "GuardScaleWithPlayers", true, "Vida do guarda tambem escala com o numero de jogadores proximos, como os bosses (secao Dungeons).");
			CitiesEnabled = cfg.Bind<bool>("21 - Cidades", "Enabled", true, "Uma cidade por bioma ao lado do altar do boss: mercador do bioma, emissario de missoes, praca e zona segura. Com cidades, o mercador do spawn vende so o tier SpawnMerchantTier e itens do mod.");
			CityAnchors = cfg.Bind<string>("21 - Cidades", "Anchors", "1=Eikthyrnir,2=GDKing,3=Bonemass,4=Dragonqueen,5=GoblinKing,6=Mistlands_DvergrBossEntrance1,7=FaderLocation", "tier=nome da location do altar do boss (ZoneSystem). Use mmo_dumplocations para conferir os nomes desta build.");
			SpawnMerchantTier = cfg.Bind<int>("21 - Cidades", "SpawnMerchantTier", 1, "Tier maximo vendido pelo mercador do spawn quando cidades estao ativas.");
			CitySellsLowerTiers = cfg.Bind<bool>("21 - Cidades", "SellsLowerTiers", true, "Cidade vende itens de biomas anteriores com sobretaxa de importacao. Se false, so o proprio bioma.");
			ImportMarkupPerTier = cfg.Bind<float>("21 - Cidades", "ImportMarkupPerTier", 0.4f, "Sobretaxa por tier de distancia para itens importados. 0.4: item de 2 biomas atras custa +80%.");
			LocalBuyRatio = cfg.Bind<float>("21 - Cidades", "LocalBuyRatio", 0.3f, "Fracao do valor base que a cidade paga por itens do PROPRIO bioma (os demais usam BuyRatio).");
			CityPlaza = cfg.Bind<bool>("21 - Cidades", "Plaza", true, "Instancia a praca minima: fogueira, estacao do bioma e 4 banners.");
			CityBuildings = cfg.Bind<bool>("21 - Cidades", "Buildings", true, "Constroi casas e cerca com pecas do bioma (plantas em BepInEx/config/ValheimMMO_cityplan.txt; mmo_cityplan).");
			CityRoofYawFix = cfg.Bind<float>("21 - Cidades", "RoofYawFix", 0f, "Correcao de rotacao (graus) das pecas de telhado, se sairem viradas ao contrario: tente 180.");
			CityMinDistance = cfg.Bind<float>("21 - Cidades", "MinDistanceFromAltar", 70f, "Distancia minima (m) entre o altar do boss e o centro da cidade.");
			CityKeepAwayFromSpawn = cfg.Bind<float>("21 - Cidades", "KeepAwayFromSpawn", 80f, "Distancia minima (m) entre o centro da cidade e as pedras iniciais (StartTemple). A cidade nunca nasce em cima do respawn.");
			CityMaxDistance = cfg.Bind<float>("21 - Cidades", "MaxDistanceFromAltar", 140f, "Distancia maxima (m). A cidade nasce no ponto mais plano e seco desse anel que ja estiver carregado.");
			CitySafeZone = cfg.Bind<bool>("21 - Cidades", "SafeZone", true, "Zona sem spawn de monstros ao redor do mercador da cidade (EffectArea NoMonsters).");
			CitySafeRadius = cfg.Bind<float>("21 - Cidades", "SafeRadius", 40f, "Raio da zona segura em metros.");
			CityPortals = cfg.Bind<bool>("21 - Cidades", "Portals", true, "Rede de portais: a cidade de tier 1 e o hub com um portal para cada outra cidade; cada cidade tem um portal de volta. Tags fixas, nao editaveis. A regra vanilla de minerio nao teleportar continua valendo.");
			CityLevelTerrain = cfg.Bind<bool>("21 - Cidades", "LevelTerrain", true, "Terraplana a praca (nivela e alisa) antes de colocar as pecas, com a mesma operacao da enxada.");
			CityLevelRadius = cfg.Bind<float>("21 - Cidades", "LevelRadius", 16f, "Raio da terraplanagem em metros.");
			MaterialTiers = cfg.Bind<string>("21 - Cidades", "MaterialTiers", "Wood=1,Stone=1,Resin=1,Flint=1,Feathers=1,LeatherScraps=1,DeerHide=1,Honey=1,Raspberry=1,Mushroom=1,Dandelion=1,RawMeat=1,DeerMeat=1,NeckTail=1,HardAntler=1,Amber=1,Fish1=1,BoneFragments=2,Blueberries=2,MushroomYellow=2,Thistle=2,Carrot=2,CarrotSeeds=2,FineWood=2,RoundLog=2,CopperOre=2,TinOre=2,Coal=2,TrollHide=2,AmberPearl=2,Ruby=2,SurtlingCore=2,AncientSeed=2,BronzeScrap=2,GreydwarfEye=2,Fish2=2,MushroomBlue=3,Turnip=3,TurnipSeeds=3,ElderBark=3,IronScrap=3,IronOre=3,Guck=3,Chitin=3,Bloodbag=3,Entrails=3,Ooze=3,SilverNecklace=3,Chain=3,WitheredBone=3,Wishbone=3,SerpentMeat=3,SerpentScale=3,Fish3=3,Onion=4,OnionSeeds=4,SilverOre=4,Crystal=4,Obsidian=4,WolfPelt=4,FreezeGland=4,WolfFang=4,DragonEgg=4,WolfMeat=4,Fish4_cave=4,Cloudberry=5,Barley=5,Flax=5,BlackMetalScrap=5,Tar=5,LoxPelt=5,Needle=5,LoxMeat=5,ChickenEgg=5,Fish5=5,Fish6=5,YggdrasilWood=6,Sap=6,BlackMarble=6,ScaleHide=6,Carapace=6,Mandible=6,RoyalJelly=6,Softtissue=6,MushroomMagecap=6,MushroomJotunPuffs=6,JuteRed=6,JuteBlue=6,Eitr=6,SeekerMeat=6,HareMeat=6,BugMeat=6,Fish7=6,Fish8=6,FlametalOreNew=7,Blackwood=7,Grausten=7,CharredBone=7,MoltenCore=7,CelestialFeather=7,Bonemawtooth=7,AskHide=7,AsksvinEgg=7,Fish9=7,Fish10=7,Fish11=7,Fish12=7", "Bioma (1-7) das materias-primas. Tudo que deriva delas por receita herda o tier do insumo mais avancado. O que nao estiver aqui e detectado por spawn/vegetacao ou por faixa de preco. mmo_dumptiers mostra o resultado.");
			WorldBossEnabled = cfg.Bind<bool>("19 - Chefes mundiais", "Enabled", true, "A cada tantos dias do mundo, um chefe mundial surge perto de um jogador aleatorio e todos sao avisados.");
			WorldBossIntervalDays = cfg.Bind<int>("19 - Chefes mundiais", "IntervalDays", 3, "Dias do mundo entre chefes mundiais.");
			WorldBossHpMultiplier = cfg.Bind<float>("19 - Chefes mundiais", "HpMultiplier", 1f, "Multiplicador sobre a vida por bioma (3000 / 6000 / 8000 / 10000 / 12000 / 15000).");
			WorldBossGoldBase = cfg.Bind<int>("19 - Chefes mundiais", "GoldBase", 300, "Ouro para CADA contribuinte = GoldBase x tier do bioma (1-6).");
			BossRaidEnabled = cfg.Bind<bool>("20 - Raids de boss", "Enabled", true, "Depois de derrotado, um boss invocado pode voltar como raid: clone do raid vanilla do bioma (mesma frequencia, duracao, perto da base, musica) com o proprio boss no lugar dos monstros.");
			BossRaidCooldownDays = cfg.Bind<int>("20 - Raids de boss", "CooldownDays", 4, "Dias do mundo entre raids de boss (qualquer boss). Os raids comuns continuam normais.");
			BossRaidMinDuration = cfg.Bind<float>("20 - Raids de boss", "MinDurationSeconds", 90f, "Duracao minima do evento. O boss continua vivo depois que o evento termina.");
			BossScalingEnabled = cfg.Bind<bool>("16 - Dungeons", "ScaleWithPlayers", true, "Vida maxima do boss escala com jogadores no raio: base x (1 + PerPlayer x (n-1)), mantendo a fracao de vida atual.");
			BossScalePerPlayer = cfg.Bind<float>("16 - Dungeons", "ScalePerPlayer", 0.6f, "Acrescimo de vida por jogador adicional. 0.6: 2 jogadores = 160%, 3 = 220%, 4 = 280%.");
			BossScaleRadius = cfg.Bind<float>("16 - Dungeons", "ScaleRadius", 80f, "Raio em metros para contar jogadores na luta.");
			BossScaleVanilla = cfg.Bind<bool>("16 - Dungeons", "ScaleVanillaBosses", true, "Aplica o escalonamento tambem aos bosses invocados do jogo (Eikthyr, Elder...).");
			BankEnabled = cfg.Bind<bool>("14 - Mercador", "BankEnabled", true, "Aba COFRE no mercador: cofre pessoal salvo no personagem, sem peso.");
			BankRows = cfg.Bind<int>("14 - Mercador", "BankRows", 6, "Linhas do cofre (8 slots por linha).");
			DropDurabilityMin = cfg.Bind<float>("9 - Drop de equipamento", "DropDurabilityMin", 0.2f, "Durabilidade minima (fracao) do equipamento dropado por mob comum.");
			DropDurabilityMax = cfg.Bind<float>("9 - Drop de equipamento", "DropDurabilityMax", 0.6f, "Durabilidade maxima (fracao) do equipamento dropado por mob comum. Boss de dungeon dropa intacto.");
			HungerStatusIcons = cfg.Bind<bool>("8 - Fome", "StatusIcons", true, "Mostra 'Bem alimentado' / 'Com fome' na lista de efeitos do HUD.");
			RepairCostRatio = cfg.Bind<float>("14 - Mercador", "RepairCostRatio", 0.1f, "Reparo no mercador custa preco do item x (1 - durabilidade) x este valor.");
			UpgradeCostFactor = cfg.Bind<float>("14 - Mercador", "UpgradeCostFactor", 0.6f, "Melhorar qualidade no mercador custa preco do item x qualidade atual x este valor.");
			ExtraQualityLevels = cfg.Bind<int>("14 - Mercador", "ExtraQualityLevels", 2, "Quantos niveis de qualidade ALEM do maximo craftavel o mercador pode dar (o bonus de atributo do item escala junto).");
			QuestsEnabled = cfg.Bind<bool>("14 - Mercador", "QuestsEnabled", true, "Missoes diarias: no emissario de cada cidade (ou na aba MISSOES do mercador, sem cidades).");
			QuestMaxActive = cfg.Bind<int>("14 - Mercador", "QuestMaxActive", 5, "Quantas missoes aceitas ao mesmo tempo (somando todas as cidades).");
			QuestTrackerEnabled = cfg.Bind<bool>("14 - Mercador", "QuestTracker", true, "Mostra as missoes aceitas com progresso no HUD, abaixo do minimapa.");
			QuestTrackerOffsetX = cfg.Bind<float>("14 - Mercador", "QuestTrackerOffsetX", 20f, "Distancia da borda direita (px em 1080p).");
			QuestTrackerOffsetY = cfg.Bind<float>("14 - Mercador", "QuestTrackerOffsetY", 300f, "Distancia do topo (px em 1080p). Minimapa termina em ~280.");
			QuestRewardMultiplier = cfg.Bind<float>("14 - Mercador", "QuestRewardMultiplier", 1f, "Multiplicador das recompensas de missao (ouro; o XP e 3x o ouro).");
			MapPrice = cfg.Bind<int>("15 - Mapa do Explorador", "Price", 150, "Preco base do Mapa do Explorador no mercador (a inflacao aplica por cima). Vendido por unidade.");
			MapRevealRadius = cfg.Bind<float>("15 - Mapa do Explorador", "RevealRadius", 300f, "Raio em metros da regiao revelada. 300 m ~ 4-5 zonas de 64 m em cada direcao.");
			MapWorldRadius = cfg.Bind<float>("15 - Mapa do Explorador", "WorldRadius", 9000f, "Raio do mundo dentro do qual a regiao e sorteada. O mundo tem ~10.500 m; alem de ~9.000 e so mar/borda.");
			MapBossDropChance = cfg.Bind<float>("15 - Mapa do Explorador", "BossDropChance", 0.35f, "Chance de qualquer boss (vanilla ou de dungeon) dropar um mapa. 1.0 = sempre.");
			BowTweaksEnabled = cfg.Bind<bool>("11 - Arquearia", "Enabled", true, "Aplica os ajustes de arco e besta abaixo a todos os itens dessas skills (vanilla e de mods).");
			BowDrawTimeMultiplier = cfg.Bind<float>("11 - Arquearia", "DrawTimeMultiplier", 0.7f, "Multiplicador do tempo minimo para puxar o arco por completo. 0.7 = 30 por cento mais rapido.");
			BowDrawStaminaMultiplier = cfg.Bind<float>("11 - Arquearia", "DrawStaminaMultiplier", 0.6f, "Multiplicador da stamina drenada enquanto segura o arco puxado.");
			BowAttackStaminaMultiplier = cfg.Bind<float>("11 - Arquearia", "AttackStaminaMultiplier", 0.8f, "Multiplicador da stamina gasta ao disparar.");
			BowProjectileSpeedMultiplier = cfg.Bind<float>("11 - Arquearia", "ProjectileSpeedMultiplier", 1.3f, "Multiplicador da velocidade da flecha. Maior = trajetoria mais reta e menos queda.");
			BowDamageMultiplier = cfg.Bind<float>("11 - Arquearia", "DamageMultiplier", 1f, "Multiplicador de dano de arcos e bestas. 1.0 = sem alteracao.");
			CrossbowReloadMultiplier = cfg.Bind<float>("11 - Arquearia", "CrossbowReloadMultiplier", 0.75f, "Multiplicador do tempo de recarga das bestas.");
		}
	}
}
namespace ValheimMMO.Commands
{
	[HarmonyPatch(typeof(Terminal), "InitTerminal")]
	internal static class Terminal_InitTerminal_Patch
	{
		private static bool _registered;

		private static void Postfix()
		{
			if (!_registered)
			{
				_registered = true;
				ConsoleCommands.Register();
				Plugin.Log.LogInfo((object)"Comandos de console registrados.");
			}
		}
	}
	internal static class ConsoleCommands
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static ConsoleEvent <>9__0_0;

			public static ConsoleEvent <>9__0_1;

			public static ConsoleEvent <>9__0_2;

			public static ConsoleEvent <>9__0_3;

			public static ConsoleEvent <>9__0_4;

			public static ConsoleEvent <>9__0_5;

			public static ConsoleEvent <>9__0_6;

			public static ConsoleEvent <>9__0_7;

			public static ConsoleEvent <>9__0_8;

			public static ConsoleEvent <>9__0_9;

			public static ConsoleEvent <>9__0_10;

			public static ConsoleEvent <>9__0_11;

			public static ConsoleEvent <>9__0_12;

			public static ConsoleEvent <>9__0_13;

			public static ConsoleEvent <>9__0_14;

			public static ConsoleEvent <>9__0_15;

			public static ConsoleEvent <>9__0_16;

			public static ConsoleEvent <>9__0_17;

			public static ConsoleEvent <>9__0_18;

			public static ConsoleEvent <>9__0_19;

			public static ConsoleEvent <>9__0_20;

			public static Comparison<(string type, string row)> <>9__2_0;

			public static Converter<string, string> <>9__3_0;

			internal void <Register>b__0_0(ConsoleEventArgs args)
			{
				PlayerProgress local = PlayerProgress.Local;
				if (local == null)
				{
					args.Context.AddString("Nenhum personagem ativo.");
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				local.ComputeStats(localPlayer, out var hp, out var stamina, out var eitr);
				args.Context.AddString($"Level {local.Level}/{ModConfig.MaxLevel.Value}  " + $"XP {local.Xp}/{local.XpForNextLevel}");
				int[] array = ItemBonuses.TotalEquipped((Humanoid)(object)localPlayer);
				args.Context.AddString($"Vitalidade {local.Spent[0]} (+{array[0]} itens)  " + $"Resistencia {local.Spent[1]} (+{array[1]})  " + $"Espirito {local.Spent[2]} (+{array[2]})  " + $"Condicionamento {local.Spent[3]} (+{array[3]})  " + $"(livres: {local.UnspentPoints})");
				args.Context.AddString($"Vida {hp:0}  Stamina {stamina:0}  Eitr {eitr:0}  Peso {localPlayer.GetMaxCarryWeight():0} kg");
				if (ModConfig.HungerEnabled.Value)
				{
					HungerState s = HungerSystem.StateOf(local.Satiety);
					args.Context.AddString($"Saciedade {local.Satiety:0}/{HungerSystem.Max:0} ({HungerSystem.DisplayName(s)})");
				}
			}

			internal void <Register>b__0_1(ConsoleEventArgs args)
			{
				Player localPlayer = Player.m_localPlayer;
				PlayerProgress local = PlayerProgress.Local;
				string reason;
				if (local == null)
				{
					args.Context.AddString("Nenhum personagem ativo.");
				}
				else if (local.RespecAll(localPlayer, out reason))
				{
					MmoUI.RefreshStats(localPlayer);
					args.Context.AddString($"Pontos redistribuidos. {local.UnspentPoints} disponiveis.");
				}
				else
				{
					args.Context.AddString(reason);
				}
			}

			internal void <Register>b__0_2(ConsoleEventArgs args)
			{
				Player localPlayer = Player.m_localPlayer;
				PlayerProgress local = PlayerProgress.Local;
				if (local == null)
				{
					args.Context.AddString("Nenhum personagem ativo.");
					return;
				}
				if (args.Length < 2 || !long.TryParse(args[1], out var result))
				{
					args.Context.AddString("Uso: mmo_addxp <quantidade>");
					return;
				}
				int num = local.AddXp(result, localPlayer);
				MmoUI.RefreshStats(localPlayer);
				args.Context.AddString($"+{result} XP. Level {local.Level} (subiu {num}).");
			}

			internal void <Register>b__0_3(ConsoleEventArgs args)
			{
				Player localPlayer = Player.m_localPlayer;
				PlayerProgress local = PlayerProgress.Local;
				if (local == null)
				{
					args.Context.AddString("Nenhum personagem ativo.");
					return;
				}
				if (args.Length < 2 || !int.TryParse(args[1], out var result))
				{
					args.Context.AddString("Uso: mmo_setlevel <n>");
					return;
				}
				local.Level = Mathf.Clamp(result, 1, ModConfig.MaxLevel.Value);
				local.Xp = 0L;
				local.SaveTo(localPlayer);
				MmoUI.RefreshStats(localPlayer);
				args.Context.AddString($"Level definido para {local.Level}. " + $"{local.UnspentPoints} pontos disponiveis.");
			}

			internal void <Register>b__0_4(ConsoleEventArgs args)
			{
				Player localPlayer = Player.m_localPlayer;
				PlayerProgress local = PlayerProgress.Local;
				if (local == null)
				{
					args.Context.AddString("Nenhum personagem ativo.");
					return;
				}
				if (args.Length < 2 || !float.TryParse(args[1], out var result))
				{
					args.Context.AddString("Uso: mmo_satiety <0-100>");
					return;
				}
				local.Satiety = Mathf.Clamp(result, 0f, HungerSystem.Max);
				local.SaveTo(localPlayer);
				args.Context.AddString($"Saciedade = {local.Satiety:0}");
			}

			internal void <Register>b__0_5(ConsoleEventArgs args)
			{
				Player localPlayer = Player.m_localPlayer;
				PlayerProgress local = PlayerProgress.Local;
				if (local == null)
				{
					args.Context.AddString("Nenhum personagem ativo.");
					return;
				}
				local.Reset();
				local.SaveTo(localPlayer);
				MmoUI.RefreshStats(localPlayer);
				args.Context.AddString("Progressao zerada.");
			}

			internal void <Register>b__0_6(ConsoleEventArgs args)
			{
				DumpEquipmentMap(args.Context);
			}

			internal void <Register>b__0_7(ConsoleEventArgs args)
			{
				DumpItems(args.Context);
			}

			internal void <Register>b__0_8(ConsoleEventArgs args)
			{
				<>c__DisplayClass0_0 <>c__DisplayClass0_ = default(<>c__DisplayClass0_0);
				<>c__DisplayClass0_.hud = Hud.instance;
				if ((Object)(object)<>c__DisplayClass0_.hud == (Object)null)
				{
					args.Context.AddString("HUD nao carregado.");
					return;
				}
				object obj;
				if (!((Object)(object)<>c__DisplayClass0_.hud.m_healthPanel != (Object)null))
				{
					RectTransform healthBarRoot = <>c__DisplayClass0_.hud.m_healthBarRoot;
					obj = ((healthBarRoot != null) ? ((Transform)healthBarRoot).parent : null);
				}
				else
				{
					obj = ((Component)<>c__DisplayClass0_.hud.m_healthPanel).transform;
				}
				Transform val = (Transform)obj;
				if ((Object)(object)val == (Object)null)
				{
					args.Context.AddString("Painel de vida nao encontrado.");
					return;
				}
				<>c__DisplayClass0_.sb = new StringBuilder();
				<>c__DisplayClass0_.sb.AppendLine("# Hierarquia de " + ((Object)val).name);
				<>c__DisplayClass0_.sb.AppendLine();
				<>c__DisplayClass0_.sb.AppendLine("Marcadores: [healthBarRoot] [foodBarRoot] [foodBaseBar] [foodIcon] [foodText]");
				<>c__DisplayClass0_.sb.AppendLine();
				<Register>g__Walk|0_21(val, 0, ref <>c__DisplayClass0_);
				string text = Path.Combine(Paths.ConfigPath, "ValheimMMO_hud.md");
				File.WriteAllText(text, <>c__DisplayClass0_.sb.ToString(), Encoding.UTF8);
				args.Context.AddString("Arquivo: " + text);
			}

			internal void <Register>b__0_9(ConsoleEventArgs args)
			{
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					args.Context.AddString("Nenhum personagem ativo.");
					return;
				}
				int result;
				DungeonTier dungeonTier = DungeonBosses.TierById((args.Length <= 1 || !int.TryParse(args[1], out result)) ? 1 : result);
				if (dungeonTier == null)
				{
					args.Context.AddString("Tier invalido (1-6).");
					return;
				}
				Vector3 pos = ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 6f;
				if (DungeonBosses.Spawn(dungeonTier, pos, out var error))
				{
					args.Context.AddString("Boss '" + dungeonTier.Title + "' spawnado.");
				}
				else
				{
					args.Context.AddString("Falha: " + error);
				}
			}

			internal void <Register>b__0_10(ConsoleEventArgs args)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
				{
					args.Context.AddString("Entre em um mundo primeiro.");
					return;
				}
				WorldBoss.SpawnNow();
				args.Context.AddString("Chefe mundial invocado. Siga o pin no mapa.");
			}

			internal void <Register>b__0_11(ConsoleEventArgs args)
			{
				RandEventSystem instance = RandEventSystem.instance;
				if ((Object)(object)instance == (Object)null)
				{
					args.Context.AddString("RandEventSystem nao carregado.");
					return;
				}
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("| Evento | Musica | Ambiente | Duracao | Spawns |");
				stringBuilder.AppendLine("|---|---|---|---|---|");
				foreach (RandomEvent @event in instance.m_events)
				{
					stringBuilder.AppendLine($"| `{@event.m_name}` | {@event.m_forceMusic} | {@event.m_forceEnvironment} | {@event.m_duration} | {@event.m_spawn?.Count ?? 0} |");
				}
				string text = Path.Combine(Paths.ConfigPath, "ValheimMMO_events.md");
				File.WriteAllText(text, stringBuilder.ToString(), Encoding.UTF8);
				args.Context.AddString($"{instance.m_events.Count} eventos. Arquivo: {text}");
			}

			internal void <Register>b__0_12(ConsoleEventArgs args)
			{
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)ZoneSystem.instance == (Object)null)
				{
					args.Context.AddString("Entre em um mundo primeiro.");
					return;
				}
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("| Location | Bioma | Unica | Icone |");
				stringBuilder.AppendLine("|---|---|---|---|");
				foreach (ZoneLocation location in ZoneSystem.instance.m_locations)
				{
					if (location != null)
					{
						stringBuilder.AppendLine(string.Format("| `{0}` | {1} | {2} | {3} |", location.m_prefabName, location.m_biome, location.m_unique ? "sim" : "", (location.m_iconAlways || location.m_iconPlaced) ? "sim" : ""));
					}
				}
				string text = Path.Combine(Paths.ConfigPath, "ValheimMMO_locations.md");
				File.WriteAllText(text, stringBuilder.ToString(), Encoding.UTF8);
				args.Context.AddString($"{ZoneSystem.instance.m_locations.Count} locations. Arquivo: {text}");
			}

			internal void <Register>b__0_13(ConsoleEventArgs args)
			{
				if ((Object)(object)ObjectDB.instance == (Object)null)
				{
					args.Context.AddString("Entre em um mundo primeiro.");
					return;
				}
				MerchantItems.Invalidate();
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("| Prefab | Tier | Bioma | Como |");
				stringBuilder.AppendLine("|---|---|---|---|");
				int[] array = new int[8];
				foreach (TradeItem item in MerchantItems.List)
				{
					string name = ((Object)((Component)item.m_prefab).gameObject).name;
					int num = BiomeTiers.TierOf(name);
					array[Mathf.Clamp(num, 0, 7)]++;
					stringBuilder.AppendLine($"| `{name}` | {num} | {BiomeTiers.Name(num)} | {BiomeTiers.WhyOf(name)} |");
				}
				stringBuilder.AppendLine();
				for (int i = 0; i <= 7; i++)
				{
					stringBuilder.AppendLine($"- Tier {i} ({BiomeTiers.Name(i)}): {array[i]} itens");
				}
				string text = Path.Combine(Paths.ConfigPath, "ValheimMMO_tiers.md");
				File.WriteAllText(text, stringBuilder.ToString(), Encoding.UTF8);
				args.Context.AddString("Arquivo: " + text);
			}

			internal void <Register>b__0_14(ConsoleEventArgs args)
			{
				DumpPrices(args.Context);
			}

			internal void <Register>b__0_15(ConsoleEventArgs args)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				string error;
				if ((Object)(object)localPlayer == (Object)null)
				{
					args.Context.AddString("Nenhum personagem ativo.");
				}
				else if (MerchantSpawner.Spawn(((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 3f, ((Component)localPlayer).transform.position, out error))
				{
					ZoneSystem instance = ZoneSystem.instance;
					if (instance != null)
					{
						instance.SetGlobalKey("mmo_merchant_spawned");
					}
					args.Context.AddString("Mercador spawnado.");
				}
				else
				{
					args.Context.AddString("Falha: " + error);
				}
			}

			internal void <Register>b__0_16(ConsoleEventArgs args)
			{
				if ((Object)(object)ZoneSystem.instance == (Object)null)
				{
					args.Context.AddString("Entre em um mundo primeiro.");
					return;
				}
				ZoneSystem.instance.RemoveGlobalKey("mmo_merchant_spawned");
				MerchantItems.Invalidate();
				args.Context.AddString("Marca removida. Va ate as pedras iniciais para ele reaparecer.");
			}

			internal void <Register>b__0_17(ConsoleEventArgs args)
			{
				//IL_0066: 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_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_02be: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				//IL_0285: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)ZNet.instance == (Object)null)
				{
					args.Context.AddString("Entre em um mundo primeiro.");
					return;
				}
				if (!ZNet.instance.IsServer())
				{
					args.Context.AddString("So funciona no host/servidor (a lista de locations vive la).");
					return;
				}
				Vector3 val = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
				int result2;
				if (args.Length >= 3 && args[1].ToLowerInvariant() == "demolish" && int.TryParse(args[2], out var result))
				{
					int num = 0;
					ZNetView[] array = Object.FindObjectsByType<ZNetView>((FindObjectsSortMode)0);
					foreach (ZNetView val2 in array)
					{
						if (val2.IsValid())
						{
							ZDO zDO = val2.GetZDO();
							if ((zDO.GetBool("mmo_city_piece", false) || zDO.GetBool("mmo_city_portal", false) || zDO.GetInt("mmo_city", 0) == result || zDO.GetInt("mmo_guard", 0) == result || zDO.GetBool("mmo_city_test", false)) && !(Vector3.Distance(((Component)val2).transform.position, val) > 120f))
							{
								val2.ClaimOwnership();
								ZNetScene.instance.Destroy(((Component)val2).gameObject);
								num++;
							}
						}
					}
					CitySystem.ResetFounded(result);
					args.Context.AddString($"{num} objetos removidos; tier {result} liberado. Ela renasce (no anel novo) quando alguem chegar perto do altar.");
				}
				else if (args.Length >= 2 && int.TryParse(args[1], out result2))
				{
					CityDef cityDef = CitySystem.ByTier(result2);
					if (cityDef == null)
					{
						args.Context.AddString("Tier invalido (1-7).");
						return;
					}
					string anchorName;
					Vector3? val3 = CitySystem.AnchorPositionFor(result2, val, out anchorName);
					if (!val3.HasValue)
					{
						args.Context.AddString("Altar '" + anchorName + "' nao existe neste mundo.");
						return;
					}
					float num2 = Vector3.Distance(val, val3.Value);
					if (num2 > 60f)
					{
						args.Context.AddString($"Voce esta a {num2:0} m do altar '{anchorName}'. O terreno so existe carregado a ate ~60 m; chegue mais perto (ou espere: ela nasce sozinha).");
						return;
					}
					CitySystem.ResetFounded(result2);
					string error;
					bool flag = CitySystem.Found(cityDef, val3.Value, Player.m_localPlayer, out error);
					args.Context.AddString(flag ? $"{cityDef.Name} fundada em {val3.Value} (altar a {num2:0} m de voce)." : ("Falha ao fundar " + cityDef.Name + ": " + error));
				}
				else
				{
					CityDef[] defs = CitySystem.Defs;
					foreach (CityDef cityDef2 in defs)
					{
						string anchorName2;
						Vector3? val4 = CitySystem.AnchorPositionFor(cityDef2.Tier, val, out anchorName2);
						string text = ((!val4.HasValue) ? "altar NAO encontrado" : $"altar a {Vector3.Distance(val, val4.Value):0} m");
						args.Context.AddString(string.Format("[{0}] {1} <- {2}: {3}; {4}", cityDef2.Tier, cityDef2.Name, anchorName2, text, CitySystem.IsFounded(cityDef2.Tier) ? "FUNDADA" : "nao fundada"));
					}
					args.Context.AddString("Fundacao automatica: servidor, quando alguem chega a 100 m do altar. Forcar: mmo_city <tier>.");
				}
			}

			internal void <Register>b__0_18(ConsoleEventArgs args)
			{
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Unknown result type (might be due to invalid IL or missing references)
				//IL_020d: Unknown result type (might be due to invalid IL or missing references)
				//IL_027d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_023e: Unknown result type (might be due to invalid IL or missing references)
				//IL_022d: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)ZNetScene.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					args.Context.AddString("Entre em um mundo primeiro.");
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				string text = ((args.Length >= 2) ? args[1].ToLowerInvariant() : "help");
				int result = 1;
				switch (text)
				{
				case "reload":
					args.Context.AddString("Plano: " + CityBuilder.Reload());
					break;
				case "export":
					args.Context.AddString(CityBuilder.ExportBuiltin() + " -- edite e use mmo_cityplan reload");
					break;
				case "build":
				{
					if (args.Length < 3)
					{
						args.Context.AddString("mmo_cityplan build <template> [tier]");
						break;
					}
					if (args.Length >= 4)
					{
						int.TryParse(args[3], out result);
					}
					Vector3 forward2 = ((Component)localPlayer).transform.forward;
					forward2.y = 0f;
					((Vector3)(ref forward2)).Normalize();
					Vector3 val2 = ((Component)localPlayer).transform.position + forward2 * 8f;
					float y2 = default(float);
					if (ZoneSystem.instance.GetGroundHeight(val2, ref y2))
					{
						val2.y = y2;
					}
					Quaternion val3 = Quaternion.LookRotation(-forward2);
					float y3 = ((Quaternion)(ref val3)).eulerAngles.y;
					int num2 = CityBuilder.BuildTemplate(args[2], val2, y3, result, test: true);
					args.Context.AddString($"{num2} pecas ({args[2]}, tier {result}). mmo_cityplan clear remove.");
					break;
				}
				case "village":
				{
					if (args.Length >= 3)
					{
						int.TryParse(args[2], out result);
					}
					Vector3 forward = ((Component)localPlayer).transform.forward;
					forward.y = 0f;
					((Vector3)(ref forward)).Normalize();
					Vector3 val = ((Component)localPlayer).transform.position + forward * 20f;
					float y = default(float);
					if (ZoneSystem.instance.GetGroundHeight(val, ref y))
					{
						val.y = y;
					}
					if (ModConfig.CityLevelTerrain.Value)
					{
						Terraform.Level(val, ModConfig.CityLevelRadius.Value);
					}
					int num = CityBuilder.BuildVillage(val, result, test: true);
					args.Context.AddString($"{num} pecas (vila tier {result}, sem NPCs). mmo_cityplan clear remove.");
					break;
				}
				case "clear":
					args.Context.AddString($"{CityBuilder.ClearTest(((Component)localPlayer).transform.position, 80f)} pecas de teste removidas.");
					break;
				default:
					args.Context.AddString("mmo_cityplan reload | export | build <template> [tier] | village [tier] | clear");
					break;
				}
			}

			internal void <Register>b__0_19(ConsoleEventArgs args)
			{
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)ZNetScene.instance == (Object)null)
				{
					args.Context.AddString("Entre em um mundo primeiro.");
					return;
				}
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("| Prefab | Categoria | Estacao | Tamanho (x y z) | Centro - pivo (x y z) | Material |");
				stringBuilder.AppendLine("|---|---|---|---|---|---|");
				int num = 0;
				foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
				{
					if ((Object)(object)prefab == (Object)null)
					{
						continue;
					}
					Piece component = prefab.GetComponent<Piece>();
					if ((Object)(object)component == (Object)null || (Object)(object)prefab.GetComponent<ItemDrop>() != (Object)null)
					{
						continue;
					}
					Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
					if (componentsInChildren.Length != 0)
					{
						Bounds bounds = componentsInChildren[0].bounds;
						Renderer[] array = componentsInChildren;
						foreach (Renderer val in array)
						{
							((Bounds)(ref bounds)).Encapsulate(val.bounds);
						}
						Vector3 val2 = ((Bounds)(ref bounds)).center - prefab.transform.position;
						WearNTear component2 = prefab.GetComponent<WearNTear>();
						string text = (((Object)(object)component.m_craftingStation != (Object)null) ? ((Object)component.m_craftingStation).name : "");
						string text2 = ((component.m_resources != null && component.m_resources.Length != 0 && (Object)(object)component.m_resources[0].m_resItem != (Object)null) ? ((Object)component.m_resources[0].m_resItem).name : "");
						stringBuilder.AppendLine(string.Format("| `{0}` | {1} | {2} | {3:0.0} {4:0.0} {5:0.0} | {6:0.0} {7:0.0} {8:0.0} | {9}{10} |", ((Object)prefab).name, component.m_category, text, ((Bounds)(ref bounds)).size.x, ((Bounds)(ref bounds)).size.y, ((Bounds)(ref bounds)).size.z, val2.x, val2.y, val2.z, text2, ((Object)(object)component2 != (Object)null) ? (" " + ((object)Unsafe.As<MaterialType, MaterialType>(ref component2.m_materialType)/*cast due to .constrained prefix*/).ToString()) : ""));
						num++;
					}
				}
				string text3 = Path.Combine(Paths.ConfigPath, "ValheimMMO_pieces.md");
				File.WriteAllText(text3, stringBuilder.ToString(), Encoding.UTF8);
				args.Context.AddString($"{num} pecas. Arquivo: {text3}");
			}

			internal void <Register>b__0_20(ConsoleEventArgs args)
			{
				if ((Object)(object)ZoneSystem.instance == (Object)null)
				{
					args.Context.AddString("Entre em um mundo primeiro.");
					return;
				}
				if (args.Length >= 2 && int.TryParse(args[1], out var result))
				{
					CitySystem.ResetFounded(result);
					args.Context.AddString($"Marca do tier {result} removida.");
					return;
				}
				CityDef[] defs = CitySystem.Defs;
				for (int i = 0; i < defs.Length; i++)
				{
					CitySystem.ResetFounded(defs[i].Tier);
				}
				args.Context.AddString("Marcas de todos os tiers removidas. Cuidado: cidades ja construidas serao construidas de novo ao chegar perto.");
			}

			internal int <DumpItems>b__2_0((string type, string row) a, (string type, string row) b)
			{
				int num = string.Compare(a.type, b.type, StringComparison.Ordinal);
				if (num == 0)
				{
					return string.Compare(a.row, b.row, StringComparison.OrdinalIgnoreCase);
				}
				return num;
			}

			internal string <DumpEquipmentMap>b__3_0(string n)
			{
				return n + "=";
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <>c__DisplayClass0_0
		{
			public Hud hud;

			public StringBuilder sb;
		}

		private static readonly HashSet<string> _unmapped = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static void Register()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_0109: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: 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_0141: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Expected O, but got Unknown
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Expected O, but got Unknown
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Expected O, but got Unknown
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Expected O, but got Unknown
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Expected O, but got Unknown
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Expected O, but got Unknown
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Expected O, but got Unknown
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Expected O, but got Unknown
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Expected O, but got Unknown
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: Expected O, but got Unknown
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Expected O, but got Unknown
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					PlayerProgress local = PlayerProgress.Local;
					if (local == null)
					{
						args.Context.AddString("Nenhum personagem ativo.");
					}
					else
					{
						Player localPlayer = Player.m_localPlayer;
						local.ComputeStats(localPlayer, out var hp, out var stamina, out var eitr);
						args.Context.AddString($"Level {local.Level}/{ModConfig.MaxLevel.Value}  " + $"XP {local.Xp}/{local.XpForNextLevel}");
						int[] array = ItemBonuses.TotalEquipped((Humanoid)(object)localPlayer);
						args.Context.AddString($"Vitalidade {local.Spent[0]} (+{array[0]} itens)  " + $"Resistencia {local.Spent[1]} (+{array[1]})  " + $"Espirito {local.Spent[2]} (+{array[2]})  " + $"Condicionamento {local.Spent[3]} (+{array[3]})  " + $"(livres: {local.UnspentPoints})");
						args.Context.AddString($"Vida {hp:0}  Stamina {stamina:0}  Eitr {eitr:0}  Peso {localPlayer.GetMaxCarryWeight():0} kg");
						if (ModConfig.HungerEnabled.Value)
						{
							HungerState s = HungerSystem.StateOf(local.Satiety);
							args.Context.AddString($"Saciedade {local.Satiety:0}/{HungerSystem.Max:0} ({HungerSystem.DisplayName(s)})");
						}
					}
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("mmo", "Mostra sua progressao atual.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj2 = <>c.<>9__0_1;
			if (obj2 == null)
			{
				ConsoleEvent val2 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					PlayerProgress local = PlayerProgress.Local;
					string reason;
					if (local == null)
					{
						args.Context.AddString("Nenhum personagem ativo.");
					}
					else if (local.RespecAll(localPlayer, out reason))
					{
						MmoUI.RefreshStats(localPlayer);
						args.Context.AddString($"Pontos redistribuidos. {local.UnspentPoints} disponiveis.");
					}
					else
					{
						args.Context.AddString(reason);
					}
				};
				<>c.<>9__0_1 = val2;
				obj2 = (object)val2;
			}
			new ConsoleCommand("mmo_respec", "Redistribui todos os pontos gastos.", (ConsoleEvent)obj2, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj3 = <>c.<>9__0_2;
			if (obj3 == null)
			{
				ConsoleEvent val3 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					PlayerProgress local = PlayerProgress.Local;
					long result;
					if (local == null)
					{
						args.Context.AddString("Nenhum personagem ativo.");
					}
					else if (args.Length < 2 || !long.TryParse(args[1], out result))
					{
						args.Context.AddString("Uso: mmo_addxp <quantidade>");
					}
					else
					{
						int num = local.AddXp(result, localPlayer);
						MmoUI.RefreshStats(localPlayer);
						args.Context.AddString($"+{result} XP. Level {local.Level} (subiu {num}).");
					}
				};
				<>c.<>9__0_2 = val3;
				obj3 = (object)val3;
			}
			new ConsoleCommand("mmo_addxp", "Concede XP. Uso: mmo_addxp <quantidade>", (ConsoleEvent)obj3, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj4 = <>c.<>9__0_3;
			if (obj4 == null)
			{
				ConsoleEvent val4 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					PlayerProgress local = PlayerProgress.Local;
					int result;
					if (local == null)
					{
						args.Context.AddString("Nenhum personagem ativo.");
					}
					else if (args.Length < 2 || !int.TryParse(args[1], out result))
					{
						args.Context.AddString("Uso: mmo_setlevel <n>");
					}
					else
					{
						local.Level = Mathf.Clamp(result, 1, ModConfig.MaxLevel.Value);
						local.Xp = 0L;
						local.SaveTo(localPlayer);
						MmoUI.RefreshStats(localPlayer);
						args.Context.AddString($"Level definido para {local.Level}. " + $"{local.UnspentPoints} pontos disponiveis.");
					}
				};
				<>c.<>9__0_3 = val4;
				obj4 = (object)val4;
			}
			new ConsoleCommand("mmo_setlevel", "Define o level. Uso: mmo_setlevel <n>", (ConsoleEvent)obj4, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj5 = <>c.<>9__0_4;
			if (obj5 == null)
			{
				ConsoleEvent val5 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					PlayerProgress local = PlayerProgress.Local;
					float result;
					if (local == null)
					{
						args.Context.AddString("Nenhum personagem ativo.");
					}
					else if (args.Length < 2 || !float.TryParse(args[1], out result))
					{
						args.Context.AddString("Uso: mmo_satiety <0-100>");
					}
					else
					{
						local.Satiety = Mathf.Clamp(result, 0f, HungerSystem.Max);
						local.SaveTo(localPlayer);
						args.Context.AddString($"Saciedade = {local.Satiety:0}");
					}
				};
				<>c.<>9__0_4 = val5;
				obj5 = (object)val5;
			}
			new ConsoleCommand("mmo_satiety", "Define a saciedade. Uso: mmo_satiety <0-100>", (ConsoleEvent)obj5, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj6 = <>c.<>9__0_5;
			if (obj6 == null)
			{
				ConsoleEvent val6 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					PlayerProgress local = PlayerProgress.Local;
					if (local == null)
					{
						args.Context.AddString("Nenhum personagem ativo.");
					}
					else
					{
						local.Reset();
						local.SaveTo(localPlayer);
						MmoUI.RefreshStats(localPlayer);
						args.Context.AddString("Progressao zerada.");
					}
				};
				<>c.<>9__0_5 = val6;
				obj6 = (object)val6;
			}
			new ConsoleCommand("mmo_reset", "Zera completamente a progressao do personagem atual.", (ConsoleEvent)obj6, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj7 = <>c.<>9__0_6;
			if (obj7 == null)
			{
				ConsoleEvent val7 = delegate(ConsoleEventArgs args)
				{
					DumpEquipmentMap(args.Context);
				};
				<>c.<>9__0_6 = val7;
				obj7 = (object)val7;
			}
			new ConsoleCommand("mmo_dumpequip", "Gera o mapeamento real de equipamento por criatura em um arquivo markdown.", (ConsoleEvent)obj7, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj8 = <>c.<>9__0_7;
			if (obj8 == null)
			{
				ConsoleEvent val8 = delegate(ConsoleEventArgs args)
				{
					DumpItems(args.Context);
				};
				<>c.<>9__0_7 = val8;
				obj8 = (object)val8;
			}
			new ConsoleCommand("mmo_dumpitems", "Lista todos os itens de jogador equipaveis (nome, tipo, armor, dano) em um arquivo markdown.", (ConsoleEvent)obj8, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj9 = <>c.<>9__0_8;
			if (obj9 == null)
			{
				ConsoleEvent val9 = delegate(ConsoleEventArgs args)
				{
					Hud hud = Hud.instance;
					StringBuilder sb;
					if ((Object)(object)hud == (Object)null)
					{
						args.Context.AddString("HUD nao carregado.");
					}
					else
					{
						object obj22;
						if (!((Object)(object)hud.m_healthPanel != (Object)null))
						{
							RectTransform healthBarRoot = hud.m_healthBarRoot;
							obj22 = ((healthBarRoot != null) ? ((Transform)healthBarRoot).parent : null);
						}
						else
						{
							obj22 = ((Component)hud.m_healthPanel).transform;
						}
						Transform val22 = (Transform)obj22;
						if ((Object)(object)val22 == (Object)null)
						{
							args.Context.AddString("Painel de vida nao encontrado.");
						}
						else
						{
							sb = new StringBuilder();
							sb.AppendLine("# Hierarquia de " + ((Object)val22).name);
							sb.AppendLine();
							sb.AppendLine("Marcadores: [healthBarRoot] [foodBarRoot] [foodBaseBar] [foodIcon] [foodText]");
							sb.AppendLine();
							Walk(val22, 0);
							string text = Path.Combine(Paths.ConfigPath, "ValheimMMO_hud.md");
							File.WriteAllText(text, sb.ToString(), Encoding.UTF8);
							args.Context.AddString("Arquivo: " + text);
						}
					}
					void Walk(Transform t, int depth)
					{
						//IL_0172: Unknown result type (might be due to invalid IL or missing references)
						//IL_0180: Unknown result type (might be due to invalid IL or missing references)
						//IL_0185: Unknown result type (might be due to invalid IL or missing references)
						//IL_0189: Unknown result type (might be due to invalid IL or missing references)
						//IL_0197: Unknown result type (might be due to invalid IL or missing references)
						//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
						//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
						RectTransform val23 = (RectTransform)(object)((t is RectTransform) ? t : null);
						string text2 = "";
						if ((Object)(object)t == (Object)(object)hud.m_healthBarRoot)
						{
							text2 += " [healthBarRoot]";
						}
						if ((Object)(object)t == (Object)(object)hud.m_foodBarRoot)
						{
							text2 += " [foodBarRoot]";
						}
						if ((Object)(object)t == (Object)(object)hud.m_foodBaseBar)
						{
							text2 += " [foodBaseBar]";
						}
						if ((Object)(object)hud.m_foodIcon != (Object)null && (Object)(object)t == (Object)(object)((Component)hud.m_foodIcon).transform)
						{
							text2 += " [foodIcon]";
						}
						if ((Object)(object)hud.m_foodText != (Object)null && (Object)(object)t == (Object)(object)hud.m_foodText.transform)
						{
							text2 += " [foodText]";
						}
						List<string> list = new List<string>();
						Component[] components = ((Component)t).GetComponents<Component>();
						foreach (Component val24 in components)
						{
							if (!((Object)(object)val24 == (Object)null) && !(val24 is Transform))
							{
								string text3 = ((object)val24).GetType().Name;
								Graphic val25 = (Graphic)(object)((val24 is Graphic) ? val24 : null);
								if (val25 != null)
								{
									text3 += (((Behaviour)val25).enabled ? "" : "(off)");
								}
								list.Add(text3);
							}
						}
						object obj23;
						if (!((Object)(object)val23 != (Object)null))
						{
							obj23 = "";
						}
						else
						{
							object[] obj24 = new object[5] { val23.anchoredPosition, null, null, null, null };
							Rect rect = val23.rect;
							obj24[1] = ((Rect)(ref rect)).size;
							obj24[2] = val23.anchorMin;
							obj24[3] = val23.anchorMax;
							obj24[4] = val23.pivot;
							obj23 = string.Format("pos={0} size={1} anchors=({2},{3}) pivot={4}", obj24);
						}
						string text4 = (string)obj23;
						sb.AppendLine(new string(' ', depth * 2) + "- " + ((Object)t).name + (((Component)t).gameObject.activeSelf ? "" : " (inativo)") + text2 + "  <" + string.Join(", ", list) + ">  " + text4);
						for (int j = 0; j < t.childCount; j++)
						{
							Walk(t.GetChild(j), depth + 1);
						}
					}
				};
				<>c.<>9__0_8 = val9;
				obj9 = (object)val9;
			}
			new ConsoleCommand("mmo_dumphud", "Despeja a hierarquia do painel de vida do HUD (nomes, tipos, tamanhos) para diagnostico.", (ConsoleEvent)obj9, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj10 = <>c.<>9__0_9;
			if (obj10 == null)
			{
				ConsoleEvent val10 = delegate(ConsoleEventArgs args)
				{
					//IL_005d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0068: Unknown result type (might be due to invalid IL or missing references)
					//IL_0072: Unknown result type (might be due to invalid IL or missing references)
					//IL_0077: Unknown result type (might be due to invalid IL or missing references)
					//IL_007c: Unknown result type (might be due to invalid IL or missing references)
					//IL_007e: Unknown result type (might be due to invalid IL or missing references)
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("Nenhum personagem ativo.");
					}
					else
					{
						int result;
						DungeonTier dungeonTier = DungeonBosses.TierById((args.Length <= 1 || !int.TryParse(args[1], out result)) ? 1 : result);
						if (dungeonTier == null)
						{
							args.Context.AddString("Tier invalido (1-6).");
						}
						else
						{
							Vector3 pos = ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 6f;
							if (DungeonBosses.Spawn(dungeonTier, pos, out var error))
							{
								args.Context.AddString("Boss '" + dungeonTier.Title + "' spawnado.");
							}
							else
							{
								args.Context.AddString("Falha: " + error);
							}
						}
					}
				};
				<>c.<>9__0_9 = val10;
				obj10 = (object)val10;
			}
			new ConsoleCommand("mmo_spawndungeonboss", "Spawna um boss de dungeon na sua frente. Uso: mmo_spawndungeonboss <tier 1-6>", (ConsoleEvent)obj10, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj11 = <>c.<>9__0_10;
			if (obj11 == null)
			{
				ConsoleEvent val11 = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
					{
						args.Context.AddString("Entre em um mundo primeiro.");
					}
					else
					{
						WorldBoss.SpawnNow();
						args.Context.AddString("Chefe mundial invocado. Siga o pin no mapa.");
					}
				};
				<>c.<>9__0_10 = val11;
				obj11 = (object)val11;
			}
			new ConsoleCommand("mmo_worldboss", "Spawna um chefe mundial do bioma a 150-200 m de voce, com anuncio e pin para todos (teste).", (ConsoleEvent)obj11, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj12 = <>c.<>9__0_11;
			if (obj12 == null)
			{
				ConsoleEvent val12 = delegate(ConsoleEventArgs args)
				{
					RandEventSystem instance = RandEventSystem.instance;
					if ((Object)(object)instance == (Object)null)
					{
						args.Context.AddString("RandEventSystem nao carregado.");
					}
					else
					{
						StringBuilder stringBuilder = new StringBuilder();
						stringBuilder.AppendLine("| Evento | Musica | Ambiente | Duracao | Spawns |");
						stringBuilder.AppendLine("|---|---|---|---|---|");
						foreach (RandomEvent @event in instance.m_events)
						{
							stringBuilder.AppendLine($"| `{@event.m_name}` | {@event.m_forceMusic} | {@event.m_forceEnvironment} | {@event.m_duration} | {@event.m_spawn?.Count ?? 0} |");
						}
						string text = Path.Combine(Paths.ConfigPath, "ValheimMMO_events.md");
						File.WriteAllText(text, stringBuilder.ToString(), Encoding.UTF8);
						args.Context.AddString($"{instance.m_events.Count} eventos. Arquivo: {text}");
					}
				};
				<>c.<>9__0_11 = val12;
				obj12 = (object)val12;
			}
			new ConsoleCommand("mmo_dumpevents", "Lista os eventos do RandEventSystem (nome, musica forcada) para conferir os eventos de boss.", (ConsoleEvent)obj12, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj13 = <>c.<>9__0_12;
			if (obj13 == null)
			{
				ConsoleEvent val13 = delegate(ConsoleEventArgs args)
				{
					//IL_0071: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)ZoneSystem.instance == (Object)null)
					{
						args.Context.AddString("Entre em um mundo primeiro.");
					}
					else
					{
						StringBuilder stringBuilder = new StringBuilder();
						stringBuilder.AppendLine("| Location | Bioma | Unica | Icone |");
						stringBuilder.AppendLine("|---|---|---|---|");
						foreach (ZoneLocation location in ZoneSystem.instance.m_locations)
						{
							if (location != null)
							{
								stringBuilder.AppendLine(string.Format("| `{0}` | {1} | {2} | {3} |", location.m_prefabName, location.m_biome, location.m_unique ? "sim" : "", (location.m_iconAlways || location.m_iconPlaced) ? "sim" : ""));
							}
						}
						string text = Path.Combine(Paths.ConfigPath, "ValheimMMO_locations.md");
						File.WriteAllText(text, stringBuilder.ToString(), Encoding.UTF8);
						args.Context.AddString($"{ZoneSystem.instance.m_locations.Count} locations. Arquivo: {text}");
					}
				};
				<>c.<>9__0_12 = val13;
				obj13 = (object)val13;
			}
			new ConsoleCommand("mmo_dumplocations", "Lista as locations do mundo (nome, bioma) para conferir os altares usados como ancora das cidades.", (ConsoleEvent)obj13, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj14 = <>c.<>9__0_13;
			if (obj14 == null)
			{
				ConsoleEvent val14 = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)ObjectDB.instance == (Object)null)
					{
						args.Context.AddString("Entre em um mundo primeiro.");
					}
					else
					{
						MerchantItems.Invalidate();
						StringBuilder stringBuilder = new StringBuilder();
						stringBuilder.AppendLine("| Prefab | Tier | Bioma | Como |");
						stringBuilder.AppendLine("|---|---|---|---|");
						int[] array = new int[8];
						foreach (TradeItem item in MerchantItems.List)
						{
							string name = ((Object)((Component)item.m_prefab).gameObject).name;
							int num = BiomeTiers.TierOf(name);
							array[Mathf.Clamp(num, 0, 7)]++;
							stringBuilder.AppendLine($"| `{name}` | {num} | {BiomeTiers.Name(num)} | {BiomeTiers.WhyOf(name)} |");
						}
						stringBuilder.AppendLine();
						for (int i = 0; i <= 7; i++)
						{
							stringBuilder.AppendLine($"- Tier {i} ({BiomeTiers.Name(i)}): {array[i]} itens");
						}
						string text = Path.Combine(Paths.ConfigPath, "ValheimMMO_tiers.md");
						File.WriteAllText(text, stringBuilder.ToString(), Encoding.UTF8);
						args.Context.AddString("Arquivo: " + text);
					}
				};
				<>c.<>9__0_13 = val14;
				obj14 = (object)val14;
			}
			new ConsoleCommand("mmo_dumptiers", "Lista o bioma (tier) atribuido a cada item do catalogo e por que.", (ConsoleEvent)obj14, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj15 = <>c.<>9__0_14;
			if (obj15 == null)
			{
				ConsoleEvent val15 = delegate(ConsoleEventArgs args)
				{
					DumpPrices(args.Context);
				};
				<>c.<>9__0_14 = val15;
				obj15 = (object)val15;
			}
			new ConsoleCommand("mmo_dumpprices", "Lista o catalogo do mercador com preco e origem de cada preco em um arquivo markdown.", (ConsoleEvent)obj15, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj16 = <>c.<>9__0_15;
			if (obj16 == null)
			{
				ConsoleEvent val16 = delegate(ConsoleEventArgs args)
				{
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Unknown result type (might be due to invalid IL or missing references)
					//IL_003b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0040: Unknown result type (might be due to invalid IL or missing references)
					//IL_004b: Unknown result type (might be due to invalid IL or missing references)
					Player localPlayer = Player.m_localPlayer;
					string error;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("Nenhum personagem ativo.");
					}
					else if (MerchantSpawner.Spawn(((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 3f, ((Component)localPlayer).transform.position, out error))
					{
						ZoneSystem instance = ZoneSystem.instance;
						if (instance != null)
						{
							instance.SetGlobalKey("mmo_merchant_spawned");
						}
						args.Context.AddString("Mercador spawnado.");
					}
					else
					{
						args.Context.AddString("Falha: " + error);
					}
				};
				<>c.<>9__0_15 = val16;
				obj16 = (object)val16;
			}
			new ConsoleCommand("mmo_spawnmerchant", "Spawna o mercador na sua frente (admin/teste).", (ConsoleEvent)obj16, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj17 = <>c.<>9__0_16;
			if (obj17 == null)
			{
				ConsoleEvent val17 = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)ZoneSystem.instance == (Object)null)
					{
						args.Context.AddString("Entre em um mundo primeiro.");
					}
					else
					{
						ZoneSystem.instance.RemoveGlobalKey("mmo_merchant_spawned");
						MerchantItems.Invalidate();
						args.Context.AddString("Marca removida. Va ate as pedras iniciais para ele reaparecer.");
					}
				};
				<>c.<>9__0_16 = val17;
				obj17 = (object)val17;
			}
			new ConsoleCommand("mmo_resetmerchant", "Remove a marca de 'mercador ja spawnado' deste mundo, para ele ser recriado no spawn.", (ConsoleEvent)obj17, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj18 = <>c.<>9__0_17;
			if (obj18 == null)
			{
				ConsoleEvent val18 = delegate(ConsoleEventArgs args)
				{
					//IL_0066: 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_006b: Unknown result type (might be due to invalid IL or missing references)
					//IL_02be: Unknown result type (might be due to invalid IL or missing references)
					//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
					//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
					//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
					//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
					//IL_0202: Unknown result type (might be due to invalid IL or missing references)
					//IL_0240: Unknown result type (might be due to invalid IL or missing references)
					//IL_0285: Unknown result type (might be due to invalid IL or missing references)
					//IL_012b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0130: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)ZNet.instance == (Object)null)
					{
						args.Context.AddString("Entre em um mundo primeiro.");
					}
					else if (!ZNet.instance.IsServer())
					{
						args.Context.AddString("So funciona no host/servidor (a lista de locations vive la).");
					}
					else
					{
						Vector3 val22 = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
						int result2;
						if (args.Length >= 3 && args[1].ToLowerInvariant() == "demolish" && int.TryParse(args[2], out var result))
						{
							int num = 0;
							ZNetView[] array = Object.FindObjectsByType<ZNetView>((FindObjectsSortMode)0);
							foreach (ZNetView val23 in array)
							{
								if (val23.IsValid())
								{
									ZDO zDO = val23.GetZDO();
									if ((zDO.GetBool("mmo_city_piece", false) || zDO.GetBool("mmo_city_portal", false) || zDO.GetInt("mmo_city", 0) == result || zDO.GetInt("mmo_guard", 0) == result || zDO.GetBool("mmo_city_test", false)) && !(Vector3.Distance(((Component)val23).transform.position, val22) > 120f))
									{
										val23.ClaimOwnership();
										ZNetScene.instance.Destroy(((Component)val23).gameObject);
										num++;
									}
								}
							}
							CitySystem.ResetFounded(result);
							args.Context.AddString($"{num} objetos removidos; tier {result} liberado. Ela renasce (no anel novo) quando alguem chegar perto do altar.");
						}
						else if (args.Length >= 2 && int.TryParse(args[1], out result2))
						{
							CityDef cityDef = CitySystem.ByTier(result2);
							if (cityDef == null)
							{
								args.Context.AddString("Tier invalido (1-7).");
							}
							else
							{
								string anchorName;
								Vector3? val24 = CitySystem.AnchorPositionFor(result2, val22, out anchorName);
								if (!val24.HasValue)
								{
									args.Context.AddString("Altar '" + anchorName + "' nao existe neste mundo.");
								}
								else
								{
									float num2 = Vector3.Distance(val22, val24.Value);
									if (num2 > 60f)
									{
										args.Context.AddString($"Voce esta a {num2:0} m do altar '{anchorName}'. O terreno so existe carregado a ate ~60 m; chegue mais perto (ou espere: ela nasce sozinha).");
									}
									else
									{
										CitySystem.ResetFounded(result2);
										string error;
										bool flag = CitySystem.Found(cityDef, val24.Value, Player.m_localPlayer, out error);
										args.Context.AddString(flag ? $"{cityDef.Name} fundada em {val24.Value} (altar a {num2:0} m de voce)." : ("Falha ao fundar " + cityDef.Name + ": " + error));
									}
								}
							}
						}
						else
						{
							CityDef[] defs = CitySystem.Defs;
							foreach (CityDef cityDef2 in defs)
							{
								string anchorName2;
								Vector3? val25 = CitySystem.AnchorPositionFor(cityDef2.Tier, val22, out anchorName2);
								string text = ((!val25.HasValue) ? "altar NAO encontrado" : $"altar a {Vector3.Distance(val22, val25.Value):0} m");
								args.Context.AddString(string.Format("[{0}] {1} <- {2}: {3}; {4}", cityDef2.Tier, cityDef2.Name, anchorName2, text, CitySystem.IsFounded(cityDef2.Tier) ? "FUNDADA" : "nao fundada"));
							}
							args.Context.AddString("Fundacao automatica: servidor, quando alguem chega a 100 m do altar. Forcar: mmo_city <tier>.");
						}
					}
				};
				<>c.<>9__0_17 = val18;
				obj18 = (object)val18;
			}
			new ConsoleCommand("mmo_city", "Sem argumento: estado das cidades (altar, distancia, fundada). Com tier (1-7): funda a cidade agora ao lado do altar, mesmo longe.", (ConsoleEvent)obj18, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj19 = <>c.<>9__0_18;
			if (obj19 == null)
			{
				ConsoleEvent val19 = delegate(ConsoleEventArgs args)
				{
					//IL_010a: Unknown result type (might be due to invalid IL or missing references)
					//IL_010f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0129: Unknown result type (might be due to invalid IL or missing references)
					//IL_012e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0134: Unknown result type (might be due to invalid IL or missing references)
					//IL_0139: Unknown result type (might be due to invalid IL or missing references)
					//IL_013e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0145: Unknown result type (might be due to invalid IL or missing references)
					//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
					//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
					//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
					//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
					//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
					//IL_0201: Unknown result type (might be due to invalid IL or missing references)
					//IL_0206: Unknown result type (might be due to invalid IL or missing references)
					//IL_020d: Unknown result type (might be due to invalid IL or missing references)
					//IL_027d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0159: Unknown result type (might be due to invalid IL or missing references)
					//IL_015a: Unknown result type (might be due to invalid IL or missing references)
					//IL_015f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0164: Unknown result type (might be due to invalid IL or missing references)
					//IL_0168: Unknown result type (might be due to invalid IL or missing references)
					//IL_017b: Unknown result type (might be due to invalid IL or missing references)
					//IL_023e: Unknown result type (might be due to invalid IL or missing references)
					//IL_022d: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)ZNetScene.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
					{
						args.Context.AddString("Entre em um mundo primeiro.");
					}
					else
					{
						Player localPlayer = Player.m_localPlayer;
						string text = ((args.Length >= 2) ? args[1].ToLowerInvariant() : "help");
						int result = 1;
						switch (text)
						{
						case "reload":
							args.Context.AddString("Plano: " + CityBuilder.Reload());
							break;
						case "export":
							args.Context.AddString(CityBuilder.ExportBuiltin() + " -- edite e use mmo_cityplan reload");
							break;
						case "build":
							if (args.Length < 3)
							{
								args.Context.AddString("mmo_cityplan build <template> [tier]");
							}
							else
							{
								if (args.Length >= 4)
								{
									int.TryParse(args[3], out result);
								}
								Vector3 forward2 = ((Component)localPlayer).transform.forward;
								forward2.y = 0f;
								((Vector3)(ref forward2)).Normalize();
								Vector3 val23 = ((Component)localPlayer).transform.position + forward2 * 8f;
								float y2 = default(float);
								if (ZoneSystem.instance.GetGroundHeight(val23, ref y2))
								{
									val23.y = y2;
								}
								Quaternion val24 = Quaternion.LookRotation(-forward2);
								float y3 = ((Quaternion)(ref val24)).eulerAngles.y;
								int num2 = CityBuilder.BuildTemplate(args[2], val23, y3, result, test: true);
								args.Context.AddString($"{num2} pecas ({args[2]}, tier {result}). mmo_cityplan clear remove.");
							}
							break;
						case "village":
						{
							if (args.Length >= 3)
							{
								int.TryParse(args[2], out result);
							}
							Vector3 forward = ((Component)localPlayer).transform.forward;
							forward.y = 0f;
							((Vector3)(ref forward)).Normalize();
							Vector3 val22 = ((Component)localPlayer).transform.position + forward * 20f;
							float y = default(float);
							if (ZoneSystem.instance.GetGroundHeight(val22, ref y))
							{
								val22.y = y;
							}
							if (ModConfig.CityLevelTerrain.Value)
							{
								Terraform.Level(val22, ModConfig.CityLevelRadius.Value);
							}
							int num = CityBuilder.BuildVillage(val22, result, test: true);
							args.Context.AddString($"{num} pecas (vila tier {result}, sem NPCs). mmo_cityplan clear remove.");
							break;
						}
						case "clear":
							args.Context.AddString($"{CityBuilder.ClearTest(((Component)localPlayer).transform.position, 80f)} pecas de teste removidas.");
							break;
						default:
							args.Context.AddString("mmo_cityplan reload | export | build <template> [tier] | village [tier] | clear");
							break;
						}
					}
				};
				<>c.<>9__0_18 = val19;
				obj19 = (object)val19;
			}
			new ConsoleCommand("mmo_cityplan", "Plantas das cidades. reload | export | build <template> [tier] | village [tier] | clear. build/village constroem na sua frente como TESTE (clear remove).", (ConsoleEvent)obj19, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj20 = <>c.<>9__0_19;
			if (obj20 == null)
			{
				ConsoleEvent val20 = delegate(ConsoleEventArgs args)
				{
					//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
					//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
					//IL_0181: Unknown result type (might be due to invalid IL or missing references)
					//IL_0195: Unknown result type (might be due to invalid IL or missing references)
					//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
					//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
					//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
					//IL_01de: Unknown result type (might be due to invalid IL or missing references)
					//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)ZNetScene.instance == (Object)null)
					{
						args.Context.AddString("Entre em um mundo primeiro.");
					}
					else
					{
						StringBuilder stringBuilder = new StringBuilder();
						stringBuilder.AppendLine("| Prefab | Categoria | Estacao | Tamanho (x y z) | Centro - pivo (x y z) | Material |");
						stringBuilder.AppendLine("|---|---|---|---|---|---|");
						int num = 0;
						foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
						{
							if (!((Object)(object)prefab == (Object)null))
							{
								Piece component = prefab.GetComponent<Piece>();
								if (!((Object)(object)component == (Object)null) && !((Object)(object)prefab.GetComponent<ItemDrop>() != (Object)null))
								{
									Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
									if (componentsInChildren.Length != 0)
									{
										Bounds bounds = componentsInChildren[0].bounds;
										Renderer[] array = componentsInChildren;
										foreach (Renderer val22 in array)
										{
											((Bounds)(ref bounds)).Encapsulate(val22.bounds);
										}
										Vector3 val23 = ((Bounds)(ref bounds)).center - prefab.transform.position;
										WearNTear component2 = prefab.GetComponent<WearNTear>();
										string text = (((Object)(object)component.m_craftingStation != (Object)null) ? ((Object)component.m_craftingStation).name : "");
										string text2 = ((component.m_resources != null && component.m_resources.Length != 0 && (Object)(object)component.m_resources[0].m_resItem != (Object)null) ? ((Object)component.m_resources[0].m_resItem).name : "");
										stringBuilder.AppendLine(string.Format("| `{0}` | {1} | {2} | {3:0.0} {4:0.0} {5:0.0} | {6:0.0} {7:0.0} {8:0.0} | {9}{10} |", ((Object)prefab).name, component.m_category, text, ((Bounds)(ref bounds)).size.x, ((Bounds)(ref bounds)).size.y, ((Bounds)(ref bounds)).size.z, val23.x, val23.y, val23.z, text2, ((Object)(object)component2 != (Object)null) ? (" " + ((object)Unsafe.As<MaterialType, MaterialType>(ref component2.m_materialType)/*cast due to .constrained prefix*/).ToString()) : ""));
										num++;
									}
								}
							}
						}
						string text3 = Path.Combine(Paths.ConfigPath, "ValheimMMO_pieces.md");
						File.WriteAllText(text3, stringBuilder.ToString(), Encoding.UTF8);
						args.Context.AddString($"{num} pecas. Arquivo: {text3}");
					}
				};
				<>c.<>9__0_19 = val20;
				obj20 = (object)val20;
			}
			new ConsoleCommand("mmo_dumppieces", "Lista as pecas de construcao (nome, categoria, tamanho e deslocamento do pivo) em BepInEx/config/ValheimMMO_pieces.md -- base para as plantas das cidades.", (ConsoleEvent)obj20, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj21 = <>c.<>9__0_20;
			if (obj21 == null)
			{
				ConsoleEvent val21 = delegate(ConsoleEventArgs args)
				{
					int result;
					if ((Object)(object)ZoneSystem.instance == (Object)null)
					{
						args.Context.AddString("Entre em um mundo primeiro.");
					}
					else if (args.Length >= 2 && int.TryParse(args[1], out result))
					{
						CitySystem.ResetFounded(result);
						args.Context.AddString($"Marca do tier {result} removida.");
					}
					else
					{
						CityDef[] defs = CitySystem.Defs;
						for (int i = 0; i < defs.Length; i++)
						{
							CitySystem.ResetFounded(defs[i].Tier);
						}
						args.Context.AddString("Marcas de todos os tiers removidas. Cuidado: cidades ja construidas serao construidas de novo ao chegar perto.");
					}
				};
				<>c.<>9__0_20 = val21;
				obj21 = (object)val21;
			}
			new ConsoleCommand("mmo_resetcities", "mmo_resetcities <tier> remove a marca de 'cidade fundada' daquele tier (ela renasce ao chegar perto do altar; pecas ja colocadas ficam). Sem tier: todos.", (ConsoleEvent)obj21, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}

		private static void DumpPrices(Terminal ctx)
		{
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ObjectDB.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				ctx.AddString("Entre em um mundo primeiro.");
				return;
			}
			MerchantItems.Invalidate();
			List<TradeItem> list = MerchantItems.List;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("# Catalogo do mercador");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"Gerado em {DateTime.Now:yyyy-MM-dd HH:mm}. {list.Count} itens. Precos em moedas.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"Dia do mundo: **{MerchantItems.CurrentDay()}** - inflacao vigente: **x{MerchantItems.InflationMultiplier():0.00}** " + $"(+{ModConfig.MerchantInflationPercent.Value:0}% a cada {ModConfig.MerchantInflationEveryDays.Value} dias, teto x{ModConfig.MerchantInflationMaxMultiplier.Value:0.#}). " + "Colunas 'Preco lote' e 'Unitario' ja incluem a inflacao.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("Origem: Base = materia-prima da config; Recipe = receita; Conversion = fornalha/fogueira/fermentador; ");
			stringBuilder.AppendLine("CreatureDrop = vida da criatura; Gathered/Mined = coletado/minerado; VanillaValue = valor de venda do jogo; ");
			stringBuilder.AppendLine("**Unknown** = sem origem conhecida, usa UnknownBase -- revise e coloque em BasePrices ou PriceOverrides.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("| Prefab | Nome | Tipo | Lote | Preco lote | Unitario | Origem | Como |");
			stringBuilder.AppendLine("|---|---|---|---|---|---|---|---|");
			int num = 0;
			foreach (TradeItem item in list)
			{
				string name = ((Object)((Component)item.m_prefab).gameObject).name;
				string text = Localization.instance.Localize(item.m_prefab.m_itemData.m_shared.m_name);
				string text2 = MerchantPricing.SourceOf(name);
				if (text2 == "Unknown")
				{
					num++;
					text2 = "**Unknown**";
				}
				int num2 = item.m_price / Math.Max(1, item.m_stack);
				stringBuilder.AppendLine($"| `{name}` | {text} | {item.m_prefab.m_itemData.m_shared.m_itemType} | {item.m_stack} | {item.m_price} | {num2} | {text2} | {MerchantPricing.WhyOf(name)} |");
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"Itens sem origem conhecida: **{num}**");
			string text3 = Path.Combine(Paths.ConfigPath, "ValheimMMO_prices.md");
			try
			{
				File.WriteAllText(text3, stringBuilder.ToString(), Encoding.UTF8);
				ctx.AddString($"{list.Count} itens, {num} sem origem.");
				ctx.AddString("Arquivo: " + text3);
			}
			catch (Exception ex)
			{
				ctx.AddString("Falha ao escrever o arquivo: " + ex.Message);
				Plugin.Log.LogError((object)ex);
			}
		}

		private static void DumpItems(Terminal ctx)
		{
			//IL_0081: 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)
			if ((Object)(object)ObjectDB.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				ctx.AddString("Entre em um mundo primeiro.");
				return;
			}
			List<(string, string)> list = new List<(string, string)>();
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if (!((Object)(object)item == (Object)null))
				{
					SharedData val = item.GetComponent<ItemDrop>()?.m_itemData?.m_shared;
					if (val != null && !(EquipmentDrops.ChanceFor(val.m_itemType) <= 0f))
					{
						bool flag = EquipmentDrops.IsDroppable(((Object)item).name);
						string text = Localization.instance.Localize(val.m_name ?? "");
						float totalDamage = ((DamageTypes)(ref val.m_damages)).GetTotalDamage();
						float totalDamage2 = ((DamageTypes)(ref val.m_damagesPerLevel)).GetTotalDamage();
						list.Add((((object)Unsafe.As<ItemType, ItemType>(ref val.m_itemType)/*cast due to .constrained prefix*/).ToString(), string.Format("| `{0}` | {1} | {2} | {3} | ", ((Object)item).name, text, val.m_itemType, flag ? "sim" : "NAO") + $"{val.m_armor:0.#} (+{val.m_armorPerLevel:0.#}/nv) | " + $"{totalDamage:0.#} (+{totalDamage2:0.#}/nv) | {val.m_blockPower:0.#} | " + $"{val.m_movementModifier * 100f:+0;-0;0}% | {val.m_eitrRegenModifier * 100f:+0;-0;0}% | " + $"{val.m_maxQuality} |"));
					}
				}
			}
			list.Sort(delegate((string type, string row) a, (string type, string row) b)
			{
				int num = string.Compare(a.type, b.type, StringComparison.Ordinal);
				return (num == 0) ? string.Compare(a.row, b.row, StringComparison.OrdinalIgnoreCase) : num;
			});
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("# Itens de jogador equipaveis");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"Gerado em {DateTime.Now:yyyy-MM-dd HH:mm} a partir do ObjectDB. {list.Count} itens.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("`Dropavel` = tem ZNetView + ItemDrop, pode ser alvo do CreatureItemRemap.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("| Prefab | Nome | Tipo | Dropavel | Armor | Dano | Bloqueio | Movimento | Regen eitr | Qualid. max |");
			stringBuilder.AppendLine("|---|---|---|---|---|---|---|---|---|---|");
			foreach (var item2 in list)
			{
				stringBuilder.AppendLine(item2.Item2);
			}
			string text2 = Path.Combine(Paths.ConfigPath, "ValheimMMO_items.md");
			try
			{
				File.WriteAllText(text2, stringBuilder.ToString(), Encoding.UTF8);
				ctx.AddString($"{list.Count} itens listados.");
				ctx.AddString("Arquivo: " + text2);
			}
			catch (Exception ex)
			{
				ctx.AddString("Falha ao escrever o arquivo: " + ex.Message);
				Plugin.Log.LogError((object)ex);
			}
		}

		private static void DumpEquipmentMap(Terminal ctx)
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				ctx.AddString("Entre em um mundo primeiro (ZNetScene nao esta carregado).");
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("# Mapeamento de equipamento por criatura");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"Gerado em {DateTime.Now:yyyy-MM-dd HH:mm} a partir dos prefabs carregados.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("`Fixos` sempre vem. `Arma` / `Escudo` / `Armadura` sao sorteados 1 de N");
			stringBuilder.AppendLine("usando a seed da criatura. `Conjuntos` sorteia 1 conjunto inteiro.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("Legenda por item: `OK` = item de jogador (tem ZNetView), cai direto. ");
			stringBuilder.AppendLine("`-> X` = arma interna traduzida para X pelo CreatureItemRemap. ");
			stringBuilder.AppendLine("**(!)** = arma interna com modelo visual mas SEM remap: hoje e ignorada. ");
			stringBuilder.AppendLine("<sub>pequeno</sub> = ataque sem modelo, ou item nao-equipamento: nunca dropa por esta regra.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("| Criatura | Boss | Fixos | Arma (1 de N) | Escudo (1 de N) | Armadura (1 de N) | Conjuntos |");
			stringBuilder.AppendLine("|---|---|---|---|---|---|---|");
			_unmapped.Clear();
			int num = 0;
			List<string> list = new List<string>();
			foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
			{
				if ((Object)(object)prefab == (Object)null)
				{
					continue;
				}
				Humanoid component = prefab.GetComponent<Humanoid>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)prefab.GetComponent<Player>() != (Object)null))
				{
					string text = Names(component.m_defaultItems);
					string text2 = Names(component.m_randomWeapon);
					string text3 = Names(component.m_randomShield);
					string text4 = Names(component.m_randomArmor);
					string text5 = SetNames(component.m_randomSets);
					if (text != "-" || text2 != "-" || text3 != "-" || text4 != "-" || text5 != "-")
					{
						num++;
						list.Add("| `" + ((Object)prefab).name + "` | " + (((Character)component).IsBoss() ? "sim" : "") + " | " + text + " | " + text2 + " | " + text3 + " | " + text4 + " | " + text5 + " |");
					}
				}
			}
			list.Sort(StringComparer.OrdinalIgnoreCase);
			foreach (string item in list)
			{
				stringBuilder.AppendLine(item);
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"Total de criaturas com equipamento: **{num}**");
			if (_unmapped.Count > 0)
			{
				List<string> list2 = new List<string>(_unmapped);
				list2.Sort(StringComparer.OrdinalIgnoreCase);
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("## Itens internos sem remap");
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("Estes prefabs estao no inventario de criaturas mas nao estao registrados na rede,");
				stringBuilder.AppendLine("logo nao podem cair no chao. Preencha o item de jogador equivalente e cole em");
				stringBuilder.AppendLine("`CreatureItemRemap` no arquivo de config:");
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("```");
				stringBuilder.AppendLine(string.Join(",", list2.ConvertAll((string n) => n + "=")));
				stringBuilder.AppendLine("```");
			}
			string text6 = Path.Combine(Paths.ConfigPath, "ValheimMMO_equipment_map.md");
			try
			{
				File.WriteAllText(text6, stringBuilder.ToString(), Encoding.UTF8);
				ctx.AddString($"{num} criaturas mapeadas.");
				ctx.AddString("Arquivo: " + text6);
			}
			catch (Exception ex)
			{
				ctx.AddString("Falha ao escrever o arquivo: " + ex.Message);
				Plugin.Log.LogError((object)ex);
			}
		}

		private static string Annotate(GameObject go)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			string name = ((Object)go).name;
			ItemDrop component = go.GetComponent<ItemDrop>();
			if (!((Object)(object)component != (Object)null) || component.m_itemData?.m_shared == null || !(EquipmentDrops.ChanceFor(component.m_itemData.m_shared.m_itemType) > 0f))
			{
				return "<sub>" + name + "</sub>";
			}
			if (EquipmentDrops.IsDroppable(name))
			{
				return "`" + name + "` OK";
			}
			if (!((Object)(object)go.GetComponentInChildren<Renderer>(true) != (Object)null))
			{
				return "<sub>" + name + " (ataque)</sub>";
			}
			string text = EquipmentDrops.RemapFor(name);
			if (text != null)
			{
				bool flag = true;
				foreach (KeyValuePair<string, float> item in EquipmentDrops.RemapChoices(name))
				{
					if (!EquipmentDrops.IsDroppable(item.Key))
					{
						flag = false;
					}
				}
				if (!flag)
				{
					_unmapped.Add(name);
				}
				if (!flag)
				{
					return "`" + name + "` -> `" + text + "` **(remap invalido!)**";
				}
				return "`" + name + "` -> `" + text + "`";
			}
			_unmapped.Add(name);
			return "`" + name + "` **(!)**";
		}

		private static string Names(GameObject[] items)
		{
			if (items == null || items.Length == 0)
			{
				return "-";
			}
			List<string> list = new List<string>();
			foreach (GameObject val in items)
			{
				if ((Object)(object)val != (Object)null)
				{
					list.Add(Annotate(val));
				}
			}
			if (list.Count != 0)
			{
				return string.Join(", ", list);
			}
			return "-";
		}

		private static string SetNames(ItemSet[] sets)
		{
			if (sets == null || sets.Length == 0)
			{
				return "-";
			}
			List<string> list = new List<string>();
			foreach (ItemSet val in sets)
			{
				if (val?.m_items == null || val.m_items.Length == 0)
				{
					continue;
				}
				List<string> list2 = new List<string>();
				GameObject[] items = val.m_items;
				foreach (GameObject val2 in items)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						list2.Add(Annotate(val2));
					}
				}
				if (list2.Count > 0)
				{
					list.Add("**" + val.m_name + "**: " + string.Join(" + ", list2));
				}
			}
			if (list.Count != 0)
			{
				return string.Join("<br>", list);
			}
			return "-";
		}

		[CompilerGenerated]
		internal static void <Register>g__Walk|0_21(Transform t, int depth, ref <>c__DisplayClass0_0 P_2)
		{
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)(object)((t is RectTransform) ? t : null);
			string text = "";
			if ((Object)(object)t == (Object)(object)P_2.hud.m_healthBarRoot)
			{
				text += " [healthBarRoot]";
			}
			if ((Object)(object)t == (Object)(object)P_2.hud.m_foodBarRoot)
			{
				text += " [foodBarRoot]";
			}
			if ((Object)(object)t == (Object)(object)P_2.hud.m_foodBaseBar)
			{
				text += " [foodBaseBar]";
			}
			if ((Object)(object)P_2.hud.m_foodIcon != (Object)null && (Object)(object)t == (Object)(object)((Component)P_2.hud.m_foodIcon).transform)
			{
				text += " [foodIcon]";
			}
			if ((Object)(object)P_2.hud.m_foodText != (Object)null && (Object)(object)t == (Object)(object)P_2.hud.m_foodText.transform)
			{
				text += " [foodText]";
			}
			List<string> list = new List<string>();
			Component[] components = ((Component)t).GetComponents<Component>();
			foreach (Component val2 in components)
			{
				if (!((Object)(object)val2 == (Object)null) && !(val2 is Transform))
				{
					string text2 = ((object)val2).GetType().Name;
					Graphic val3 = (Graphic)(object)((val2 is Graphic) ? val2 : null);
					if (val3 != null)
					{
						text2 += (((Behaviour)val3).enabled ? "" : "(off)");
					}
					list.Add(text2);
				}
			}
			object obj;
			if (!((Object)(object)val != (Object)null))
			{
				obj = "";
			}
			else
			{
				object[] obj2 = new object[5] { val.anchoredPosition, null, null, null, null };
				Rect rect = val.rect;
				obj2[1] = ((Rect)(ref rect)).size;
				obj2[2] = val.anchorMin;
				obj2[3] = val.anchorMax;
				obj2[4] = val.pivot;
				obj = string.Format("pos={0} size={1} anchors=({2},{3}) pivot={4}", obj2);
			}
			string text3 = (string)obj;
			P_2.sb.AppendLine(new string(' ', depth * 2) + "- " + ((Object)t).name + (((Component)t).gameObject.activeSelf ? "" : " (inativo)") + text + "  <" + string.Join(", ", list) + ">  " + text3);
			for (int j = 0; j < t.childCount; j++)
			{
				<Register>g__Walk|0_21(t.GetChild(j), depth + 1, ref P_2);
			}
		}
	}
}
namespace ValheimMMO.Combat
{
	internal static class BowTweaks
	{
		private static readonly HashSet<int> Applied = new HashSet<int>();

		internal static void ApplyAll(ObjectDB db)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Invalid comparison between Unknown and I4
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			if (!ModConfig.BowTweaksEnabled.Value || (Object)(object)db == (Object)null)
			{
				return;
			}
			int num = 0;
			int num2 = 0;
			foreach (GameObject item in db.m_items)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				SharedData val = item.GetComponent<ItemDrop>()?.m_itemData?.m_shared;
				if (val == null)
				{
					continue;
				}
				bool flag = (int)val.m_skillType == 8;
				bool flag2 = (int)val.m_skillType == 14;
				if ((flag || flag2) && Applied.Add(((Object)item).GetInstanceID()))
				{
					Scale(val.m_attack, flag);
					Scale(val.m_secondaryAttack, flag);
					float value = ModConfig.BowDamageMultiplier.Value;
					if (!Mathf.Approximately(value, 1f))
					{
						((DamageTypes)(ref val.m_damages)).Modify(value);
						((DamageTypes)(ref val.m_damagesPerLevel)).Modify(value);
					}
					if (flag)
					{
						num++;
					}
					else
					{
						num2++;
					}
				}
			}
			if (num + num2 > 0)
			{
				Plugin.Log.LogInfo((object)$"[Arquearia] Ajustes aplicados a {num} arco(s) e {num2} besta(s).");
			}
		}

		private static void Scale(Attack attack, bool isBow)
		{
			if (attack != null)
			{
				attack.m_attackStamina *= ModConfig.BowAttackStaminaMultiplier.Value;
				attack.m_projectileVel *= ModConfig.BowProjectileSpeedMultiplier.Value;
				attack.m_projectileVelMin *= ModConfig.BowProjectileSpeedMultiplier.Value;
				if (isBow && attack.m_bowDraw)
				{
					attack.m_drawDurationMin *= ModConfig.BowDrawTimeMultiplier.Value;
					attack.m_drawStaminaDrain *= ModConfig.BowDrawStaminaMultiplier.Value;
				}
				if (!isBow)
				{
					attack.m_reloadTime *= ModConfig.CrossbowReloadMultiplier.Value;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	internal static class ObjectDB_Awake_BowPatch
	{
		private static void Postfix(ObjectDB __instance)
		{
			BowTweaks.ApplyAll(__instance);
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
	internal static class ObjectDB_CopyOtherDB_BowPatch
	{
		private static void Postfix(ObjectDB __instance)
		{
			BowTweaks.ApplyAll(__instance);
		}
	}
}
namespace ValheimMMO.Cities
{
	internal static class BiomeTiers
	{
		public const int Universal = 0;

		public const int Max = 7;

		private static readonly Dictionary<string, int> Cache = new Dictionary<string, int>(StringComparer.Ordinal);

		private static readonly Dictionary<string, string> Why = new Dictionary<string, string>(StringComparer.Ordinal);

		private static readonly HashSet<string> Visiting = new HashSet<string>(StringComparer.Ordinal);

		private static Dictionary<string, int> _manual;

		private static Dictionary<string, int> _auto;

		private static ObjectDB _builtFor;

		public static string Name(int tier)
		{
			return tier switch
			{
				1 => "Campos", 
				2 => "Floresta Negra", 
				3 => "Pantano", 
				4 => "Montanha", 
				5 => "Planicies", 
				6 => "Nevoa", 
				7 => "Cinzas", 
				_ => "Universal", 
			};
		}

		public static int TierOfBiome(Biome b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if ((b & 1) != 0)
			{
				return 1;
			}
			if ((b & 8) != 0)
			{
				return 2;
			}
			if ((b & 2) != 0)
			{
				return 3;
			}
			if ((b & 0x100) != 0)
			{
				return 3;
			}
			if ((b & 4) != 0)
			{
				return 4;
			}
			if ((b & 0x10) != 0)
			{
				return 5;
			}
			if ((b & 0x200) != 0)
			{
				return 6;
			}
			if ((b & 0x20) != 0)
			{
				return 7;
			}
			if ((b & 0x40) != 0)
			{
				return 7;
			}
			return 0;
		}

		public static void Invalidate()
		{
			Cache.Clear();
			Why.Clear();
			Visiting.Clear();
			_manual = null;
			_auto = null;
			_builtFor = null;
		}

		private static void EnsureBuilt()
		{
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null || (_manual != null && (Object)(object)_builtFor == (Object)(object)instance))
			{
				return;
			}
			Invalidate();
			_builtFor = instance;
			_manual = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			string[] array = (ModConfig.MaterialTiers.Value ?? "").Split(new char[3] { ',', ';', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num > 0 && int.TryParse(text.Substring(num + 1).Trim(), out var result))
				{
					_manual[text.Substring(0, num).Trim()] = Mathf.Clamp(result, 0, 7);
				}
			}
			_auto = new Dictionary<string, int>(StringComparer.Ordinal);
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				foreach (GameObject prefab2 in ZNetScene.instance.m_prefabs)
				{
					SpawnSystem val = ((prefab2 != null) ? prefab2.GetComponent<SpawnSystem>() : null);
					if (val?.m_spawnLists == null)
					{
						continue;
					}
					foreach (SpawnSystemList spawnList in val.m_spawnLists)
					{
						if (spawnList?.m_spawners == null)
						{
							continue;
						}
						foreach (SpawnData spawner in spawnList.m_spawners)
						{
							if ((Object)(object)spawner?.m_prefab == (Object)null)
							{
								continue;
							}
							int num2 = TierOfBiome(spawner.m_biome);
							if (num2 <= 0)
							{
								continue;
							}
							CharacterDrop component = spawner.m_prefab.GetComponent<CharacterDrop>();
							if (component?.m_drops == null)
							{
								continue;
							}
							foreach (Drop drop in component.m_drops)
							{
								if ((Object)(object)drop?.m_prefab != (Object)null)
								{
									Lower(_auto, ((Object)drop.m_prefab).name, num2);
								}
							}
						}
					}
				}
			}
			if (ZoneSystem.instance?.m_vegetation == null)
			{
				return;
			}
			foreach (ZoneVegetation item in ZoneSystem.instance.m_vegetation)
			{
				if ((Object)(object)item?.m_prefab == (Object)null)
				{
					continue;
				}
				int num3 = TierOfBiome(item.m_biome);
				if (num3 <= 0)
				{
					continue;
				}
				GameObject prefab = item.m_prefab;
				Pickable component2 = prefab.GetComponent<Pickable>();
				if ((Object)(object)component2?.m_itemPrefab != (Object)null)
				{
					Lower(_auto, ((Object)component2.m_itemPrefab).name, num3);
				}
				AddTable(prefab.GetComponent<DropOnDestroyed>()?.m_dropWhenDestroyed, num3);
				AddTable(prefab.GetComponent<TreeBase>()?.m_dropWhenDestroyed, num3);
				AddTable(prefab.GetComponent<TreeLog>()?.m_dropWhenDestroyed, num3);
				AddTable(prefab.GetComponent<MineRock5>()?.m_dropItems, num3);
				AddTable(prefab.GetComponent<MineRock>()?.m_dropItems, num3);
				TreeBase component3 = prefab.GetComponent<TreeBase>();
				if ((Object)(object)component3?.m_logPrefab != (Object)null)
				{
					AddTable(component3.m_logPrefab.GetComponent<TreeLog>()?.m_dropWhenDestroyed, num3);
					GameObject val2 = component3.m_logPrefab.GetComponent<TreeLog>()?.m_subLogPrefab;
					if ((Object)(object)val2 != (Object)null)
					{
						AddTable(val2.GetComponent<TreeLog>()?.m_dropWhenDestroyed, num3);
					}
				}
			}
		}

		private static void AddTable(DropTable table, int tier)
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (table?.m_drops == null)
			{
				return;
			}
			foreach (DropData drop in table.m_drops)
			{
				if ((Object)(object)drop.m_item != (Object)null)
				{
					Lower(_auto, ((Object)drop.m_item).name, tier);
				}
			}
		}

		private static void Lower(Dictionary<string, int> dict, string name, int tier)
		{
			if (!dict.TryGetValue(name, out var value) || tier < value)
			{
				dict[name] = tier;
			}
		}

		public static string WhyOf(string name)
		{
			if (!Why.TryGetValue(name, out var value))
			{
				return "";
			}
			return value;
		}

		public static int TierOf(string prefabName)
		{
			EnsureBuilt();
			if (string.IsNullOrEmpty(prefabName))
			{
				return 0;
			}
			if (Cache.TryGetValue(prefabName, out var value))
			{
				return value;
			}
			if (MapItem.IsMap(prefabName) || CustomItems.IsCustom(prefabName))
			{
				return Store(prefabName, 0, "item do mod");
			}
			if (Visiting.Contains(prefabName))
			{
				return 0;
			}
			Visiting.Add(prefabName);
			try
			{
				if (_manual != null && _manual.TryGetValue(prefabName, out var value2))
				{
					return Store(prefabName, value2, "tabela manual");
				}
				int num = -1;
				string why = "";
				ObjectDB instance = ObjectDB.instance;
				if ((Object)(object)instance != (Object)null)
				{
					foreach (Recipe recipe in instance.m_recipes)
					{
						if ((Object)(object)recipe?.m_item == (Object)null || !recipe.m_enabled || ((Object)((Component)recipe.m_item).gameObject).name != prefabName)
						{
							continue;
						}
						int num2 = 0;
						string text = "";
						Requirement[] resources = recipe.m_resources;
						foreach (Requirement val in resources)
						{
							if (!((Object)(object)val?.m_resItem == (Object)null))
							{
								int num3 = TierOf(((Object)((Component)val.m_resItem).gameObject).name);
								if (num3 > num2)
								{
									num2 = num3;
									text = ((Object)((Component)val.m_resItem).gameObject).name;
								}
							}
						}
						if (num2 > 0 && (num < 0 || num2 < num))
						{
							num = num2;
							why = "receita (insumo mais avancado: " + text + ")";
						}
					}
				}
				if (num > 0)
				{
					return Store(prefabName, num, why);
				}
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
					{
						Smelter val2 = ((prefab != null) ? prefab.GetComponent<Smelter>() : null);
						if (val2?.m_conversion != null)
						{
							foreach (ItemConversion item in val2.m_conversion)
							{
								if ((Object)(object)item?.m_to != (Object)null && (Object)(object)item.m_from != (Object)null && ((Object)((Component)item.m_to).gameObject).name == prefabName)
								{
									return Store(prefabName, Mathf.Max(1, TierOf(((Object)((Component)item.m_from).gameObject).name)), "conversao de " + ((Object)((Component)item.m_from).gameObject).name);
								}
							}
						}
						CookingStation val3 = ((prefab != null) ? prefab.GetComponent<CookingStation>() : null);
						if (val3?.m_conversion != null)
						{
							foreach (ItemConversion item2 in val3.m_conversion)
							{
								if ((Object)(object)item2?.m_to != (Object)null && (Object)(object)item2.m_from != (Object)null && ((Object)((Component)item2.m_to).gameObject).name == prefabName)
								{
									return Store(prefabName, Mathf.Max(1, TierOf(((Object)((Component)item2.m_from).gameObject).name)), "cozinha de " + ((Object)((Component)item2.m_from).gameObject).name);
								}
							}
						}
						Fermenter val4 = ((prefab != null) ? prefab.GetComponent<Fermenter>() : null);
						if (val4?.m_conversion == null)
						{
							continue;
						}
						foreach (ItemConversion item3 in val4.m_conversion)
						{
							if ((Object)(object)item3?.m_to != (Object)null && (Object)(object)item3.m_from != (Object)null && ((Object)((Component)item3.m_to).gameObject).name == prefabName)
							{
								return Store(prefabName, Mathf.Max(1, TierOf(((Object)((Component)item3.m_from).gameObject).name)), "fermentado de " + ((Object)((Component)item3.m_from).gameObject).name);
							}
						}
					}
				}
				if (_auto != null && _auto.TryGetValue(prefabName, out var value3))
				{
					return Store(prefabName, value3, "bioma de origem (spawn/vegetacao)");
				}
				int num4 = MerchantPricing.PriceOf(prefabName);
				int tier = ((num4 <= 5) ? 1 : ((num4 <= 12) ? 2 : ((num4 <= 25) ? 3 : ((num4 <= 45) ? 4 : ((num4 <= 80) ? 5 : ((num4 <= 150) ? 6 : 7))))));
				return Store(prefabName, tier, $"faixa de preco ({num4})");
			}
			finally
			{
				Visiting.Remove(prefabName);
			}
		}

		private static int Store(string name, int tier, string why)
		{
			Cache[name] = tier;
			Why[name] = why;
			return tier;
		}
	}
	internal static class CityBuilder
	{
		private sealed class Part
		{
			public string Prefab;

			public float Dy;

			public Part(string p, float dy = 0f)
			{
				Prefab = p;
				Dy = dy;
			}
		}

		private sealed class Placement
		{
			public string Token;

			public float X;

			public float Y;

			public float Z;

			public float Rot;
		}

		private sealed class Layout
		{
			public List<(string template, float x, float z, float rot)> Buildings = new List<(string, float, float, float)>();

			public float FenceRadius;

			public float GateAngle = float.NaN;
		}

		public const string ZdoTest = "mmo_city_test";

		private static readonly Dictionary<string, float> PivotAboveBottom = new Dictionary<string, float>
		{
			["woodwall"] = 1f,
			["wood_door"] = 1f,
			["wood_floor"] = 0f,
			["wood_wall_half"] = 0.5f,
			["wood_roof_45"] = 1.6f,
			["wood_roof_top_45"] = 0.15f,
			["wood_wall_roof_45"] = 0.2f,
			["wood_wall_roof_top_45"] = 0.25f,
			["wood_fence"] = 0.15f,
			["wood_gate"] = 1f,
			["wood_pole2"] = 1f,
			["wood_beam"] = 0.2f,
			["stone_wall_2x1"] = 0.6f,
			["stone_wall_1x1"] = 0.6f,
			["stone_floor_2x2"] = 0.5f,
			["stone_pillar"] = 1f,
			["piece_sharpstakes"] = 0.4f,
			["darkwood_roof_45"] = 1.35f,
			["darkwood_roof_top_45"] = 0.5f,
			["darkwood_gate"] = 0f,
			["darkwood_pole"] = 1f,
			["blackmarble_2x2x1"] = 1.05f,
			["blackmarble_floor"] = 0.55f,
			["blackmarble_1x1"] = 0.5f,
			["piece_dvergr_stake_wall"] = 0.6f,
			["ashwood_wall_2x2"] = 1f,
			["ashwood_floor_2x2"] = 0.1f,
			["ashwood_wall_roof_45"] = 0.25f,
			["ashwood_halfwall_1x2"] = 0f,
			["piece_groundtorch_wood"] = 0.7f,
			["piece_groundtorch"] = 0.65f,
			["piece_groundtorch_blue"] = 0.65f,
			["piece_chest_wood"] = 0f,
			["piece_chest_blackmetal"] = 0f,
			["piece_chest"] = 0f,
			["rug_deer"] = 0.05f,
			["rug_straw"] = 0.05f,
			["rug_wolf"] = 0.05f,
			["rug_fur"] = 0.05f,
			["piece_table"] = 0f,
			["piece_chair"] = 0f,
			["piece_stool"] = 0f,
			["piece_bench"] = 0f
		};

		private const string BuiltinPlans = "\n# ---------- template casa (4x4, porta na frente = -z) ----------\ntemplate casa\nfloor  -1 0 -1 0\nfloor   1 0 -1 0\nfloor  -1 0  1 0\nfloor   1 0  1 0\nwall   -1 0 -2 0\ndoor    1 0 -2 0\nwall   -1 0  2 180\nwall    1 0  2 180\nwall   -2 0 -1 90\nwall   -2 0  1 90\nwall    2 0 -1 270\nwall    2 0  1 270\nroof    2 2 -1 270\nroof    2 2  1 270\nroof   -2 2 -1 90\nroof   -2 2  1 90\nridge   0 4  0 0\ngable  -1 2 -2 0\ngable   1 2 -2 180\ngable  -1 2  2 180\ngable   1 2  2 0\nchest   1 0.1  1 180\nrug    -1 0.1  0 0\ntorch  -1.6 0 -2.6 0\n\n# ---------- template salao (8x6, porta na frente) ----------\ntemplate salao\nfloor  -3 0 -2 0\nfloor  -1 0 -2 0\nfloor   1 0 -2 0\nfloor   3 0 -2 0\nfloor  -3 0  0 0\nfloor  -1 0  0 0\nfloor   1 0  0 0\nfloor   3 0  0 0\nfloor  -3 0  2 0\nfloor  -1 0  2 0\nfloor   1 0  2 0\nfloor   3 0  2 0\nwall   -3 0 -3 0\nwall   -1 0 -3 0\ndoor    1 0 -3 0\nwall    3 0 -3 0\nwall   -3 0  3 180\nwall   -1 0  3 180\nwall    1 0  3 180\nwall    3 0  3 180\nwall   -4 0 -2 90\nwall   -4 0  0 90\nwall   -4 0  2 90\nwall    4 0 -2 270\nwall    4 0  0 270\nwall    4 0  2 270\nroof    4 2 -2 270\nroof    4 2  0 270\nroof    4 2  2 270\nroof    2 4 -2 270\nroof    2 4  0 270\nroof    2 4  2 270\nroof   -4 2 -2 90\nroof   -4 2  0 90\nroof   -4 2  2 90\nroof   -2 4 -2 90\nroof   -2 4  0 90\nroof   -2 4  2 90\nridge   0 6  0 0\ngable  -3 2 -3 0\nwall   -1 2 -3 0\nwall    1 2 -3 0\ngable   3 2 -3 180\ngable  -1 4 -3 0\ngable   1 4 -3 180\ngable  -3 2  3 180\nwall   -1 2  3 180\nwall    1 2  3 180\ngable   3 2  3 0\ngable  -1 4  3 180\ngable   1 4  3 0\nchest   3 0.1  2 180\nchest  -3 0.1  2 180\nrug     0 0.1  0 0\ntorch  -1.6 0 -3.6 0\ntorch   3.6 0 -3.6 0\n\n# ---------- layout padrao (todas as cidades): so o cercado, portao a leste ----------\n# Decisao do Lucas (07/09): casas ficam de fora, o cercado ja basta.\n# Para ter casas, descomente as linhas 'building' (ou use mmo_cityplan export).\nlayout all\n# building casa   0  11   180\n# building casa  -9   6.5 125\n# building casa   9   6.5 235\n# building salao -11 -2   90\nfence 15 90\n";

		private static Dictionary<string, List<Placement>> _templates;

		private static Dictionary<string, Layout> _layouts;

		private static string _loadedFrom;

		private static string PlanPath => Path.Combine(Paths.ConfigPath, "ValheimMMO_cityplan.txt");

		private static Dictionary<string, Part[]> PaletteFor(int tier)
		{
			Dictionary<string, Part[]> dictionary = new Dictionary<string, Part[]>();
			dictionary["wall"] = new Part[1]
			{
				new Part("woodwall")
			};
			dictionary["door"] = new Part[1]
			{
				new Part("wood_door")
			};
			dictionary["floor"] = new Part[1]
			{
				new Part("wood_floor")
			};
			dictionary["roof"] = new Part[1]
			{
				new Part("wood_roof_45")
			};
			dictionary["ridge"] = new Part[1]
			{
				new Part("wood_roof_top_45")
			};
			dictionary["gable"] = new Part[1]
			{
				new Part("wood_wall_roof_45")
			};
			dictionary["fence"] = new Part[1]
			{
				new Part("wood_fence")
			};
			dictionary["gate"] = new Part[1]
			{
				new Part("wood_gate")
			};
			dictionary["torch"] = new Part[1]
			{
				new Part("piece_groundtorch_wood")
			};
			dictionary["chest"] = new Part[1]
			{
				new Part("piece_chest_wood")
			};
			dictionary["rug"] = new Part[1]
			{
				new Part("rug_deer")
			};
			dictionary["pole"] = new Part[1]
			{
				new Part("wood_pole2")
			};
			Dictionary<string, Part[]> dictionary2 = dictionary;
			switch (tier)
			{
			case 2:
				dictionary2["wall"] = new Part[2]
				{
					new Part("stone_wall_2x1"),
					new Part("stone_wall_2x1", 1f)
				};
				dictionary2["floor"] = new Part[1]
				{
					new Part("stone_floor_2x2", -1f)
				};
				dictionary2["fence"] = new Part[1]
				{
					new Part("piece_sharpstakes")
				};
				break;
			case 3:
				dictionary2["fence"] = new Part[1]
				{
					new Part("piece_sharpstakes")
				};
				dictionary2["rug"] = new Part[1]
				{
					new Part("rug_straw")
				};
				break;
			case 4:
				dictionary2["wall"] = new Part[2]
				{
					new Part("stone_wall_2x1"),
					new Part("stone_wall_2x1", 1f)
				};
				dictionary2["floor"] = new Part[1]
				{
					new Part("stone_floor_2x2", -1f)
				};
				dictionary2["fence"] = new Part[1]
				{
					new Part("stone_wall_1x1")
				};
				dictionary2["torch"] = new Part[1]
				{
					new Part("piece_groundtorch")
				};
				dictionary2["rug"] = new Part[1]
				{
					new Part("rug_wolf")
				};
				break;
			case 5:
				dictionary2["roof"] = new Part[1]
				{
					new Part("darkwood_roof_45")
				};
				dictionary2["ridge"] = new Part[1]
				{
					new Part("darkwood_roof_top_45")
				};
				dictionary2["gate"] = new Part[1]
				{
					new Part("darkwood_gate")
				};
				dictionary2["torch"] = new Part[1]
				{
					new Part("piece_groundtorch")
				};
				dictionary2["rug"] = new Part[1]
				{
					new Part("rug_fur")
				};
				dictionary2["pole"] = new Part[1]
				{
					new Part("darkwood_pole")
				};
				break;
			case 6:
				dictionary2["wall"] = new Part[1]
				{
					new Part("blackmarble_2x2x1")
				};
				dictionary2["floor"] = new Part[1]
				{
					new Part("blackmarble_floor", -1.1f)
				};
				dictionary2["roof"] = new Part[1]
				{
					new Part("darkwood_roof_45")
				};
				dictionary2["ridge"] = new Part[1]
				{
					new Part("darkwood_roof_top_45")
				};
				dictionary2["fence"] = new Part[1]
				{
					new Part("piece_dvergr_stake_wall")
				};
				dictionary2["gate"] = new Part[1]
				{
					new Part("darkwood_gate")
				};
				dictionary2["torch"] = new Part[1]
				{
					new Part("piece_groundtorch_blue")
				};
				dictionary2["chest"] = new Part[1]
				{
					new Part("piece_chest_blackmetal")
				};
				dictionary2["rug"] = new Part[1]
				{
					new Part("rug_fur")
				};
				break;
			case 7:
				dictionary2["wall"] = new Part[1]
				{
					new Part("ashwood_wall_2x2")
				};
				dictionary2["floor"] = new Part[1]
				{
					new Part("ashwood_floor_2x2")
				};
				dictionary2["roof"] = new Part[1]
				{
					new Part("darkwood_roof_45")
				};
				dictionary2["ridge"] = new Part[1]
				{
					new Part("darkwood_roof_top_45")
				};
				dictionary2["gable"] = new Part[1]
				{
					new Part("ashwood_wall_roof_45")
				};
				dictionary2["fence"] = new Part[1]
				{
					new Part("ashwood_halfwall_1x2")
				};
				dictionary2["gate"] = new Part[1]
				{
					new Part("darkwood_gate")
				};
				dictionary2["torch"] = new Part[1]
				{
					new Part("piece_groundtorch")
				};
				dictionary2["chest"] = new Part[1]
				{
					new Part("piece_chest_blackmetal")
				};
				dictionary2["rug"] = new Part[1]
				{
					new Part("rug_fur")
				};
				break;
			}
			return dictionary2;
		}

		internal static string Reload()
		{
			_templates = new Dictionary<string, List<Placement>>(StringComparer.OrdinalIgnoreCase);
			_layouts = new Dictionary<string, Layout>(StringComparer.OrdinalIgnoreCase);
			Parse("\n# ---------- template casa (4x4, porta na frente = -z) ----------\ntemplate casa\nfloor  -1 0 -1 0\nfloor   1 0 -1 0\nfloor  -1 0  1 0\nfloor   1 0  1 0\nwall   -1 0 -2 0\ndoor    1 0 -2 0\nwall   -1 0  2 180\nwall    1 0  2 180\nwall   -2 0 -1 90\nwall   -2 0  1 90\nwall    2 0 -1 270\nwall    2 0  1 270\nroof    2 2 -1 270\nroof    2 2  1 270\nroof   -2 2 -1 90\nroof   -2 2  1 90\nridge   0 4  0 0\ngable  -1 2 -2 0\ngable   1 2 -2 180\ngable  -1 2  2 180\ngable   1 2  2 0\nchest   1 0.1  1 180\nrug    -1 0.1  0 0\ntorch  -1.6 0 -2.6 0\n\n# ---------- template salao (8x6, porta na frente) ----------\ntemplate salao\nfloor  -3 0 -2 0\nfloor  -1 0 -2 0\nfloor   1 0 -2 0\nfloor   3 0 -2 0\nfloor  -3 0  0 0\nfloor  -1 0  0 0\nfloor   1 0  0 0\nfloor   3 0  0 0\nfloor  -3 0  2 0\nfloor  -1 0  2 0\nfloor   1 0  2 0\nfloor   3 0  2 0\nwall   -3 0 -3 0\nwall   -1 0 -3 0\ndoor    1 0 -3 0\nwall    3 0 -3 0\nwall   -3 0  3 180\nwall   -1 0  3 180\nwall    1 0  3 180\nwall    3 0  3 180\nwall   -4 0 -2 90\nwall   -4 0  0 90\nwall   -4 0  2 90\nwall    4 0 -2 270\nwall    4 0  0 270\nwall    4 0  2 270\nroof    4 2 -2 270\nroof    4 2  0 270\nroof    4 2  2 270\nroof    2 4 -2 270\nroof    2 4  0 270\nroof    2 4  2 270\nroof   -4 2 -2 90\nroof   -4 2  0 90\nroof   -4 2  2 90\nroof   -2 4 -2 90\nroof   -2 4  0 90\nroof   -2 4  2 90\nridge   0 6  0 0\ngable  -3 2 -3 0\nwall   -1 2 -3 0\nwall    1 2 -3 0\ngable   3 2 -3 180\ngable  -1 4 -3 0\ngable   1 4 -3 180\ngable  -3 2  3 180\nwall   -1 2  3 180\nwall    1 2  3 180\ngable   3 2  3 0\ngable  -1 4  3 180\ngable   1 4  3 0\nchest   3 0.1  2 180\nchest  -3 0.1  2 180\nrug     0 0.1  0 0\ntorch  -1.6 0 -3.6 0\ntorch   3.6 0 -3.6 0\n\n# ---------- layout padrao (todas as cidades): so o cercado, portao a leste ----------\n# Decisao do Lucas (07/09): casas ficam de fora, o cercado ja basta.\n# Para ter casas, descomente as linhas 'building' (ou use mmo_cityplan export).\nlayout all\n# building casa   0  11   180\n# building casa  -9   6.5 125\n# building casa   9   6.5 235\n# building salao -11 -2   90\nfence 15 90\n");
			_loadedFrom = "embutido";
			if (File.Exists(PlanPath))
			{
				try
				{
					Parse(File.ReadAllText(PlanPath));
					_loadedFrom = PlanPath;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[Cidade] plano '" + PlanPath + "': " + ex.Message));
				}
			}
			return $"{_templates.Count} template(s), {_layouts.Count} layout(s) de {_loadedFrom}";
		}

		internal static string ExportBuiltin()
		{
			if (File.Exists(PlanPath))
			{
				return "ja existe: " + PlanPath;
			}
			File.WriteAllText(PlanPath, "\n# ---------- template casa (4x4, porta na frente = -z) ----------\ntemplate casa\nfloor  -1 0 -1 0\nfloor   1 0 -1 0\nfloor  -1 0  1 0\nfloor   1 0  1 0\nwall   -1 0 -2 0\ndoor    1 0 -2 0\nwall   -1 0  2 180\nwall    1 0  2 180\nwall   -2 0 -1 90\nwall   -2 0  1 90\nwall    2 0 -1 270\nwall    2 0  1 270\nroof    2 2 -1 270\nroof    2 2  1 270\nroof   -2 2 -1 90\nroof   -2 2  1 90\nridge   0 4  0 0\ngable  -1 2 -2 0\ngable   1 2 -2 180\ngable  -1 2  2 180\ngable   1 2  2 0\nchest   1 0.1  1 180\nrug    -1 0.1  0 0\ntorch  -1.6 0 -2.6 0\n\n# ---------- template salao (8x6, porta na frente) ----------\ntemplate salao\nfloor  -3 0 -2 0\nfloor  -1 0 -2 0\nfloor   1 0 -2 0\nfloor   3 0 -2 0\nfloor  -3 0  0 0\nfloor  -1 0  0 0\nfloor   1 0  0 0\nfloor   3 0  0 0\nfloor  -3 0  2 0\nfloor  -1 0  2 0\nfloor   1 0  2 0\nfloor   3 0  2 0\nwall   -3 0 -3 0\nwall   -1 0 -3 0\ndoor    1 0 -3 0\nwall    3 0 -3 0\nwall   -3 0  3 180\nwall   -1 0  3 180\nwall    1 0  3 180\nwall    3 0  3 180\nwall   -4 0 -2 90\nwall   -4 0  0 90\nwall   -4 0  2 90\nwall    4 0 -2 270\nwall    4 0  0 270\nwall    4 0  2 270\nroof    4 2 -2 270\nroof    4 2  0 270\nroof    4 2  2 270\nroof    2 4 -2 270\nroof    2 4  0 270\nroof    2 4  2 270\nroof   -4 2 -2 90\nroof   -4 2  0 90\nroof   -4 2  2 90\nroof   -2 4 -2 90\nroof   -2 4  0 90\nroof   -2 4  2 90\nridge   0 6  0 0\ngable  -3 2 -3 0\nwall   -1 2 -3 0\nwall    1 2 -3 0\ngable   3 2 -3 180\ngable  -1 4 -3 0\ngable   1 4 -3 180\ngable  -3 2  3 180\nwall   -1 2  3 180\nwall    1 2  3 180\ngable   3 2  3 0\ngable  -1 4  3 180\ngable   1 4  3 0\nchest   3 0.1  2 180\nchest  -3 0.1  2 180\nrug     0 0.1  0 0\ntorch  -1.6 0 -3.6 0\ntorch   3.6 0 -3.6 0\n\n# ---------- layout padrao (todas as cidades): so o cercado, portao a leste ----------\n# Decisao do Lucas (07/09): casas ficam de fora, o cercado ja basta.\n# Para ter casas, descomente as linhas 'building' (ou use mmo_cityplan export).\nlayout all\n# building casa   0  11   180\n# building casa  -9   6.5 125\n# building casa   9   6.5 235\n# building salao -11 -2   90\nfence 15 90\n".TrimStart('\r', '\n'));
			return "gravado: " + PlanPath;
		}

		private static void Ensure()
		{
			if (_templates == null)
			{
				Reload();
			}
		}

		private static float F(string s)
		{
			return float.Parse(s, CultureInfo.InvariantCulture);
		}

		private static void Parse(string text)
		{
			List<Placement> list = null;
			Layout layout = null;
			string[] array = text.Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0 || text2[0] == '#')
				{
					continue;
				}
				string[] array2 = text2.Split(new char[2] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
				switch (array2[0].ToLowerInvariant())
				{
				case "template":
					list = new List<Placement>();
					layout = null;
					_templates[array2[1]] = list;
					continue;
				case "layout":
					layout = new Layout();
					list = null;
					_layouts[array2[1]] = layout;
					continue;
				case "building":
					layout?.Buildings.Add((array2[1], F(array2[2]), F(array2[3]), (array2.Length > 4) ? F(array2[4]) : 0f));
					continue;
				case "fence":
					if (layout != null)
					{
						layout.FenceRadius = F(array2[1]);
						if (array2.Length > 2)
						{
							layout.GateAngle = F(array2[2]);
						}
					}
					continue;
				}
				if (list != null && array2.Length >= 4)
				{
					list.Add(new Placement
					{
						Token = array2[0],
						X = F(array2[1]),
						Y = F(array2[2]),
						Z = F(array2[3]),
						Rot = ((array2.Length > 4) ? F(array2[4]) : 0f)
					});
				}
			}
		}

		internal static int BuildVillage(Vector3 center, int tier, bool test = false)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			Ensure();
			if (!_layouts.TryGetValue(tier.ToString(), out var value) && !_layouts.TryGetValue("all", out value))
			{
				return 0;
			}
			Dictionary<string, Part[]> pal = PaletteFor(tier);
			int num = 0;
			foreach (var building in value.Buildings)
			{
				Vector3 origin = center + new Vector3(building.x, 0f, building.z);
				num += BuildTemplate(building.template, origin, building.rot, tier, pal, test, center.y);
			}
			if (value.FenceRadius > 0f)
			{
				num += BuildFence(center, value.FenceRadius, value.GateAngle, pal, test);
			}
			return num;
		}

		internal static int BuildTemplate(string template, Vector3 origin, float yaw, int tier, bool test)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return BuildTemplate(template, origin, yaw, tier, PaletteFor(tier), test, origin.y);
		}

		private static int BuildTemplate(string template, Vector3 origin, float yaw, int tier, Dictionary<string, Part[]> pal, bool test, float groundY)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ce: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			Ensure();
			if (!_templates.TryGetValue(template, out var value))
			{
				Plugin.Log.LogWarning((object)("[Cidade] template '" + template + "' nao existe."));
				return 0;
			}
			Quaternion val = Quaternion.Euler(0f, yaw, 0f);
			int num = 0;
			Vector3 val2 = default(Vector3);
			foreach (Placement item in value)
			{
				string text = item.Token.ToLowerInvariant();
				((Vector3)(ref val2))..ctor(item.X, item.Y, item.Z);
				float num2 = item.Rot;
				switch (text)
				{
				case "roof":
				{
					Vector3 val3 = Quaternion.Euler(0f, num2, 0f) * Vector3.forward;
					val2 += val3 * 1f + Vector3.up * 1f;
					num2 += ModConfig.CityRoofYawFix.Value;
					break;
				}
				case "gable":
				case "ridge":
					num2 += ModConfig.CityRoofYawFix.Value;
					break;
				}
				Part[] value2;
				Part[] array = (pal.TryGetValue(text, out value2) ? value2 : new Part[1]
				{
					new Part(item.Token)
				});
				foreach (Part part in array)
				{
					float value3;
					float num3 = (PivotAboveBottom.TryGetValue(part.Prefab, out value3) ? value3 : 0f);
					float num4 = ((text == "roof") ? part.Dy : (part.Dy + num3));
					Vector3 pos = origin + val * (val2 + Vector3.up * num4);
					pos.y = groundY + val2.y + num4;
					if (Place(part.Prefab, pos, Quaternion.Euler(0f, yaw + num2, 0f), test))
					{
						num++;
					}
				}
			}
			return num;
		}

		private static int BuildFence(Vector3 center, float radius, float gateAngle, Dictionary<string, Part[]> pal, bool test)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			Part part = pal["fence"][0];
			Part part2 = pal["gate"][0];
			int num = Mathf.Max(8, Mathf.RoundToInt(MathF.PI * 2f * radius / 2f));
			float num2 = 360f / (float)num;
			int num3 = (float.IsNaN(gateAngle) ? (-1) : (Mathf.RoundToInt(gateAngle / num2) % num));
			int num4 = 0;
			for (int i = 0; i < num; i++)
			{
				float num5 = (float)i * num2;
				Vector3 val = Quaternion.Euler(0f, num5, 0f) * Vector3.forward;
				Vector3 pos = center + val * radius;
				pos.y = CitySystem.GroundY(pos);
				Part part3 = ((i == num3) ? part2 : part);
				float value;
				float num6 = (PivotAboveBottom.TryGetValue(part3.Prefab, out value) ? value : 0f);
				pos.y += num6 + part3.Dy;
				if (Place(part3.Prefab, pos, Quaternion.Euler(0f, num5, 0f), test))
				{
					num4++;
				}
			}
			return num4;
		}

		private static bool Place(string prefabName, Vector3 pos, Quaternion rot, bool test)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab = ZNetScene.instance.GetPrefab(prefabName);
			if ((Object)(object)prefab == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[Cidade] peca '" + prefabName + "' nao encontrada."));
				return false;
			}
			GameObject val = Object.Instantiate<GameObject>(prefab, pos, rot);
			ZNetView component = val.GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return true;
			}
			ZDO zDO = component.GetZDO();
			zDO.Persistent = true;
			zDO.Set("mmo_city_piece", true);
			if (test)
			{
				zDO.Set("mmo_city_test", true);
			}
			WearNTear component2 = val.GetComponent<WearNTear>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_supports = true;
			}
			return true;
		}

		internal static int ClearTest(Vector3 center, float radius)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			ZNetView[] array = Object.FindObjectsByType<ZNetView>((FindObjectsSortMode)0);
			foreach (ZNetView val in array)
			{
				if (val.IsValid() && val.GetZDO().GetBool("mmo_city_test", false) && !(Vector3.Distance(((Component)val).transform.position, center) > radius))
				{
					val.ClaimOwnership();
					ZNetScene.instance.Destroy(((Component)val).gameObject);
					num++;
				}
			}
			return num;
		}
	}
	internal static class CityGuards
	{
		public const string ZdoGuard = "mmo_guard";

		private const string ZdoGuardDay = "mmo_guard_day";

		internal static readonly List<Character> Loaded = new List<Character>();

		public static bool IsGuard(Character c, out int tier)
		{
			tier = 0;
			ZDO val = (((Object)(object)c?.m_nview != (Object)null && c.m_nview.IsValid()) ? c.m_nview.GetZDO() : null);
			if (val == null)
			{
				return false;
			}
			tier = val.GetInt("mmo_guard", 0);
			return tier > 0;
		}

		private static DungeonTier TierFor(int tier)
		{
			return DungeonBosses.TierById(Mathf.Clamp(tier, 1, DungeonBosses.Tiers.Length));
		}

		private static string CreatureFor(int tier)
		{
			DungeonTier dungeonTier = TierFor(tier);
			if (dungeonTier == null || !dungeonTier.EquipsItems)
			{
				return "Draugr_Elite";
			}
			return dungeonTier.Creature;
		}

		private static string WeaponsFor(int tier)
		{
			DungeonTier dungeonTier = TierFor(tier);
			if (dungeonTier == null || !dungeonTier.EquipsItems || dungeonTier.WeaponChoices.Length == 0)
			{
				return "SwordIron|ShieldBanded";
			}
			string text = dungeonTier.WeaponChoices[Random.Range(0, dungeonTier.WeaponChoices.Length)];
			if (!string.IsNullOrEmpty(dungeonTier.Shield))
			{
				return text + "|" + dungeonTier.Shield;
			}
			return text;
		}

		internal static float HealthFor(int tier)
		{
			return (TierFor(tier)?.Health ?? 1600f) * Mathf.Max(0.1f, ModConfig.DungeonBossHpMultiplier.Value) * Mathf.Max(0.1f, ModConfig.GuardHpMultiplier.Value);
		}

		internal static void EnsureGuards(Vector3 center, int tier, CityDef def)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.GuardsEnabled.Value || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			int num = Mathf.Clamp(ModConfig.GuardsPerCity.Value, 0, 12);
			int num2 = 0;
			foreach (Character item in Loaded)
			{
				if ((Object)(object)item != (Object)null && !item.IsDead() && IsGuard(item, out var tier2) && tier2 == tier && Vector3.Distance(((Component)item).transform.position, center) < 80f)
				{
					num2++;
				}
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(CreatureFor(tier));
			if ((Object)(object)prefab == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[Guardas] criatura '" + CreatureFor(tier) + "' nao encontrada."));
				return;
			}
			for (int i = num2; i < num; i++)
			{
				float num3 = (float)i * (360f / (float)Mathf.Max(1, num)) + 22.5f;
				Vector3 val = Quaternion.Euler(0f, num3, 0f) * Vector3.forward * 9f;
				Vector3 val2 = center + val;
				val2.y = CitySystem.GroundY(val2) + 0.3f;
				GameObject val3 = Object.Instantiate<GameObject>(prefab, val2, Quaternion.LookRotation(-val));
				Character component = val3.GetComponent<Character>();
				ZNetView component2 = val3.GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || !component2.IsValid())
				{
					Object.Destroy((Object)(object)val3);
					continue;
				}
				string text = WeaponsFor(tier);
				ZDO zDO = component2.GetZDO();
				zDO.Set("mmo_guard", tier);
				zDO.Set("mmo_dboss_items", text);
				zDO.Persistent = true;
				component.SetLevel(Mathf.Clamp(ModConfig.GuardStars.Value, 0, 3) + 1);
				float num4 = HealthFor(tier);
				component.SetMaxHealth(num4);
				component.SetHealth(num4);
				Apply(component, tier, def);
				Humanoid val4 = (Humanoid)(object)((component is Humanoid) ? component : null);
				if (val4 != null)
				{
					DungeonBosses.GiveItems(val4, text);
				}
			}
			if (num > num2)
			{
				Plugin.Log.LogInfo((object)$"[Guardas] {num - num2} guarda(s) postados em {def.Name} (vida {HealthFor(tier):0}, {CreatureFor(tier)}).");
			}
		}

		internal static void Apply(Character c, int tier, CityDef def)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			c.m_faction = (Faction)0;
			c.m_name = ((def != null) ? ("Guarda de " + def.Name) : "Guarda");
			c.m_boss = false;
			if (!Loaded.Contains(c))
			{
				Loaded.Add(c);
			}
			if ((Object)(object)((Component)c).GetComponent<GuardPost>() == (Object)null)
			{
				((Component)c).gameObject.AddComponent<GuardPost>();
			}
			if (ModConfig.GuardScaleWithPlayers.Value)
			{
				BossScaling.Attach(c);
			}
		}

		internal static void DailyReplenish(Trader merchant, int tier, CityDef def)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.GuardsEnabled.Value || (Object)(object)merchant == (Object)null || (Object)(object)EnvMan.instance == (Object)null)
			{
				return;
			}
			ZNetView component = ((Component)merchant).GetComponent<ZNetView>();
			if (!((Object)(object)component == (Object)null) && component.IsValid() && component.IsOwner())
			{
				ZDO zDO = component.GetZDO();
				int day = EnvMan.instance.GetDay();
				if (zDO.GetInt("mmo_guard_day", -1) != day)
				{
					zDO.Set("mmo_guard_day", day);
					EnsureGuards(((Component)merchant).transform.position, tier, def);
				}
			}
		}
	}
	internal sealed class GuardPost : MonoBehaviour
	{
		private void Start()
		{
			BaseAI component = ((Component)this).GetComponent<BaseAI>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			try
			{
				component.SetPatrolPoint();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Guardas] patrulha: " + ex.Message));
			}
		}

		private void OnDestroy()
		{
			CityGuards.Loaded.Remove(((Component)this).GetComponent<Character>());
		}
	}
	[HarmonyPatch(typeof(Character), "Awake")]
	internal static class Character_Awake_GuardPatch
	{
		private static void Postfix(Character __instance)
		{
			if (CityGuards.IsGuard(__instance, out var tier))
			{
				CityGuards.Apply(__instance, tier, CitySystem.ByTier(tier));
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "Awake")]
	internal static class Humanoid_Awake_GuardPatch
	{
		private static void Postfix(Humanoid __instance)
		{
			if (CityGuards.IsGuard((Character)(object)__instance, out var _))
			{
				DungeonBosses.GiveItemsDeferred(__instance, ((Character)__instance).m_nview.GetZDO().GetString("mmo_dboss_items", ""));
			}
		}
	}
	[HarmonyPatch(typeof(MonsterAI), "UpdateAI")]
	internal static class MonsterAI_UpdateAI_GuardPatch
	{
		internal static bool InGuardAI;

		private static void Prefix(MonsterAI __instance)
		{
			Character character = ((BaseAI)__instance).m_character;
			InGuardAI = (Object)(object)character != (Object)null && CityGuards.IsGuard(character, out var _);
		}

		private static void Postfix()
		{
			InGuardAI = false;
		}

		private static Exception Finalizer(Exception __exception)
		{
			InGuardAI = false;
			return __exception;
		}
	}
	[HarmonyPatch(typeof(EffectArea), "IsPointInsideNoMonsterArea")]
	internal static class EffectArea_IsPointInsideNoMonsterArea_GuardPatch
	{
		private static bool Prefix(ref EffectArea __result)
		{
			if (!MonsterAI_UpdateAI_GuardPatch.InGuardAI)
			{
				return true;
			}
			__result = null;
			return false;
		}
	}
	[HarmonyPatch(typeof(EffectArea), "IsPointCloseToNoMonsterArea")]
	internal static class EffectArea_IsPointCloseToNoMonsterArea_GuardPatch
	{
		private static bool Prefix(ref EffectArea __result)
		{
			if (!MonsterAI_UpdateAI_GuardPatch.InGuardAI)
			{
				return true;
			}
			__result = null;
			return false;
		}
	}
	[HarmonyPatch(typeof(BaseAI), "IsEnemy", new Type[]
	{
		typeof(Character),
		typeof(Character)
	})]
	internal static class BaseAI_IsEnemy_GuardPatch
	{
		private static bool Prefix(Character a, Character b, ref bool __result)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Invalid comparison between Unknown and I4
			if ((Object)(object)a == (Object)null || (Object)(object)b == (Object)null || (Object)(object)a == (Object)(object)b)
			{
				return true;
			}
			int tier;
			bool flag = CityGuards.IsGuard(a, out tier);
			bool flag2 = CityGuards.IsGuard(b, out tier);
			if (!flag && !flag2)
			{
				return true;
			}
			Character val = (flag ? b : a);
			if (flag && flag2)
			{
				__result = false;
				return false;
			}
			Player val2 = (Player)(object)((val is Player) ? val : null);
			if (val2 != null)
			{
				__result = Karma.IsWanted(val2);
				return false;
			}
			if (val.IsTamed())
			{
				__result = false;
				return false;
			}
			__result = (int)val.GetFaction() > 0;
			return false;
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "GetHoverText")]
	internal static class TeleportWorld_GetHoverText_CityPatch
	{
		private static void Postfix(TeleportWorld __instance, ref string __result)
		{
			ZNetView nview = __instance.m_nview;
			ZDO val = (((Object)(object)nview != (Object)null && nview.IsValid()) ? nview.GetZDO() : null);
			if (val != null && val.GetBool("mmo_city_portal", false))
			{
				string text = val.GetString(ZDOVars.s_tag, "");
				int result = 0;
				if (text.StartsWith("mmo_city_"))
				{
					int.TryParse(text.Substring("mmo_city_".Length), out result);
				}
				CityDef cityDef = CitySystem.ByTier(result);
				string text2 = ((cityDef != null) ? cityDef.Name : "cidade");
				bool flag = __instance.HaveTarget();
				string text3 = (flag ? "<color=#8FD16A>conectado</color>" : (CitySystem.IsFounded(result) ? "<color=#E0B04A>destino sem par por perto</color>" : "<color=#E04A3A>cidade ainda nao fundada</color>"));
				__result = "Portal da cidade\nDestino: <color=#F4E3B2>" + text2 + "</color>  [" + text3 + "]" + (flag ? "\n[<color=yellow><b>$KEY_Use</b></color>] atravessar" : "");
				__result = Localization.instance.Localize(__result);
			}
		}
	}
	internal sealed class CityDef
	{
		public int Tier;

		public string Name;

		public Biome Biome;

		public string MerchantPrefab;

		public string QuestPrefab;

		public string Station;

		public string Fire;

		public string Banner;
	}
	internal static class CitySystem
	{
		public const string ZdoCity = "mmo_city";

		public const string ZdoRole = "mmo_city_role";

		private const string DiscoveredKey = "mmo.cities";

		internal static readonly CityDef[] Defs = new CityDef[7]
		{
			new CityDef
			{
				Tier = 1,
				Name = "Vila do Vale",
				Biome = (Biome)1,
				MerchantPrefab = "Haldor",
				QuestPrefab = "Hildir",
				Station = "piece_workbench",
				Fire = "fire_pit",
				Banner = "piece_banner01"
			},
			new CityDef
			{
				Tier = 2,
				Name = "Entreposto do Carvao",
				Biome = (Biome)8,
				MerchantPrefab = "Haldor",
				QuestPrefab = "Hildir",
				Station = "forge",
				Fire = "fire_pit",
				Banner = "piece_banner02"
			},
			new CityDef
			{
				Tier = 3,
				Name = "Cais Afogado",
				Biome = (Biome)2,
				MerchantPrefab = "BogWitch",
				QuestPrefab = "Hildir",
				Station = "forge",
				Fire = "fire_pit",
				Banner = "piece_banner03"
			},
			new CityDef
			{
				Tier = 4,
				Name = "Posto do Gelo",
				Biome = (Biome)4,
				MerchantPrefab = "Hildir",
				QuestPrefab = "Haldor",
				Station = "piece_stonecutter",
				Fire = "fire_pit",
				Banner = "piece_banner04"
			},
			new CityDef
			{
				Tier = 5,
				Name = "Mercado da Colheita",
				Biome = (Biome)16,
				MerchantPrefab = "Haldor",
				QuestPrefab = "Hildir",
				Station = "piece_artisanstation",
				Fire = "fire_pit",
				Banner = "piece_banner05"
			},
			new CityDef
			{
				Tier = 6,
				Name = "Enclave Dvergr",
				Biome = (Biome)512,
				MerchantPrefab = "Haldor",
				QuestPrefab = "Hildir",
				Station = "blackforge",
				Fire = "fire_pit",
				Banner = "piece_banner06"
			},
			new CityDef
			{
				Tier = 7,
				Name = "Bastiao de Flametal",
				Biome = (Biome)32,
				MerchantPrefab = "Haldor",
				QuestPrefab = "Hildir",
				Station = "blackforge",
				Fire = "fire_pit",
				Banner = "piece_banner07"
			}
		};

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

		private static readonly Dictionary<int, Vector3> AnchorPos = new Dictionary<int, Vector3>();

		private static string _anchorsRaw;

		private static float _timer;

		internal static readonly List<Trader> LoadedMerchants = new List<Trader>();

		private static float _serverTimer;

		private static readonly HashSet<int> _loggedMissing = new HashSet<int>();

		private const float FoundRadius = 60f;

		private static readonly Dictionary<int, float> _nextTry = new Dictionary<int, float>();

		internal static Vector3 LevelCenter;

		internal static float LevelRadius = -1f;

		public const string ZdoPiece = "mmo_city_piece";

		public const string ZdoPortal = "mmo_city_portal";

		private const int HubTier = 1;

		public static CityDef ByTier(int tier)
		{
			CityDef[] defs = Defs;
			foreach (CityDef cityDef in defs)
			{
				if (cityDef.Tier == tier)
				{
					return cityDef;
				}
			}
			return null;
		}

		private static void EnsureAnchors()
		{
			string text = ModConfig.CityAnchors.Value ?? "";
			if (text == _anchorsRaw)
			{
				return;
			}
			_anchorsRaw = text;
			Anchors.Clear();
			AnchorPos.Clear();
			string[] array = text.Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text2 in array)
			{
				int num = text2.IndexOf('=');
				if (num > 0 && int.TryParse(text2.Substring(0, num).Trim(), out var result))
				{
					Anchors[result] = text2.Substring(num + 1).Trim();
				}
			}
		}

		private static string GlobalKeyFor(int tier)
		{
			return $"mmo_city_{tier}";
		}

		public static int CityTierOf(Component c)
		{
			ZNetView val = ((c != null) ? c.GetComponent<ZNetView>() : null);
			ZDO obj = (((Object)(object)val != (Object)null && val.IsValid()) ? val.GetZDO() : null);
			if (obj == null)
			{
				return 0;
			}
			return obj.GetInt("mmo_city", 0);
		}

		public static bool IsCityMerchant(Trader t)
		{
			if ((Object)(object)t != (Object)null && CityTierOf((Component)(object)t) > 0)
			{
				return RoleOf((Component)(object)t) == "merchant";
			}
			return false;
		}

		public static bool IsQuestNpc(Trader t)
		{
			if ((Object)(object)t != (Object)null && CityTierOf((Component)(object)t) > 0)
			{
				return RoleOf((Component)(object)t) == "quests";
			}
			return false;
		}

		private static string RoleOf(Component c)
		{
			ZNetView val = ((c != null) ? c.GetComponent<ZNetView>() : null);
			ZDO obj = (((Object)(object)val != (Object)null && val.IsValid()) ? val.GetZDO() : null);
			return ((obj != null) ? obj.GetString("mmo_city_role", "") : null) ?? "";
		}

		internal static void Tick(Player player, float dt)
		{
			if (!ModConfig.CitiesEnabled.Value || (Object)(object)player == (Object)null)
			{
				return;
			}
			_timer += dt;
			if (_timer < 5f)
			{
				return;
			}
			_timer = 0f;
			if ((Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			DiscoverNearby(player);
			foreach (Trader loadedMerchant in LoadedMerchants)
			{
				if (!((Object)(object)loadedMerchant == (Object)null))
				{
					int tier = CityTierOf((Component)(object)loadedMerchant);
					CityDef cityDef = ByTier(tier);
					if (cityDef != null)
					{
						CityGuards.DailyReplenish(loadedMerchant, tier, cityDef);
					}
				}
			}
		}

		internal static Vector3? AnchorPositionFor(int tier, Vector3 near, out string anchorName)
		{
			//IL_004a: 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)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			EnsureAnchors();
			anchorName = null;
			if (!Anchors.TryGetValue(tier, out anchorName) || (Object)(object)ZoneSystem.instance == (Object)null)
			{
				return null;
			}
			if (AnchorPos.TryGetValue(tier, out var value))
			{
				return value;
			}
			LocationInstance val = default(LocationInstance);
			if (ZoneSystem.instance.FindClosestLocation(anchorName, near, ref val))
			{
				AnchorPos[tier] = val.m_position;
				return val.m_position;
			}
			return null;
		}

		internal static bool IsFounded(int tier)
		{
			if ((Object)(object)ZoneSystem.instance != (Object)null)
			{
				return ZoneSystem.instance.GetGlobalKey(GlobalKeyFor(tier));
			}
			return false;
		}

		internal static void ResetFounded(int tier)
		{
			ZoneSystem instance = ZoneSystem.instance;
			if (instance != null)
			{
				instance.RemoveGlobalKey(GlobalKeyFor(tier));
			}
			AnchorPos.Remove(tier);
		}

		internal static void ServerTick(float dt)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.CitiesEnabled.Value || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			_serverTimer += dt;
			if (_serverTimer < 5f)
			{
				return;
			}
			_serverTimer = 0f;
			if ((Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			List<Vector3> list = new List<Vector3>();
			foreach (ZNetPeer peer in ZNet.instance.GetPeers())
			{
				list.Add(peer.m_refPos);
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				list.Add(((Component)Player.m_localPlayer).transform.position);
			}
			if (list.Count == 0)
			{
				return;
			}
			CityDef[] defs = Defs;
			foreach (CityDef cityDef in defs)
			{
				if (IsFounded(cityDef.Tier))
				{
					continue;
				}
				string anchorName;
				Vector3? val = AnchorPositionFor(cityDef.Tier, list[0], out anchorName);
				if (!val.HasValue)
				{
					if (anchorName != null && _loggedMissing.Add(cityDef.Tier))
					{
						Plugin.Log.LogWarning((object)("[Cidade] " + cityDef.Name + ": altar '" + anchorName + "' nao existe neste mundo (ainda). Confira com mmo_city."));
					}
					continue;
				}
				bool flag = false;
				foreach (Vector3 item in list)
				{
					if (Vector3.Distance(item, val.Value) <= 60f)
					{
						flag = true;
						break;
					}
				}
				if (flag && (!_nextTry.TryGetValue(cityDef.Tier, out var value) || !(Time.time < value)) && !Found(cityDef, val.Value, Player.m_localPlayer, out var error))
				{
					_nextTry[cityDef.Tier] = Time.time + 20f;
					if (_loggedMissing.Add(1000 + cityDef.Tier))
					{
						Plugin.Log.LogWarning((object)("[Cidade] " + cityDef.Name + ": " + error + " -- vou tentar de novo enquanto alguem estiver perto."));
					}
				}
			}
		}

		internal static bool Found(CityDef def, Vector3 altar, Player messageTo, out string error)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (Spawn(def, altar, out error))
			{
				ZoneSystem.instance.SetGlobalKey(GlobalKeyFor(def.Tier));
				_loggedMissing.Remove(1000 + def.Tier);
				if (messageTo != null)
				{
					((Character)messageTo).Message((MessageType)2, def.Name + " foi fundada!", 0, (Sprite)null);
				}
				return true;
			}
			return false;
		}

		private static bool Spawn(CityDef def, Vector3 altar, out string error)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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)
			//IL_0112: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			error = null;
			GameObject val = ZNetScene.instance.GetPrefab(def.MerchantPrefab) ?? ZNetScene.instance.GetPrefab("Haldor");
			GameObject val2 = ZNetScene.instance.GetPrefab(def.QuestPrefab) ?? ZNetScene.instance.GetPrefab("Haldor");
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				error = "prefabs de NPC nao encontrados";
				return false;
			}
			float num = Mathf.Max(30f, ModConfig.CityMinDistance.Value);
			float maxR = Mathf.Max(num + 20f, ModConfig.CityMaxDistance.Value);
			Vector3? val3 = FindFlatSpot(altar, num, maxR);
			if (!val3.HasValue)
			{
				error = "terreno em volta do altar ainda nao carregado (chegue mais perto)";
				return false;
			}
			Vector3 value = val3.Value;
			float y = default(float);
			if (!ZoneSystem.instance.GetGroundHeight(value, ref y))
			{
				error = "sem chao";
				return false;
			}
			value.y = y;
			if (ModConfig.CityLevelTerrain.Value)
			{
				Terraform.Level(value, ModConfig.CityLevelRadius.Value);
			}
			SpawnNpc(val, value + new Vector3(3.5f, 0f, 0f), value, def.Tier, "merchant", "Mercador de " + def.Name);
			SpawnNpc(val2, value + new Vector3(-3.5f, 0f, 0f), value, def.Tier, "quests", "Emissario de " + def.Name);
			if (ModConfig.CityPlaza.Value)
			{
				SpawnPiece("hearth", value, Quaternion.identity);
			}
			SpawnPortals(def, value);
			if (ModConfig.CityBuildings.Value)
			{
				int num2 = CityBuilder.BuildVillage(value, def.Tier);
				Plugin.Log.LogInfo((object)$"[Cidade] {def.Name}: {num2} pecas de construcao.");
			}
			CityGuards.EnsureGuards(value, def.Tier, def);
			Plugin.Log.LogInfo((object)$"[Cidade] {def.Name} (tier {def.Tier}) fundada em {value}.");
			return true;
		}

		internal static float GroundY(Vector3 pos)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (LevelRadius > 0f && Vector2.Distance(new Vector2(pos.x, pos.z), new Vector2(LevelCenter.x, LevelCenter.z)) <= LevelRadius - 1f)
			{
				return LevelCenter.y;
			}
			float result = default(float);
			if (!((Object)(object)ZoneSystem.instance != (Object)null) || !ZoneSystem.instance.GetGroundHeight(pos, ref result))
			{
				return pos.y;
			}
			return result;
		}

		private static void SpawnNpc(GameObject prefab, Vector3 pos, Vector3 lookAt, int tier, string role, string name)
		{
			//IL_0002: 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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			pos.y = GroundY(pos);
			Vector3 val = lookAt - pos;
			val.y = 0f;
			Quaternion val2 = ((((Vector3)(ref val)).sqrMagnitude > 0.01f) ? Quaternion.LookRotation(((Vector3)(ref val)).normalized) : Quaternion.identity);
			GameObject val3 = Object.Instantiate<GameObject>(prefab, pos, val2);
			ZNetView component = val3.GetComponent<ZNetView>();
			if (!((Object)(object)component == (Object)null) && component.IsValid())
			{
				ZDO zDO = component.GetZDO();
				zDO.Set("mmo_city", tier);
				zDO.Set("mmo_city_role", role);
				zDO.Persistent = true;
				Trader component2 = val3.GetComponent<Trader>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.m_name = name;
				}
			}
		}

		private static void SpawnPiece(string prefabName, Vector3 pos, Quaternion rot)
		{
			//IL_0032: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab = ZNetScene.instance.GetPrefab(prefabName);
			if ((Object)(object)prefab == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[Cidade] peca '" + prefabName + "' nao encontrada."));
				return;
			}
			pos.y = GroundY(pos);
			ZNetView component = Object.Instantiate<GameObject>(prefab, pos, rot).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				component.GetZDO().Persistent = true;
				component.GetZDO().Set("mmo_city_piece", true);
			}
		}

		private static Vector3? FindFlatSpot(Vector3 altar, float minR, float maxR)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			Vector3? result = null;
			float num = float.MaxValue;
			Vector3? val = null;
			LocationInstance val2 = default(LocationInstance);
			if (ZoneSystem.instance.FindClosestLocation("StartTemple", altar, ref val2))
			{
				val = val2.m_position;
			}
			float num2 = Mathf.Max(0f, ModConfig.CityKeepAwayFromSpawn.Value);
			float num5 = default(float);
			float num8 = default(float);
			for (int i = 0; i < 48; i++)
			{
				float num3 = (float)i / 48f * MathF.PI * 2f;
				for (float num4 = minR; num4 <= maxR; num4 += 15f)
				{
					Vector3 val3 = altar + new Vector3(Mathf.Cos(num3) * num4, 0f, Mathf.Sin(num3) * num4);
					if ((val.HasValue && Vector2.Distance(new Vector2(val3.x, val3.z), new Vector2(val.Value.x, val.Value.z)) < num2) || !ZoneSystem.instance.GetGroundHeight(val3, ref num5) || num5 < 31.5f)
					{
						continue;
					}
					float num6 = 0f;
					int num7 = 0;
					bool flag = true;
					for (int j = -1; j <= 1 && flag; j++)
					{
						for (int k = -1; k <= 1; k++)
						{
							Vector3 val4 = val3 + new Vector3((float)j * 5f, 0f, (float)k * 5f);
							if (!ZoneSystem.instance.GetGroundHeight(val4, ref num8) || num8 < 31f)
							{
								flag = false;
								break;
							}
							num6 += Mathf.Abs(num8 - num5);
							num7++;
						}
					}
					if (flag && num7 != 0)
					{
						float num9 = num6 / (float)num7;
						if (num9 < num)
						{
							num = num9;
							result = val3;
						}
					}
				}
			}
			return result;
		}

		private static void DiscoverNearby(Player player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)player).transform.position;
			for (int num = LoadedMerchants.Count - 1; num >= 0; num--)
			{
				Trader val = LoadedMerchants[num];
				if ((Object)(object)val == (Object)null)
				{
					LoadedMerchants.RemoveAt(num);
				}
				else if (!(Vector3.Distance(position, ((Component)val).transform.position) > 120f))
				{
					int tier = CityTierOf((Component)(object)val);
					CityDef cityDef = ByTier(tier);
					if (cityDef != null && !IsDiscovered(player, tier))
					{
						MarkDiscovered(player, tier);
						try
						{
							Minimap instance = Minimap.instance;
							if (instance != null)
							{
								instance.AddPin(((Component)val).transform.position, (PinType)1, cityDef.Name, true, false, 0L, default(PlatformUserID));
							}
						}
						catch
						{
						}
						((Character)player).Message((MessageType)2, "Voce descobriu " + cityDef.Name, 0, (Sprite)null);
					}
				}
			}
		}

		public static bool IsDiscovered(Player player, int tier)
		{
			if (player.m_customData.TryGetValue("mmo.cities", out var value))
			{
				return (";" + value + ";").Contains($";{tier};");
			}
			return false;
		}

		private static void MarkDiscovered(Player player, int tier)
		{
			player.m_customData.TryGetValue("mmo.cities", out var value);
			player.m_customData["mmo.cities"] = (string.IsNullOrEmpty(value) ? tier.ToString() : (value + ";" + tier));
		}

		internal static void OnMerchantLoaded(Trader t)
		{
			if (!LoadedMerchants.Contains(t))
			{
				LoadedMerchants.Add(t);
			}
			CreateSafeZone(t);
		}

		private static void CreateSafeZone(Trader t)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.CitySafeZone.Value && !((Object)(object)((Component)t).transform.Find("MMO_CitySafeZone") != (Object)null))
			{
				GameObject val = new GameObject("MMO_CitySafeZone");
				val.SetActive(false);
				val.transform.SetParent(((Component)t).transform, false);
				val.transform.localPosition = Vector3.zero;
				SphereCollider obj = val.AddComponent<SphereCollider>();
				((Collider)obj).isTrigger = true;
				obj.radius = Mathf.Max(10f, ModConfig.CitySafeRadius.Value);
				val.AddComponent<EffectArea>().m_type = (Type)32;
				val.SetActive(true);
			}
		}

		public static bool IsCityPiece(Component c)
		{
			ZNetView val = ((c != null) ? c.GetComponent<ZNetView>() : null);
			ZDO val2 = (((Object)(object)val != (Object)null && val.IsValid()) ? val.GetZDO() : null);
			if (val2 != null)
			{
				return val2.GetBool("mmo_city_piece", false);
			}
			return false;
		}

		private static void SpawnPortals(CityDef def, Vector3 center)
		{
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.CityPortals.Value)
			{
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab("portal_wood");
			if ((Object)(object)prefab == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[Cidade] prefab 'portal_wood' nao encontrado.");
			}
			else if (def.Tier == 1)
			{
				int num = Defs.Length - 1;
				int num2 = 0;
				CityDef[] defs = Defs;
				foreach (CityDef cityDef in defs)
				{
					if (cityDef.Tier != 1)
					{
						float num3 = 180f + ((float)num2 - (float)(num - 1) / 2f) * 25f;
						Vector3 val = Quaternion.Euler(0f, num3, 0f) * Vector3.forward * 13f;
						SpawnPortal(prefab, center + val, Quaternion.LookRotation(-val), $"mmo_city_{cityDef.Tier}", "Portal: " + cityDef.Name);
						num2++;
					}
				}
			}
			else
			{
				Vector3 val2 = Vector3.back * 10f;
				SpawnPortal(prefab, center + val2, Quaternion.LookRotation(-val2), $"mmo_city_{def.Tier}", "Portal: " + ByTier(1)?.Name);
			}
		}

		private static void SpawnPortal(GameObject prefab, Vector3 pos, Quaternion rot, string tag, string label)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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)
			pos.y = GroundY(pos);
			ZNetView component = Object.Instantiate<GameObject>(prefab, pos, rot).GetComponent<ZNetView>();
			if (!((Object)(object)component == (Object)null) && component.IsValid())
			{
				ZDO zDO = component.GetZDO();
				zDO.Persistent = true;
				zDO.Set("mmo_city_piece", true);
				zDO.Set("mmo_city_portal", true);
				zDO.Set(ZDOVars.s_tag, tag);
				zDO.Set(ZDOVars.s_tagauthor, "");
				Plugin.Log.LogInfo((object)$"[Cidade] {label} ({tag}) em {pos}.");
			}
		}
	}
	[HarmonyPatch(typeof(WearNTear), "RPC_Damage")]
	internal static class WearNTear_RPC_Damage_CityPatch
	{
		private static bool Prefix(WearNTear __instance)
		{
			return !CitySystem.IsCityPiece((Component)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(WearNTear), "RPC_Remove")]
	internal static class WearNTear_RPC_Remove_CityPatch
	{
		private static bool Prefix(WearNTear __instance)
		{
			return !CitySystem.IsCityPiece((Component)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "Interact")]
	internal static class TeleportWorld_Interact_CityPatch
	{
		private static bool Prefix(TeleportWorld __instance, Humanoid human, ref bool __result)
		{
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			ZDO val = (((Object)(object)component != (Object)null && component.IsValid()) ? component.GetZDO() : null);
			if (val == null || !val.GetBool("mmo_city_portal", false))
			{
				return true;
			}
			Humanoid obj = ((human is Player) ? human : null);
			if (obj != null)
			{
				((Character)obj).Message((MessageType)2, "Este portal e mantido pela cidade.", 0, (Sprite)null);
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateStats", new Type[] { typeof(float) })]
	internal static class Player_UpdateStats_CityPatch
	{
		private static void Postfix(Player __instance, float dt)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				CitySystem.Tick(__instance, dt);
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Update")]
	internal static class ZNet_Update_CityPatch
	{
		private static void Postfix()
		{
			CitySystem.ServerTick(Time.deltaTime);
		}
	}
	[HarmonyPatch(typeof(Trader), "Start")]
	internal static class Trader_Start_CityPatch
	{
		private static void Postfix(Trader __instance)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			int num = CitySystem.CityTierOf((Component)(object)__instance);
			if (num <= 0)
			{
				return;
			}
			CityDef cityDef = CitySystem.ByTier(num);
			if (cityDef == null)
			{
				return;
			}
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid() && component.IsOwner() && (Object)(object)ZoneSystem.instance != (Object)null)
			{
				Vector3 position = ((Component)__instance).transform.position;
				float num2 = default(float);
				if (ZoneSystem.instance.GetGroundHeight(position, ref num2) && Mathf.Abs(position.y - num2) > 0.3f)
				{
					position.y = num2;
					((Component)__instance).transform.position = position;
					component.GetZDO().SetPosition(position);
					Plugin.Log.LogInfo((object)$"[Cidade] NPC '{__instance.m_name}' reposicionado no chao ({num2:0.0}).");
				}
			}
			if (CitySystem.IsCityMerchant(__instance))
			{
				__instance.m_name = "Mercador de " + cityDef.Name;
				CitySystem.OnMerchantLoaded(__instance);
			}
			else if (CitySystem.IsQuestNpc(__instance))
			{
				__instance.m_name = "Emissario de " + cityDef.Name;
			}
		}
	}
	[HarmonyPatch(typeof(Trader), "Interact")]
	internal static class Trader_Interact_QuestNpcPatch
	{
		private static bool Prefix(Trader __instance, bool hold, ref bool __result)
		{
			if (hold || !CitySystem.IsQuestNpc(__instance))
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && Karma.IsWanted(localPlayer))
			{
				((Character)localPlayer).Message((MessageType)2, "O emissario nao fala com procurados.", 0, (Sprite)null);
				__result = false;
				return false;
			}
			QuestNpcUI.Open(CitySystem.CityTierOf((Component)(object)__instance));
			__result = false;
			return false;
		}
	}
	internal static class Terraform
	{
		public static void Level(Vector3 center, float radius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			CitySystem.LevelCenter = center;
			CitySystem.LevelRadius = radius;
			radius = Mathf.Clamp(radius, 2f, 40f);
			Settings val = new Settings
			{
				m_level = true,
				m_levelRadius = radius,
				m_levelOffset = 0f,
				m_square = false,
				m_raise = false,
				m_smooth = true,
				m_smoothRadius = radius + 4f,
				m_smoothPower = 3f,
				m_paintCleared = true,
				m_paintType = (PaintType)2,
				m_paintRadius = radius,
				m_paintHeightCheck = false
			};
			List<Heightmap> list = new List<Heightmap>();
			Heightmap.FindHeightmap(center, val.GetRadius(), list);
			int num = 0;
			foreach (Heightmap item in list)
			{
				if (!((Object)(object)item == (Object)null))
				{
					TerrainComp andCreateTerrainCompiler = item.GetAndCreateTerrainCompiler();
					if (!((Object)(object)andCreateTerrainCompiler == (Object)null) && !((Object)(object)andCreateTerrainCompiler.m_nview == (Object)null) && andCreateTerrainCompiler.m_nview.IsValid())
					{
						ZPackage val2 = new ZPackage();
						val2.Write(center);
						val.Serialize(val2);
						andCreateTerrainCompiler.m_nview.InvokeRPC("ApplyOperation", new object[1] { val2 });
						num++;
					}
				}
			}
			Plugin.Log.LogInfo((object)$"[Cidade] Terraplanagem em {center} (raio {radius:0}) aplicada em {num} heightmap(s).");
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}