using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Splatform;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Mobrin")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2026 Mobrin")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+8ada8a25722f08e620ed0cf72daf41adc6d68499")]
[assembly: AssemblyProduct("GroupHUD")]
[assembly: AssemblyTitle("GroupHUD")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 GroupHUD
{
	internal sealed class ConfigurationManagerAttributes
	{
		public int? Order;

		public bool? Browsable;
	}
	[BepInPlugin("mobrin.grouphud", "GroupHUD", "0.65.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class GroupHUDPlugin : BaseUnityPlugin
	{
		private class FoodInfo
		{
			public string Name;

			public float Time;

			public float BurnTime;

			public string IconName = "";
		}

		private class EffectInfo
		{
			public string Name;

			public int Hash;

			public float Remaining;

			public float Ttl;

			public string IconName = "";

			public bool Debuff;
		}

		private class Vitals
		{
			public float Health;

			public float MaxHealth;

			public float Stamina;

			public float MaxStamina;

			public float Eitr;

			public float MaxEitr;

			public float Adrenaline;

			public float MaxAdrenaline;

			public float LastUpdate;

			public List<FoodInfo> Foods = new List<FoodInfo>();

			public string GuardianName = "";

			public float GuardianCooldown;

			public List<EffectInfo> Effects = new List<EffectInfo>();

			public bool HasPosition;

			public int State;

			public string Emote = "";

			public Vector3 Position;
		}

		private class BarLook
		{
			public Color Color;

			public Sprite Sprite;

			public BarLook(Color c)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Color = c;
			}
		}

		private class GroupMember
		{
			public long Peer;

			public long PlayerId;

			public string Name = "";
		}

		private class GroupState
		{
			public long Leader;

			public List<GroupMember> Members = new List<GroupMember>();

			public GroupMember Find(long peer)
			{
				foreach (GroupMember member in Members)
				{
					if (member.Peer == peer)
					{
						return member;
					}
				}
				return null;
			}
		}

		private class PendingInvite
		{
			public long Leader;

			public string Name;

			public float Time;
		}

		private class OutgoingInvite
		{
			public string Name;

			public float Time;
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		internal static class NoFriendlyFirePatch
		{
			private static bool Prefix(Character __instance, HitData __1)
			{
				if ((Object)(object)instance == (Object)null || !instance.NoFriendlyFire || group == null)
				{
					return true;
				}
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || __1 == null)
				{
					return true;
				}
				Character attacker = __1.GetAttacker();
				Player val = (Player)(object)((attacker is Player) ? attacker : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)Player.m_localPlayer)
				{
					return true;
				}
				long playerID = val.GetPlayerID();
				foreach (GroupMember member in group.Members)
				{
					if (member.PlayerId != 0L && member.PlayerId == playerID)
					{
						return false;
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(EnemyHud), "UpdateHuds")]
		internal static class GroupNameColorPatch
		{
			private static void Postfix(EnemyHud __instance)
			{
				//IL_016f: 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_02b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f8: 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_027a: Unknown result type (might be due to invalid IL or missing references)
				//IL_027f: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_029e: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if ((Object)(object)instance == (Object)null)
					{
						return;
					}
					if (!hudsLookedUp)
					{
						hudsField = AccessTools.Field(typeof(EnemyHud), "m_huds");
						hudsLookedUp = true;
					}
					if (hudsField == null || !(hudsField.GetValue(__instance) is IDictionary dictionary))
					{
						return;
					}
					bool flag = instance.modEnabled.Value && instance.colorGroupNames.Value && group != null;
					foreach (DictionaryEntry item in dictionary)
					{
						object key = item.Key;
						Player val = (Player)((key is Player) ? key : null);
						if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)Player.m_localPlayer || item.Value == null)
						{
							continue;
						}
						object obj = AccessTools.Field(item.Value.GetType(), "m_name")?.GetValue(item.Value);
						if (obj == null)
						{
							continue;
						}
						PropertyInfo property = obj.GetType().GetProperty("color", BindingFlags.Instance | BindingFlags.Public);
						if (property == null || property.PropertyType != typeof(Color))
						{
							continue;
						}
						if (!originalNameColors.ContainsKey(obj))
						{
							originalNameColors[obj] = (Color)property.GetValue(obj, null);
						}
						GroupMember groupMember = null;
						if (flag)
						{
							long playerID = val.GetPlayerID();
							foreach (GroupMember member in group.Members)
							{
								if (member.PlayerId != 0L && member.PlayerId == playerID)
								{
									groupMember = member;
									break;
								}
							}
						}
						Color val2 = originalNameColors[obj];
						if (groupMember != null)
						{
							val2 = instance.NameColorFor(groupMember.Name);
							float maxHealth = ((Character)val).GetMaxHealth();
							float health = ((Character)val).GetHealth();
							float value = instance.lowHealthThreshold.Value;
							Vitals value2;
							bool flag2 = Received.TryGetValue(groupMember.Peer, out value2) && Time.time - value2.LastUpdate < 5f && (value2.State == 11 || value2.State == 4);
							if (((Character)val).IsDead() || health <= 0f)
							{
								val2 = DeadNameColor;
							}
							else if (value > 0f && maxHealth > 0f && health / maxHealth <= value)
							{
								val2 = LowHealthRed;
							}
							else if (flag2)
							{
								val2 = CombatNameColor;
							}
						}
						property.SetValue(obj, val2, null);
					}
					if (originalNameColors.Count > 200)
					{
						originalNameColors.Clear();
					}
				}
				catch
				{
				}
			}
		}

		private struct BackingItem
		{
			public Rect R;

			public float Alpha;

			public float Size;

			public bool Block;

			public int Z;
		}

		private enum PlayerState
		{
			None,
			Sleeping,
			InBed,
			Swimming,
			Fighting,
			Sneaking,
			Sitting,
			Running,
			Emote,
			Mining,
			Airborne,
			Combat,
			Helm,
			Riding,
			Building,
			Fishing,
			Woodcutting,
			Afk,
			Station,
			Planting
		}

		private class CardWatch
		{
			public float Until = -1f;

			public bool Food;

			public bool Effects;

			public float Alpha = 1f;

			public int Frame = -1;

			public bool Active => Time.time < Until;
		}

		private class WinEntry
		{
			public string Key;

			public int Id;

			public Rect Rect;

			public Rect BaseRect;

			public float Scale;

			public WindowFunction Func;

			public bool Covered;

			public List<Rect> Pieces;

			public bool ChestCut;
		}

		private class RaisedCanvas
		{
			public Canvas C;

			public bool Added;

			public bool OrigOverride;

			public int OrigOrder;
		}

		[HarmonyPatch(typeof(Player), "Interact")]
		internal static class InviteInteractBlockPatch
		{
			private static bool Prefix(Player __instance)
			{
				if (!((Object)(object)instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					return !instance.InviteKeysActive;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Hud), "UpdateCrosshair")]
		internal static class LookInviteHoverPatch
		{
			private static void Postfix(Hud __instance)
			{
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if ((Object)(object)instance == (Object)null || (Object)(object)instance.lookTarget == (Object)null)
					{
						return;
					}
					if (!hoverNameLooked)
					{
						hoverNameField = AccessTools.Field(typeof(Hud), "m_hoverName");
						hoverNameLooked = true;
					}
					object obj = ((hoverNameField != null) ? hoverNameField.GetValue(__instance) : null);
					if (obj == null)
					{
						return;
					}
					if (hoverNameTextProp == null)
					{
						hoverNameTextProp = obj.GetType().GetProperty("text", BindingFlags.Instance | BindingFlags.Public);
					}
					if (hoverNameTextProp == null || !string.IsNullOrEmpty(hoverNameTextProp.GetValue(obj, null) as string))
					{
						return;
					}
					string value = instance.LookInviteHoverText();
					if (!string.IsNullOrEmpty(value))
					{
						hoverNameTextProp.SetValue(obj, value, null);
						if ((Object)(object)__instance.m_crosshair != (Object)null)
						{
							((Graphic)__instance.m_crosshair).color = Color.yellow;
						}
						lookHintVanillaFrame = Time.frameCount;
					}
				}
				catch
				{
				}
			}
		}

		private class Alert
		{
			public string Text;

			public string Sub;

			public string Key;

			public Color Color;

			public float Until;

			public bool Pulse;
		}

		private struct NavItem
		{
			public Rect Screen;

			public Action Act;

			public char Win;
		}

		[HarmonyPatch]
		internal static class GamepadSelectionBlockPatch
		{
			private static bool Prepare()
			{
				return FindGamepadMethod(typeof(InventoryGrid), "SetGamepadSelection") != null;
			}

			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return FindGamepadMethod(typeof(InventoryGrid), "SetGamepadSelection");
			}

			private static bool Prefix()
			{
				if ((Object)(object)instance == (Object)null || !instance.navFocus)
				{
					return true;
				}
				LogBlocked("SetGamepadSelection");
				return false;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		internal static class InventoryShowRestorePatch
		{
			private static void Prefix()
			{
				invClosing = false;
				closingFrameWin = '\0';
			}

			private static void Postfix(InventoryGui __instance, object[] __args)
			{
				try
				{
					if ((Object)(object)instance == (Object)null || (Object)(object)__instance == (Object)null)
					{
						return;
					}
					instance.restoredOnShow = false;
					invHidden = false;
					if (__args != null && __args.Length != 0 && __args[0] != null)
					{
						instance.restoredOnShow = true;
						instance.liveStop = 0;
					}
					if (!instance.TabMode || !instance.GamepadInUse() || instance.lastStop == int.MinValue)
					{
						return;
					}
					instance.reopenTarget = instance.lastStop;
					instance.reopenCheckFrame = Time.frameCount + 90;
					if (savedPlayerSelection != null)
					{
						if (gridSelectedField == null)
						{
							gridSelectedField = AccessTools.Field(typeof(InventoryGrid), "m_selected");
						}
						FieldInfo fieldInfo = AccessTools.Field(typeof(InventoryGui), "m_playerGrid");
						InventoryGrid val = (InventoryGrid)((fieldInfo != null) ? /*isinst with value type is only supported in some contexts*/: null);
						if ((Object)(object)val != (Object)null && gridSelectedField != null)
						{
							gridSelectedField.SetValue(val, savedPlayerSelection);
						}
					}
					if (__args != null && __args.Length != 0 && __args[0] != null)
					{
						return;
					}
					int lastStop = instance.lastStop;
					if (lastStop >= 1)
					{
						Array array = VanillaUiGroups();
						if (array != null && lastStop < array.Length && !(setActiveGroupMethod == null))
						{
							tabRouting = true;
							try
							{
								setActiveGroupMethod.Invoke(__instance, new object[2] { lastStop, false });
							}
							finally
							{
								tabRouting = false;
							}
							instance.restoredOnShow = true;
							instance.restoreTarget = lastStop;
							instance.restoreGuardUntil = Time.frameCount + 10;
							((BaseUnityPlugin)instance).Logger.LogInfo((object)("Controller: inventory reopened – back in " + instance.StopName(lastStop)));
						}
					}
					else if (lastStop == -2 || lastStop == -3)
					{
						DeactivateVanillaGroups();
					}
				}
				catch
				{
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		internal static class InventoryHideSavePatch
		{
			private static void Prefix(InventoryGui __instance)
			{
				try
				{
					if (gridSelectedField == null)
					{
						gridSelectedField = AccessTools.Field(typeof(InventoryGrid), "m_selected");
					}
					FieldInfo fieldInfo = AccessTools.Field(typeof(InventoryGui), "m_playerGrid");
					InventoryGrid val = (InventoryGrid)((fieldInfo != null && (Object)(object)__instance != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
					if ((Object)(object)val != (Object)null && gridSelectedField != null)
					{
						savedPlayerSelection = gridSelectedField.GetValue(val);
					}
					if ((Object)(object)instance != (Object)null && !invHidden)
					{
						if (instance.navFocus)
						{
							instance.liveStop = ((instance.navStop == 'P') ? (-2) : (-3));
							instance.RememberNavPosition();
						}
						closingFrameWin = (instance.navFocus ? (instance.TabMode ? instance.navStop : 'M') : '\0');
						closingStop = ((!instance.navFocus) ? instance.liveStop : ((instance.navStop == 'P') ? (-2) : (-3)));
						closingTime = Time.unscaledTime;
						invClosing = true;
						if (instance.TabMode && instance.liveStop != int.MinValue && instance.liveStop != 0)
						{
							instance.lastStop = instance.liveStop;
						}
						if (instance.TabMode && instance.GamepadInUse())
						{
							((BaseUnityPlugin)instance).Logger.LogInfo((object)("Controller: inventory closed in " + instance.StopName(instance.lastStop)));
						}
					}
					invHidden = true;
				}
				catch
				{
				}
			}
		}

		[HarmonyPatch]
		internal static class InventoryGuiTabPatch
		{
			private static bool Prepare()
			{
				return AccessTools.Method(typeof(InventoryGui), "SetActiveGroup", new Type[2]
				{
					typeof(int),
					typeof(bool)
				}, (Type[])null) != null;
			}

			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return AccessTools.Method(typeof(InventoryGui), "SetActiveGroup", new Type[2]
				{
					typeof(int),
					typeof(bool)
				}, (Type[])null);
			}

			private static bool Prefix(object[] __args)
			{
				if (invClosing)
				{
					return false;
				}
				if (tabRouting || (Object)(object)instance == (Object)null || instance.navFocus || __args == null || __args.Length == 0 || !(__args[0] is int))
				{
					return true;
				}
				if (!instance.GroupHudTabAvailable())
				{
					return true;
				}
				int num = (PadDown("JoyTabRight") ? 1 : (PadDown("JoyTabLeft") ? (-1) : 0));
				if (num == 0)
				{
					return true;
				}
				if (lastRouteFrame == Time.frameCount)
				{
					return false;
				}
				instance.GoToStop(instance.NextStop(InventoryGui.instance.ActiveGroup, num));
				return false;
			}
		}

		[HarmonyPatch]
		internal static class GamepadInputBlockPatch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				string[] array = new string[3] { "GetButtonDown", "GetButtonUp", "GetButton" };
				foreach (string text in array)
				{
					MethodBase methodBase = null;
					try
					{
						methodBase = AccessTools.Method(typeof(ZInput), text, new Type[1] { typeof(string) }, (Type[])null);
					}
					catch
					{
					}
					if (methodBase != null)
					{
						yield return methodBase;
					}
				}
			}

			private static bool Prefix(object[] __args, ref bool __result)
			{
				string name = ((__args != null && __args.Length != 0) ? (__args[0] as string) : null);
				if (!BlockPadInput(name))
				{
					return true;
				}
				LogBlocked(name);
				__result = false;
				return false;
			}
		}

		[HarmonyPatch]
		internal static class OtherModControllerPausePatch
		{
			private static bool Prepare()
			{
				using (IEnumerator<KeyValuePair<MethodBase, string>> enumerator = OtherModControllerHandlers().GetEnumerator())
				{
					if (enumerator.MoveNext())
					{
						_ = enumerator.Current;
						return true;
					}
				}
				return false;
			}

			private static IEnumerable<MethodBase> TargetMethods()
			{
				foreach (KeyValuePair<MethodBase, string> item in OtherModControllerHandlers())
				{
					if ((Object)(object)instance != (Object)null)
					{
						((BaseUnityPlugin)instance).Logger.LogInfo((object)("Controller lock: pauses the controller buttons of " + item.Value + " while the group menu is active"));
					}
					yield return item.Key;
				}
			}

			private static bool Prefix()
			{
				if ((Object)(object)instance == (Object)null)
				{
					return true;
				}
				if (instance.navFocus)
				{
					return false;
				}
				if (instance.otherModsOnlyInInventory.Value && (Object)(object)InventoryGui.instance != (Object)null && InventoryGui.instance.ActiveGroup > 1)
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch]
		internal static class GamepadAxisBlockPatch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				string[] array = new string[6] { "GetJoyLeftStickX", "GetJoyLeftStickY", "GetJoyRightStickX", "GetJoyRightStickY", "GetJoyLTrigger", "GetJoyRTrigger" };
				foreach (string text in array)
				{
					MethodBase methodBase = null;
					try
					{
						methodBase = AccessTools.Method(typeof(ZInput), text, Type.EmptyTypes, (Type[])null);
					}
					catch
					{
					}
					if (methodBase != null)
					{
						yield return methodBase;
					}
				}
			}

			private static bool Prefix(ref float __result)
			{
				if ((Object)(object)instance == (Object)null || !instance.navFocus || navOwnRead)
				{
					return true;
				}
				__result = 0f;
				return false;
			}
		}

		[HarmonyPatch]
		internal static class GamepadInventoryBlockPatch
		{
			private static bool Prepare()
			{
				if (!(FindGamepadMethod(typeof(InventoryGrid), "UpdateGamepad") != null))
				{
					return FindGamepadMethod(typeof(InventoryGui), "UpdateRecipeGamepadInput") != null;
				}
				return true;
			}

			private static IEnumerable<MethodBase> TargetMethods()
			{
				MethodBase methodBase = FindGamepadMethod(typeof(InventoryGrid), "UpdateGamepad");
				if (methodBase != null)
				{
					yield return methodBase;
				}
				MethodBase methodBase2 = FindGamepadMethod(typeof(InventoryGui), "UpdateRecipeGamepadInput");
				if (methodBase2 != null)
				{
					yield return methodBase2;
				}
			}

			private static bool Prefix()
			{
				if (!((Object)(object)instance == (Object)null))
				{
					return !instance.navFocus;
				}
				return true;
			}

			private static void Postfix()
			{
				if ((Object)(object)instance != (Object)null)
				{
					instance.HoldInventorySelection();
				}
			}
		}

		private class ScrollState
		{
			public float Y;

			public bool Dragging;

			public float StartMouseY;

			public float StartY;

			public float Track;

			public float Max;

			public float Scale;
		}

		private enum ResizeKind
		{
			Panel,
			Card,
			Menu
		}

		private struct ResizeState
		{
			public bool Active;

			public bool Zoom;

			public bool AxisX;

			public bool AxisY;

			public ResizeKind Kind;

			public float StartScale;

			public float StartW;

			public float StartH;

			public float StartCardW;

			public float Cards;

			public float Scale;

			public float StartScreenX;

			public float StartScreenY;

			public Vector2 StartMouse;

			public float LastClick;

			public Vector2 LastClickPos;
		}

		public const string PluginGuid = "mobrin.grouphud";

		private static readonly string[] OldConfigFiles = new string[0];

		private const string RpcName = "GroupHUD_Stats";

		private const string GroupRpcName = "GroupHUD_Group";

		private const string ConfigRpcName = "GroupHUD_Config";

		private const float ConfigBroadcastInterval = 5f;

		private const int WindowId = 734512;

		private const int MenuWindowId = 734513;

		private const float DefaultCardWidth = 260f;

		private const float CardMinWidth = 230f;

		private const float CardMaxWidth = 420f;

		private const float MenuWidth = 280f;

		private const float Pad = 6f;

		private const float OfflineTimeout = 15f;

		private const float InviteTimeout = 60f;

		private const float NameHeight = 22f;

		private const float CrownSize = 18f;

		private const float DistanceWidth = 64f;

		private const float BarHeight = 14f;

		private const float BarStep = 16f;

		private const float FoodIconSize = 20f;

		private const float FoodRowHeight = 23f;

		private const float EffectIconSize = 26f;

		private const float EffectTimeHeight = 16f;

		private const float EffectRowGap = 4f;

		private static GroupHUDPlugin instance;

		private static GroupState group;

		private static readonly Dictionary<long, Vitals> Received = new Dictionary<long, Vitals>();

		private readonly Dictionary<int, Sprite> effectIconCache = new Dictionary<int, Sprite>();

		private readonly HashSet<string> loggedMissing = new HashSet<string>();

		private Dictionary<string, Sprite> spritesByName;

		private readonly BarLook lookHealth = new BarLook(new Color(0.8f, 0.1f, 0.1f));

		private readonly BarLook lookStamina = new BarLook(new Color(0.9f, 0.8f, 0.2f));

		private readonly BarLook lookEitr = new BarLook(new Color(0.2f, 0.5f, 0.9f));

		private readonly BarLook lookAdrenaline = new BarLook(new Color(0.95f, 0.5f, 0.1f));

		private bool barsLoaded;

		private float nextBarTry;

		private PendingInvite pendingInvite;

		private long awaitingLeader;

		private float awaitingSince;

		private readonly Dictionary<long, float> lastSeen = new Dictionary<long, float>();

		private float nextGroupCheck;

		private readonly Queue<Action> uiActions = new Queue<Action>();

		private readonly List<PinData> pins = new List<PinData>();

		private float nextPinUpdate;

		private bool commandsRegistered;

		private string cachedOwnName = "";

		private Texture2D crownTexture;

		private static readonly Color Gold = new Color(0.86f, 0.66f, 0.34f, 1f);

		private static readonly Color WarnRed = new Color(1f, 0.5f, 0.5f, 1f);

		private static readonly Color LowHealthRed = new Color(1f, 0.27f, 0.22f, 1f);

		private static readonly Color GroupOrange = new Color(1f, 0.55f, 0.08f, 1f);

		private static readonly Color GroupGreen = new Color(0.18f, 0.69f, 0.1f, 1f);

		private static readonly Color CombatNameColor = new Color(1f, 0.82f, 0.22f, 1f);

		private static readonly Color DeadNameColor = new Color(0.6f, 0.6f, 0.6f, 1f);

		private const string WarnRedHex = "#ff8080";

		private static readonly Color HoverYellow = new Color(1f, 0.82f, 0.25f, 1f);

		private static readonly Color HeaderGold = new Color(1f, 0.8f, 0.28f, 1f);

		private static readonly Color TitleGold = new Color(1f, 0.88f, 0.48f, 1f);

		private static readonly Color CardFill = new Color(0.03f, 0.03f, 0.03f, 1f);

		private static readonly Color CardBorder = new Color(0.17f, 0.12f, 0.08f, 0.95f);

		private const int UiTexSize = 16;

		private const float UiTexRadius = 5f;

		private readonly List<Texture2D> uiTextures = new List<Texture2D>();

		private Harmony harmony;

		private bool serverSynced;

		private int syncedMaxSize;

		private bool syncedNoFriendlyFire;

		private bool syncedShowOnMap;

		private float nextConfigBroadcast;

		private bool loggedNoServerCheck;

		private static readonly MethodInfo GetServerPeerIdMethod = typeof(ZRoutedRpc).GetMethod("GetServerPeerID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private readonly Dictionary<string, string[]> wrappedNames = new Dictionary<string, string[]>();

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

		private const int EffectNameFontSize = 10;

		private ConfigEntry<int> effectNameMinFontSize;

		private ConfigEntry<int> maxEffectRows;

		private readonly Dictionary<string, KeyValuePair<string, int>> fittedLines = new Dictionary<string, KeyValuePair<string, int>>();

		private const int MinLineFontSize = 9;

		private const int OverflowEffectsPerRow = 6;

		private ConfigEntry<int> configVersion;

		private ConfigEntry<bool> modEnabled;

		private ConfigEntry<string> panelLayout;

		private ConfigEntry<bool> showState;

		private ConfigEntry<float> combatStateSeconds;

		private ConfigEntry<float> afkMinutes;

		private ConfigEntry<bool> colorGroupNames;

		private ConfigEntry<Color> groupNameColor;

		private ConfigEntry<string> memberNameColors;

		private ConfigEntry<string> distanceStyleSetting;

		private ConfigEntry<float> alertPositionY;

		private ConfigEntry<float> alertPositionX;

		private ConfigEntry<KeyboardShortcut> inviteLookKey;

		private ConfigEntry<bool> gamepadSupport;

		private ConfigEntry<string> gamepadMenuButton;

		private ConfigEntry<bool> logGamepadButtons;

		private ConfigEntry<bool> otherModsOnlyInInventory;

		private ConfigEntry<string> vanillaHudTooltips;

		private ConfigEntry<bool> showPanelOnMap;

		private ConfigEntry<bool> panelLinked;

		private ConfigEntry<string> cardPositions;

		private ConfigEntry<string> hiddenCards;

		private ConfigEntry<float> cardWidth;

		private ConfigEntry<float> panelHeight;

		private ConfigEntry<float> panelHeightH;

		private ConfigEntry<float> menuWidthV;

		private ConfigEntry<float> menuHeightV;

		private ConfigEntry<float> menuWidthH;

		private ConfigEntry<float> menuHeightH;

		private ConfigEntry<bool> lockWindows;

		private ConfigEntry<string> collapsedCards;

		private ConfigEntry<string> foodCards;

		private ConfigEntry<string> effectCards;

		private ConfigEntry<bool> compactShowFood;

		private ConfigEntry<bool> compactShowEffects;

		private ConfigEntry<string> chestOverlap;

		private ConfigEntry<string> noticeStyle;

		private ConfigEntry<float> noticeSeconds;

		private ConfigEntry<bool> colorTooltipValues;

		private ConfigEntry<Color> buffValueColor;

		private ConfigEntry<Color> debuffValueColor;

		private ConfigEntry<Color> neutralValueColor;

		private ConfigEntry<bool> matchInventoryLook;

		private ConfigEntry<string> menuLayout;

		private ConfigEntry<bool> showMenuLayoutButton;

		private ConfigEntry<float> menuSidePadding;

		private ConfigEntry<string> showSeparators;

		private ConfigEntry<bool> inviteBlinkFrame;

		private ConfigEntry<int> inviteFrameThickness;

		private ConfigEntry<bool> blockClicksBehind;

		private ConfigEntry<float> barSidePadding;

		private ConfigEntry<float> effectsBottomGap;

		private ConfigEntry<Color> distanceColor;

		private ConfigEntry<float> cardPadding;

		private ConfigEntry<float> menuTopPadding;

		private ConfigEntry<float> menuSlideIn;

		private ConfigEntry<bool> menuFollowInventory;

		private ConfigEntry<string> inventoryFrame;

		private ConfigEntry<string> effectAlignment;

		private ConfigEntry<bool> leaderFirst;

		private ConfigEntry<bool> resetWindows;

		private ConfigEntry<string> inventoryLookSource;

		private ConfigEntry<bool> notifyDeath;

		private ConfigEntry<bool> notifyLowHealth;

		private ConfigEntry<bool> showTooltips;

		private ConfigEntry<float> tooltipScale;

		private ConfigEntry<bool> clickNameForMap;

		private ConfigEntry<bool> mapCloseButton;

		private ConfigEntry<bool> inviteNotice;

		private ConfigEntry<bool> showLayoutButton;

		private ConfigEntry<bool> showResizeGrip;

		private ConfigEntry<bool> snapToVanilla;

		private ConfigEntry<bool> avoidVanillaHud;

		private ConfigEntry<bool> autoCompact;

		private ConfigEntry<string> autoShow;

		private ConfigEntry<string> popUpCombat;

		private ConfigEntry<string> popUpLowHealth;

		private ConfigEntry<string> popUpDeath;

		private ConfigEntry<string> popUpFood;

		private ConfigEntry<string> popUpBadEffect;

		private ConfigEntry<string> popUpFarAway;

		private ConfigEntry<float> fadeOpacity;

		private ConfigEntry<float> calmSeconds;

		private ConfigEntry<float> popUpFoodSeconds;

		private ConfigEntry<float> popUpFarMeters;

		private ConfigEntry<string> sectionOrder;

		private ConfigEntry<bool> compactOutsideInventory;

		private ConfigEntry<bool> alertsInChat;

		private bool wasInventoryOpen;

		private ConfigEntry<bool> showPanel;

		private ConfigEntry<KeyboardShortcut> togglePanelKey;

		private ConfigEntry<bool> compactMode;

		private ConfigEntry<bool> followVanillaHud;

		private ConfigEntry<KeyboardShortcut> compactKey;

		private ConfigEntry<bool> highlightDebuffs;

		private ConfigEntry<string> debuffNames;

		private ConfigEntry<bool> logEffectNames;

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

		private static string debuffNamesParsed;

		private readonly HashSet<string> loggedEffectNames = new HashSet<string>();

		private ConfigEntry<bool> showSelf;

		private ConfigEntry<string> language;

		private ConfigEntry<float> sendInterval;

		private ConfigEntry<int> maxGroupSize;

		private ConfigEntry<bool> noFriendlyFire;

		private ConfigEntry<bool> showOnMap;

		private ConfigEntry<bool> showMenu;

		private ConfigEntry<bool> menuCollapsed;

		private ConfigEntry<float> panelX;

		private ConfigEntry<float> panelY;

		private ConfigEntry<float> menuX;

		private ConfigEntry<float> menuY;

		private ConfigEntry<float> scale;

		private ConfigEntry<float> menuScale;

		private ConfigEntry<string> fontName;

		private ConfigEntry<bool> showHealth;

		private ConfigEntry<bool> showStamina;

		private ConfigEntry<bool> showEitr;

		private ConfigEntry<bool> showAdrenaline;

		private ConfigEntry<bool> showBarNumbers;

		private ConfigEntry<bool> showFood;

		private ConfigEntry<bool> showFoodIcons;

		private ConfigEntry<bool> showFoodTime;

		private ConfigEntry<bool> showGuardianPower;

		private ConfigEntry<bool> showEffects;

		private ConfigEntry<bool> showEffectNames;

		private ConfigEntry<bool> showEffectTimes;

		private ConfigEntry<bool> showEffectsWithoutIcon;

		private ConfigEntry<string> hiddenEffects;

		private ConfigEntry<bool> showAllEffectsAgain;

		private ConfigEntry<bool> showCrown;

		private ConfigEntry<bool> showDistance;

		private ConfigEntry<float> lowHealthThreshold;

		private ConfigEntry<int> effectsPerRow;

		private ConfigEntry<int> effectNameLines;

		private ConfigEntry<float> panelOpacity;

		private ConfigEntry<float> menuOpacity;

		private const float VanillaOpacity = 0.3f;

		private const float CollapseButtonWidth = 26f;

		private const float CollapseButtonHeight = 20f;

		private float menuNaturalHeight = 120f;

		private Vector3? pendingMapTarget;

		private float pendingMapSince;

		private float panelNaturalHeight = 50f;

		private float panelNaturalWidth = 240f;

		private float menuTargetHeight = 120f;

		private float panelTargetHeight = 50f;

		private const float RowHeight = 22f;

		private const float RowGap = 4f;

		private const float ButtonHeight = 20f;

		private const float CardGap = 6f;

		private GUIStyle collapseButtonStyle;

		private float menuStyleOpacity = -1f;

		private Texture2D menuTexture;

		private ZRoutedRpc registeredOn;

		private float nextSend;

		private bool configDirty;

		private GUIStyle textStyle;

		private GUIStyle nameStyle;

		private GUIStyle nameLowStyle;

		private GUIStyle nameDeadStyle;

		private GUIStyle rightStyle;

		private GUIStyle distanceStyle;

		private GUIStyle stateStyle;

		private GUIStyle barTextStyle;

		private GUIStyle barShadowStyle;

		private GUIStyle effectNameStyle;

		private GUIStyle effectTimeStyle;

		private GUIStyle lineStyle;

		private GUIStyle menuWindowStyle;

		private GUIStyle menuLabelStyle;

		private GUIStyle menuHeaderStyle;

		private GUIStyle menuTitleStyle;

		private GUIStyle menuButtonStyle;

		private int configOrder = 1000;

		private static readonly Color ButtonText = new Color(0.93f, 0.89f, 0.8f);

		private static readonly Color ButtonTextHover = new Color(1f, 0.9f, 0.6f);

		private static MethodInfo selectedLanguageMethod;

		private static bool selectedLanguageLookedUp;

		private readonly HashSet<long> onlineSet = new HashSet<long>();

		private int onlineSetFrame = -1;

		private readonly Dictionary<long, float> waitingSince = new Dictionary<long, float>();

		private readonly Dictionary<long, OutgoingInvite> outgoingInvites = new Dictionary<long, OutgoingInvite>();

		private static readonly Dictionary<object, Color> originalNameColors = new Dictionary<object, Color>();

		private static FieldInfo hudsField;

		private static bool hudsLookedUp;

		private string parsedNameColorsSource;

		private readonly Dictionary<string, Color> parsedNameColors = new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<int, GUIStyle> cardStyles = new Dictionary<int, GUIStyle>();

		private Image inventoryBackground;

		private Object inventoryBackgroundOwner;

		private bool inventoryBackgroundSearched;

		private string inventoryLookSourceUsed;

		private float curPanelScale = 1f;

		private float curMenuScale = 1f;

		private readonly List<BackingItem> backingPanel = new List<BackingItem>();

		private readonly List<BackingItem> backingMenu = new List<BackingItem>();

		private readonly List<BackingItem> backingAlerts = new List<BackingItem>();

		private readonly List<BackingItem> backingApplied = new List<BackingItem>();

		private bool backingPanelSeen;

		private bool backingMenuSeen;

		private bool backingAlertsSeen;

		private readonly List<Image> backingImages = new List<Image>();

		private GameObject backingRoot;

		private Canvas backingRootCanvas;

		private bool backingWarned;

		private readonly Dictionary<Sprite, Sprite> innerSprites = new Dictionary<Sprite, Sprite>();

		private const float SeparatorHeight = 9f;

		private static FieldInfo emoteVarField;

		private static bool emoteVarLookedUp;

		private static float lastCombatTime = -999f;

		private static float lastMiningTime = -999f;

		private static float lastWoodTime = -999f;

		private static float lastMoveTime;

		private static float lastHealth = -1f;

		private static float lastMaxHealth = -1f;

		private static Vector3 lastAfkPos;

		private static string currentStationToken = "";

		private static Quaternion lastAfkRot;

		private const float ToolStateSeconds = 4f;

		private static readonly Dictionary<string, MethodInfo> playerMethods = new Dictionary<string, MethodInfo>();

		private static MethodInfo onGroundMethod;

		private static bool onGroundLookedUp;

		private GUIStyle distanceLeftStyle;

		private const int ArrowSteps = 72;

		private readonly Texture2D[] arrowTextures = (Texture2D[])(object)new Texture2D[72];

		private readonly Dictionary<string, CardWatch> cardWatch = new Dictionary<string, CardWatch>();

		private static float uiFade = 1f;

		private const int CardWindowBase = 734600;

		private Vector2 screenMouse;

		private readonly List<string> zOrder = new List<string>();

		private readonly List<KeyValuePair<string, List<Rect>>> lastVisible = new List<KeyValuePair<string, List<Rect>>>();

		private readonly Dictionary<int, Rect> winRects = new Dictionary<int, Rect>();

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

		private readonly Dictionary<int, int> winZ = new Dictionary<int, int>();

		private readonly Dictionary<int, KeyValuePair<long, string>> cardWindows = new Dictionary<int, KeyValuePair<long, string>>();

		private readonly Dictionary<string, float> cardHeights = new Dictionary<string, float>();

		private readonly Dictionary<string, Vector2> linkedCardOffsets = new Dictionary<string, Vector2>();

		private Rect lastLinkedRect;

		private Rect curWinRect;

		private float curWinScale = 1f;

		private int curWinZ;

		private bool drawingClipped;

		private bool clipFirstPiece = true;

		private int panelMemberCount;

		private int curWinId;

		private static FieldInfo vanillaTooltipField;

		private static bool vanillaTooltipLooked;

		private static FieldInfo containerField;

		private static bool containerFieldLooked;

		private readonly Vector3[] cornerBuffer = (Vector3[])(object)new Vector3[4];

		private static readonly string[] containerExtraFields = new string[4] { "m_containerName", "m_containerWeight", "m_takeAllButton", "m_stackAllButton" };

		private static FieldInfo[] containerExtras;

		private readonly List<RectTransform> containerParts = new List<RectTransform>();

		private readonly Rect[] chestHistory = (Rect[])(object)new Rect[2];

		private readonly int[] chestHistoryFrame = new int[2] { -100, -100 };

		private int chestRectFrame = -1;

		private bool chestRectOk;

		private Rect chestRectCached;

		private readonly Dictionary<GameObject, RaisedCanvas> raisedCanvases = new Dictionary<GameObject, RaisedCanvas>();

		private static FieldInfo dragGoField;

		private static FieldInfo splitDialogField;

		private static bool dragFieldsLooked;

		private readonly List<GameObject> raiseDone = new List<GameObject>();

		private static FieldInfo hudHealthPanelField;

		private int hudBlockFrame = -1;

		private bool hudBlockOk;

		private Rect hudBlockRect;

		private string dragRawKey;

		private string pressedKey;

		private string manualKey;

		private Vector2 manualMouse;

		private Rect manualStart;

		private bool manualStartSet;

		private bool manualMoving;

		private Vector2 dragRaw;

		private static readonly List<Rect> vanillaSnapRects = new List<Rect>();

		private static FieldInfo snapPlayerField;

		private static FieldInfo snapCraftingField;

		private int backingHideFrame = -10;

		private readonly Dictionary<string, List<BackingItem>> panelBackingCache = new Dictionary<string, List<BackingItem>>();

		private string drawnPanelKey;

		private string drawnMenuKey;

		private readonly Dictionary<string, float> menuHeightCache = new Dictionary<string, float>();

		private string lastHeightKey;

		private float lastHeightValue = -1f;

		private bool menuDrawnAside;

		private Rect chestScreenRect;

		private bool chestClipping;

		private Dictionary<string, Vector2> cardPosCache;

		private string cardPosCacheRaw;

		private const float CardButtonW = 16f;

		private const float CardButtonH = 14f;

		private const float CardButtonGap = 2f;

		private GUIStyle cardButtonStyleCache;

		private float menuProgress;

		private bool menuTarget;

		private static FieldInfo invAnimatorField;

		private static MethodInfo animatorGetBool;

		private static readonly object[] visibleArg = new object[1] { "visible" };

		private static bool invAnimatorLooked;

		private Vector2 invRestPos;

		private Vector2 invLastPos;

		private Vector2 invHiddenDir;

		private bool invRestKnown;

		private float invHiddenDist;

		private int invStableFrames;

		private float menuOpenedAt = -10f;

		private bool menuSynced;

		private int invScreenW;

		private int invScreenH;

		private Rect lastMenuBase;

		private float lastMenuScale = 1f;

		private Vector2 lastMenuSlide;

		private bool lastMenuValid;

		private static object cfgMgr;

		private static PropertyInfo cfgMgrShown;

		private static float cfgMgrNextLook;

		private bool otherUiOnTop;

		private Player lookTarget;

		private long lookPeer;

		private string lookName;

		private GUIStyle lookHintStyle;

		private GUIStyle lookHintShadow;

		private const float InviteDeclineHold = 0.8f;

		private float inviteKeyDownTime = -1f;

		private float inviteSwallowUntil = -1f;

		private const float LookInviteRange = 10f;

		private static readonly float[] lookNameHeights = new float[3] { 2.2f, 2.45f, 2.7f };

		private static MethodInfo hoverObjectMethod;

		private static bool hoverObjectLooked;

		private bool lookAccept;

		private static FieldInfo hoverNameField;

		private static PropertyInfo hoverNameTextProp;

		private static bool hoverNameLooked;

		private static int lookHintVanillaFrame = -10;

		private const int TooltipWindowId = 734514;

		private const float TooltipWidth = 230f;

		private string hoverTitle;

		private string hoverBody;

		private Rect hoverRect;

		private bool hoverSetThisFrame;

		private Rect panelRect;

		private GUIStyle tooltipTitleStyle;

		private GUIStyle tooltipBodyStyle;

		private GUIStyle tooltipStyle;

		private readonly Dictionary<string, ItemData> foodItems = new Dictionary<string, ItemData>();

		private static readonly string[][] GuardianKeywords = new string[7][]
		{
			new string[2] { "eikthyr", "GP_Eikthyr" },
			new string[2] { "elder", "GP_TheElder" },
			new string[2] { "bonemass", "GP_Bonemass" },
			new string[2] { "moder", "GP_Moder" },
			new string[2] { "yagluth", "GP_Yagluth" },
			new string[2] { "queen", "GP_Queen" },
			new string[2] { "fader", "GP_Fader" }
		};

		private static readonly Regex anyColorTag = new Regex("<color=[^>]*>", RegexOptions.Compiled);

		private HashSet<string> hiddenEffectSet;

		private string hiddenEffectSource;

		private static readonly Regex colorTag = new Regex("<color=([#A-Za-z0-9]+)>", RegexOptions.Compiled);

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

		private const int VanillaTooltipWindowId = 734515;

		private static FieldInfo hudFoodIconsField;

		private static FieldInfo hudStatusRectsField;

		private static FieldInfo hudStatusListField;

		private static FieldInfo hudGpRootField;

		private static bool hudFieldsLooked;

		private static readonly Vector3[] hudCorners = (Vector3[])(object)new Vector3[4];

		private static readonly List<RaycastResult> uiHits = new List<RaycastResult>();

		private static FieldInfo mapModeField;

		private static FieldInfo mapImageLargeField;

		private static FieldInfo largeRootField;

		private static MethodInfo setMapModeMethod;

		private static bool mapReflectionDone;

		private static bool mapReflectionWarned;

		private GUIStyle mapCloseStyle;

		private readonly Dictionary<long, bool> wasDead = new Dictionary<long, bool>();

		private readonly Dictionary<long, bool> wasLow = new Dictionary<long, bool>();

		private readonly Dictionary<long, float> lowRepeat = new Dictionary<long, float>();

		private const float LowHealthRepeat = 4f;

		private readonly List<Alert> alerts = new List<Alert>();

		private GUIStyle alertStyle;

		private GUIStyle alertShadowStyle;

		private GUIStyle alertSubStyle;

		private GUIStyle alertSubShadowStyle;

		private const string InviteAlertKey = "invite";

		private bool alertDragging;

		private GUIStyle alertCloseStyle;

		private const int AlertWindowId = 734516;

		private readonly List<Rect> alertScreenRects = new List<Rect>();

		private float nextAlertCheck;

		private GUIStyle menuInviteStyleCache;

		private const float MenuColumnGap = 20f;

		private float menuColA = 180f;

		private float menuColB = 180f;

		private float menuScrollContent;

		private float menuFullHeight;

		private const float MenuTitleInset = 20f;

		private readonly Dictionary<string, GUIStyle> fittedMenuStyles = new Dictionary<string, GUIStyle>();

		private GUIStyle menuBigTitleStyle;

		private GUIStyle menuKeyTitleStyle;

		private const int StopPanel = -2;

		private const int StopMenu = -3;

		private char navStop = 'M';

		private static readonly Color NavSelectWhite = new Color(1f, 1f, 1f, 0.95f);

		private List<NavItem> navItems = new List<NavItem>();

		private List<NavItem> navBuild = new List<NavItem>();

		private bool navFocus;

		private int navIndex;

		private int navHeaderCount;

		private int navHeaderBuild;

		private bool navIdle;

		private bool navQuiet;

		private Rect menuScreenRect;

		private bool menuScreenKnown;

		private GUIStyle keyHintStyle;

		private GUIStyle keyHintShadow;

		private static bool navOwnRead;

		private static FieldInfo gridSelectedField;

		private static bool gridSelectedLooked;

		private readonly Dictionary<InventoryGrid, object> heldSelections = new Dictionary<InventoryGrid, object>();

		private bool savedSendNavigation = true;

		private bool navigationSuspended;

		private static readonly string[] padButtonNames = new string[26]
		{
			"JoyButtonA", "JoyButtonB", "JoyButtonX", "JoyButtonY", "JoyLBumper", "JoyRBumper", "JoyLTrigger", "JoyRTrigger", "JoyLStick", "JoyRStick",
			"JoyDPadUp", "JoyDPadDown", "JoyDPadLeft", "JoyDPadRight", "JoyBack", "JoyStart", "JoyUse", "JoyTabLeft", "JoyTabRight", "JoyHotbarLeft",
			"JoyHotbarRight", "JoyHotbarUse", "JoyGP", "JoyMap", "JoyMenu", "JoyInventory"
		};

		private static readonly HashSet<string> loggedBlocks = new HashSet<string>();

		private static FieldInfo uiGroupsField;

		private static MethodInfo setActiveGroupMethod;

		private static bool uiGroupsLooked;

		private static bool groupsDeactivated;

		private static MethodInfo isContainerOpenMethod;

		private static bool isContainerOpenLooked;

		private static bool tabRouting;

		private static int lastRouteFrame = -1;

		private static int focusStartFrame = -1;

		private int lastStop = int.MinValue;

		private int liveStop = int.MinValue;

		private static bool invHidden = true;

		private static bool invClosing;

		private static char closingFrameWin;

		private static int closingStop = int.MinValue;

		private static float closingTime;

		private bool padInvWasOpen;

		private bool restorePending;

		private static HashSet<int> fieldGroups;

		private static int fieldGroupsCount = -1;

		private static FieldInfo playerGridField;

		private static FieldInfo playerPanelField;

		private static FieldInfo gridElementsField;

		private static bool extraSlotsLooked;

		private static readonly Vector3[] slotCorners = (Vector3[])(object)new Vector3[4];

		private static FieldInfo groupFrameField;

		private CanvasGroup craftFrameHider;

		private float craftFrameOrigAlpha = 1f;

		private bool craftFrameHidden;

		private static FieldInfo tabEffectsField;

		private static bool tabEffectsLooked;

		private readonly Dictionary<char, int> navMemory = new Dictionary<char, int>();

		private readonly Dictionary<int, GameObject> vanillaRemembered = new Dictionary<int, GameObject>();

		private readonly Dictionary<int, bool> vanillaMemoryAllowed = new Dictionary<int, bool>();

		private int vanillaSeenGroup = -1;

		private int vanillaSelectGroup = -1;

		private int vanillaSelectUntil = -10;

		private bool vanillaSeenVisible;

		private bool restoredOnShow;

		private int reopenTarget = int.MinValue;

		private int reopenCheckFrame = -10;

		private int restoreTarget = -1;

		private int restoreGuardUntil = -10;

		private static object savedPlayerSelection;

		private static readonly string[][] otherModControllerHandlers = new string[1][] { new string[3] { "QuickStackStore.KeybindChecker+Player_Update_Patch", "HandleControllerKeys", "Quick Stack Store" } };

		private readonly Dictionary<int, GUIStyle> fittedButtonStyles = new Dictionary<int, GUIStyle>();

		private float panelContentHeight;

		private float panelMinHeight = 60f;

		private readonly Dictionary<int, ScrollState> scrolls = new Dictionary<int, ScrollState>();

		private ScrollState activeScroll;

		private Vector2 curContentOffset;

		private bool panelScrolling;

		private const float ScrollBarWidth = 4f;

		private const float GripSize = 12f;

		private const int HintWindowId = 734517;

		private int drawingWindow;

		private string nextHintText;

		private string shownHintText;

		private Rect nextHintAnchor;

		private Rect shownHintAnchor;

		private int nextHintWindow;

		private int shownHintWindow;

		private Rect menuRect;

		private float nextHintScale = 1f;

		private float shownHintScale = 1f;

		private bool hintCollected;

		private ResizeState panelResize;

		private ResizeState menuResize;

		private const float GripHitSize = 24f;

		private GUIStyle foodTimeStyle;

		private static readonly string[] TrKeys = new string[136]
		{
			"Group", "{0} invites you to a group. Accept: /party accept – Decline: /party decline (or in the inventory)", "{0} joined the group.", "{0} declined the invitation.", "The group is already full.", "This group no longer exists.", "{0} left the group.", "You are no longer in the group.", "You joined the group.", "You are now the group leader.",
			"The leader went offline – you are now the leader.", "{0} went offline and was removed from the group.", "Group created.", "Only the leader can invite.", "{0} is already in the group.", "The group is full.", "Invitation sent to {0}.", "No pending invitation.", "Invitation declined.", "You are not in a group.",
			"You left the group.", "{0} was removed from the group.", "{0} is now the leader.", "Player '{0}' not found (or name not unique).", "Group member '{0}' not found.", "You are not in a group. Invite: /party invite <name>", " (leader)", "dancing", "waving", "sitting",
			"cheering", "laughing", "crying", "kneeling", "pointing", "flexing", "thumbs up", "resting", "calling", "headbanging",
			"sleeping", "in bed", "swimming", "fighting", "mining", "jumping", "sneaking", "running", "emote", "Remaining",
			"Debuff", "{0} died!", "{0} is low on health! ({1}%)", "Members", "No group", "{0} invites you to a group.", "Accept", "Decline", " (you)", "Kick",
			"Leave group", "Players online", "Invite", "No other players on the server.", "Click: show on the map", "no data", "DEAD", "ready", "N NE E SE S SW W NW", "All players online are in your group.",
			"offline", "Waiting {0}s", "{0} was already invited – waiting for an answer.", "{0} did not answer the invitation.", "in combat", "at the helm", "riding", "building", "fishing", "chopping wood",
			"AFK", "planting", "Leader", "Drag: resize · Shift: zoom · Double-click: default size", "Windows locked – nothing can be moved.", "Back", "everything", "bars and food", "only bars", "bars and effects",
			"Now: {0}", "Click: {0}", "In the inventory you always see everything", "Your own effects stay visible in the inventory", "collapsed", "expand", "expanded", "collapse", "side by side", "below each other",
			"locked – nothing moves", "unlocked – drag to move, grip to resize", "lock", "one panel", "separate cards – drag each one anywhere", "separate cards", "join into one panel", "hide this card", "Show it again with HUD in the group menu", "show in the panel again",
			"close the map", "Moving and resizing windows needs the mouse for now", "Controller support for it is planned", "unlock – then move, resize and separate the players' cards", "The chain button on the panel separates the players' cards", "join the group of {0}", "Also without the inventory:", "decline the invitation", "leave the group", "The next member becomes the leader",
			"make {0} the group leader", "remove {0} from the group", "invite {0} to your group", "Or look at the player and press [{0}]", "[{0}] accept · hold [{0}] decline", "Windows unlocked – move, resize and separate the players' cards (chain button).", "Now with the inventory closed: {0}", "or in the inventory", "Decline (hold)", "Right-click: hide in the panel",
			"Drag: zoom · Shift + drag: width and height · Double-click: default size", "Hidden effects: {0}", "Show", "show all hidden effects in the panel again", "Show all", "show {0} in the panel again"
		};

		private static readonly Dictionary<string, string[]> TrBuiltIn = new Dictionary<string, string[]>
		{
			{
				"de",
				new string[136]
				{
					"Gruppe", "{0} lädt dich in eine Gruppe ein. Annehmen: /party accept – Ablehnen: /party decline (oder im Inventar)", "{0} ist der Gruppe beigetreten.", "{0} hat die Einladung abgelehnt.", "Die Gruppe ist bereits voll.", "Diese Gruppe gibt es nicht mehr.", "{0} hat die Gruppe verlassen.", "Du bist nicht mehr in der Gruppe.", "Du bist der Gruppe beigetreten.", "Du bist jetzt Anführer der Gruppe.",
					"Der Anführer ist offline – du bist jetzt Anführer.", "{0} ist nicht mehr online und wurde aus der Gruppe entfernt.", "Gruppe gegründet.", "Nur der Anführer kann einladen.", "{0} ist schon in der Gruppe.", "Die Gruppe ist voll.", "Einladung an {0} gesendet.", "Keine offene Einladung.", "Einladung abgelehnt.", "Du bist in keiner Gruppe.",
					"Du hast die Gruppe verlassen.", "{0} wurde aus der Gruppe entfernt.", "{0} ist jetzt Anführer.", "Spieler '{0}' nicht gefunden (oder Name nicht eindeutig).", "Gruppenmitglied '{0}' nicht gefunden.", "Du bist in keiner Gruppe. Einladen: /party invite <Name>", " (Anführer)", "tanzt", "winkt", "sitzt",
					"jubelt", "lacht", "weint", "kniet", "zeigt", "posiert", "Daumen hoch", "ruht", "ruft", "headbangt",
					"schläft", "im Bett", "schwimmt", "kämpft", "baut ab", "springt", "schleicht", "rennt", "Emote", "Restzeit",
					"Negativer Effekt", "{0} ist gestorben!", "{0} hat wenig Leben! ({1}%)", "Mitglieder", "Keine Gruppe", "{0} lädt dich in eine Gruppe ein.", "Annehmen", "Ablehnen", " (du)", "Entfernen",
					"Gruppe verlassen", "Spieler online", "Einladen", "Keine anderen Spieler auf dem Server.", "Klicken: auf der Karte zeigen", "keine Daten", "TOT", "bereit", "N NO O SO S SW W NW", "Alle Spieler online sind in deiner Gruppe.",
					"offline", "Wartet {0}s", "{0} wurde schon eingeladen – warte auf Antwort.", "{0} hat nicht auf die Einladung geantwortet.", "im Kampf", "am Steuer", "reitet", "baut", "angelt", "hackt Holz",
					"AFK", "pflanzt", "Anführer", "Ziehen: Größe ändern · Shift: zoomen · Doppelklick: Standard", "Fenster gesperrt – nichts lässt sich mehr verschieben.", "Zurück", "alles", "Balken und Essen", "nur Balken", "Balken und Effekte",
					"Jetzt: {0}", "Klick: {0}", "Im Inventar siehst du immer alles", "Deine eigenen Effekte bleiben im Inventar sichtbar", "eingeklappt", "ausklappen", "ausgeklappt", "einklappen", "nebeneinander", "untereinander",
					"gesperrt – nichts verschiebt sich", "entsperrt – ziehen verschiebt, Griff ändert die Größe", "sperren", "ein Panel", "Karten trennen – jede einzeln verschieben", "getrennte Karten", "zu einem Panel verbinden", "diese Karte ausblenden", "Mit HUD im Gruppenmenü wieder einblenden", "wieder im Panel zeigen",
					"Karte schließen", "Fenster verschieben und skalieren geht vorerst nur mit der Maus", "Für den Controller ist es geplant", "entsperren – dann verschieben, skalieren und die Karten der Spieler trennen", "Der Kettenknopf am Panel trennt die Karten der Spieler", "der Gruppe von {0} beitreten", "Auch ohne Inventar:", "Einladung ablehnen", "die Gruppe verlassen", "Das nächste Mitglied wird Anführer",
					"{0} zum Anführer machen", "{0} aus der Gruppe entfernen", "{0} in deine Gruppe einladen", "Oder den Spieler anschauen und [{0}] drücken", "[{0}] annehmen · [{0}] halten ablehnen", "Fenster entsperrt – verschieben, skalieren und die Karten der Spieler trennen (Kettenknopf).", "Jetzt bei geschlossenem Inventar: {0}", "oder im Inventar", "Ablehnen (halten)", "Rechtsklick: im Panel ausblenden",
					"Ziehen: zoomen · Shift + Ziehen: Breite und Höhe · Doppelklick: Standard", "Ausgeblendete Effekte: {0}", "Zeigen", "alle ausgeblendeten Effekte wieder im Panel zeigen", "Alle zeigen", "{0} wieder im Panel zeigen"
				}
			},
			{
				"fr",
				new string[136]
				{
					"Groupe", "{0} vous invite dans un groupe. Accepter : /party accept – Refuser : /party decline (ou dans l'inventaire)", "{0} a rejoint le groupe.", "{0} a refusé l'invitation.", "Le groupe est déjà complet.", "Ce groupe n'existe plus.", "{0} a quitté le groupe.", "Vous ne faites plus partie du groupe.", "Vous avez rejoint le groupe.", "Vous êtes maintenant le chef du groupe.",
					"Le chef s'est déconnecté – vous êtes maintenant le chef.", "{0} s'est déconnecté et a été retiré du groupe.", "Groupe créé.", "Seul le chef peut inviter.", "{0} fait déjà partie du groupe.", "Le groupe est complet.", "Invitation envoyée à {0}.", "Aucune invitation en attente.", "Invitation refusée.", "Vous n'êtes dans aucun groupe.",
					"Vous avez quitté le groupe.", "{0} a été retiré du groupe.", "{0} est maintenant le chef.", "Joueur '{0}' introuvable (ou nom ambigu).", "Membre du groupe '{0}' introuvable.", "Vous n'êtes dans aucun groupe. Inviter : /party invite <nom>", " (chef)", "danse", "salue", "assis",
					"acclame", "rit", "pleure", "à genoux", "pointe", "pose", "pouce levé", "se repose", "appelle", "headbang",
					"dort", "au lit", "nage", "combat", "mine", "saute", "furtif", "court", "emote", "Restant",
					"Effet négatif", "{0} est mort !", "{0} a peu de vie ! ({1}%)", "Membres", "Aucun groupe", "{0} vous invite dans un groupe.", "Accepter", "Refuser", " (vous)", "Exclure",
					"Quitter le groupe", "Joueurs en ligne", "Inviter", "Aucun autre joueur sur le serveur.", "Cliquer : afficher sur la carte", "aucune donnée", "MORT", "prêt", "N NE E SE S SO O NO", "Tous les joueurs en ligne sont dans ton groupe.",
					"hors ligne", "Attente {0}s", "{0} a déjà été invité – en attente de réponse.", "{0} n'a pas répondu à l'invitation.", "en combat", "à la barre", "à cheval", "construit", "pêche", "coupe du bois",
					"AFK", "plante", "Chef", "Glisser : taille · Maj : zoom · Double-clic : par défaut", "Fenêtres verrouillées – plus rien ne bouge.", "Retour", "tout", "barres et nourriture", "barres seules", "barres et effets",
					"Actuel : {0}", "Clic : {0}", "Dans l'inventaire, tu vois toujours tout", "Tes propres effets restent visibles dans l'inventaire", "replié", "déplier", "déplié", "replier", "côte à côte", "les uns sous les autres",
					"verrouillé – rien ne bouge", "déverrouillé – glisser pour déplacer, poignée pour redimensionner", "verrouiller", "un seul panneau", "séparer les cartes – chacune où tu veux", "cartes séparées", "réunir en un panneau", "masquer cette carte", "Réaffiche-la avec HUD dans le menu de groupe", "réafficher dans le panneau",
					"fermer la carte", "Déplacer et redimensionner les fenêtres se fait à la souris pour l'instant", "Le support manette est prévu", "déverrouiller – puis déplacer, redimensionner et séparer les cartes des joueurs", "Le bouton chaîne du panneau sépare les cartes des joueurs", "rejoindre le groupe de {0}", "Aussi sans l'inventaire :", "refuser l'invitation", "quitter le groupe", "Le membre suivant devient chef",
					"faire de {0} le chef du groupe", "retirer {0} du groupe", "inviter {0} dans ton groupe", "Ou regarde le joueur et appuie sur [{0}]", "[{0}] accepter · maintenir [{0}] refuser", "Fenêtres déverrouillées – déplace, redimensionne et sépare les cartes des joueurs (bouton chaîne).", "Actuel, inventaire fermé : {0}", "ou dans l'inventaire", "Refuser (maintenir)", "Clic droit : masquer dans le panneau",
					"Glisser : zoom · Maj + glisser : largeur et hauteur · Double-clic : taille par défaut", "Effets masqués : {0}", "Afficher", "réafficher tous les effets masqués dans le panneau", "Tout afficher", "réafficher {0} dans le panneau"
				}
			},
			{
				"es",
				new string[136]
				{
					"Grupo", "{0} te invita a un grupo. Aceptar: /party accept – Rechazar: /party decline (o en el inventario)", "{0} se ha unido al grupo.", "{0} ha rechazado la invitación.", "El grupo ya está lleno.", "Este grupo ya no existe.", "{0} ha abandonado el grupo.", "Ya no estás en el grupo.", "Te has unido al grupo.", "Ahora eres el líder del grupo.",
					"El líder se ha desconectado – ahora eres el líder.", "{0} se ha desconectado y ha sido expulsado del grupo.", "Grupo creado.", "Solo el líder puede invitar.", "{0} ya está en el grupo.", "El grupo está lleno.", "Invitación enviada a {0}.", "No hay invitaciones pendientes.", "Invitación rechazada.", "No estás en ningún grupo.",
					"Has abandonado el grupo.", "{0} ha sido expulsado del grupo.", "{0} es ahora el líder.", "Jugador '{0}' no encontrado (o nombre ambiguo).", "Miembro del grupo '{0}' no encontrado.", "No estás en ningún grupo. Invitar: /party invite <nombre>", " (líder)", "bailando", "saludando", "sentado",
					"animando", "riendo", "llorando", "arrodillado", "señalando", "presumiendo", "pulgar arriba", "descansando", "llamando", "headbanging",
					"durmiendo", "en la cama", "nadando", "luchando", "minando", "saltando", "sigiloso", "corriendo", "emote", "Restante",
					"Efecto negativo", "¡{0} ha muerto!", "¡{0} tiene poca vida! ({1}%)", "Miembros", "Sin grupo", "{0} te invita a un grupo.", "Aceptar", "Rechazar", " (tú)", "Expulsar",
					"Abandonar grupo", "Jugadores en línea", "Invitar", "No hay otros jugadores en el servidor.", "Clic: mostrar en el mapa", "sin datos", "MUERTO", "listo", "N NE E SE S SO O NO", "Todos los jugadores en línea están en tu grupo.",
					"desconectado", "Esperando {0}s", "{0} ya fue invitado – esperando respuesta.", "{0} no respondió a la invitación.", "en combate", "al timón", "montando", "construyendo", "pescando", "talando",
					"AFK", "plantando", "Líder", "Arrastrar: tamaño · Mayús: zoom · Doble clic: predeterminado", "Ventanas bloqueadas: ya no se puede mover nada.", "Volver", "todo", "barras y comida", "solo barras", "barras y efectos",
					"Ahora: {0}", "Clic: {0}", "En el inventario siempre ves todo", "Tus propios efectos siguen visibles en el inventario", "plegado", "desplegar", "desplegado", "plegar", "lado a lado", "uno debajo de otro",
					"bloqueado – nada se mueve", "desbloqueado – arrastra para mover, esquina para redimensionar", "bloquear", "un panel", "separar tarjetas – cada una donde quieras", "tarjetas separadas", "unir en un panel", "ocultar esta tarjeta", "Vuelve a mostrarla con HUD en el menú de grupo", "mostrar de nuevo en el panel",
					"cerrar el mapa", "Mover y redimensionar ventanas solo funciona con el ratón por ahora", "El soporte para mando está previsto", "desbloquear – luego mover, redimensionar y separar las tarjetas de los jugadores", "El botón de cadena del panel separa las tarjetas de los jugadores", "unirte al grupo de {0}", "También sin el inventario:", "rechazar la invitación", "salir del grupo", "El siguiente miembro será el líder",
					"hacer líder del grupo a {0}", "expulsar a {0} del grupo", "invitar a {0} a tu grupo", "O mira al jugador y pulsa [{0}]", "[{0}] aceptar · mantener [{0}] rechazar", "Ventanas desbloqueadas – mueve, redimensiona y separa las tarjetas de los jugadores (botón de cadena).", "Ahora con el inventario cerrado: {0}", "o en el inventario", "Rechazar (mantener)", "Clic derecho: ocultar en el panel",
					"Arrastrar: zoom · Mayús + arrastrar: ancho y alto · Doble clic: tamaño predeterminado", "Efectos ocultos: {0}", "Mostrar", "volver a mostrar todos los efectos ocultos en el panel", "Mostrar todo", "volver a mostrar {0} en el panel"
				}
			},
			{
				"it",
				new string[136]
				{
					"Gruppo", "{0} ti invita in un gruppo. Accetta: /party accept – Rifiuta: /party decline (o nell'inventario)", "{0} si è unito al gruppo.", "{0} ha rifiutato l'invito.", "Il gruppo è già pieno.", "Questo gruppo non esiste più.", "{0} ha lasciato il gruppo.", "Non fai più parte del gruppo.", "Ti sei unito al gruppo.", "Ora sei il capo del gruppo.",
					"Il capo è offline – ora sei tu il capo.", "{0} è offline ed è stato rimosso dal gruppo.", "Gruppo creato.", "Solo il capo può invitare.", "{0} è già nel gruppo.", "Il gruppo è pieno.", "Invito inviato a {0}.", "Nessun invito in sospeso.", "Invito rifiutato.", "Non sei in nessun gruppo.",
					"Hai lasciato il gruppo.", "{0} è stato rimosso dal gruppo.", "{0} è ora il capo.", "Giocatore '{0}' non trovato (o nome non univoco).", "Membro del gruppo '{0}' non trovato.", "Non sei in nessun gruppo. Invita: /party invite <nome>", " (capo)", "balla", "saluta", "seduto",
					"esulta", "ride", "piange", "in ginocchio", "indica", "si mette in posa", "pollice in su", "riposa", "chiama", "headbanging",
					"dorme", "a letto", "nuota", "combatte", "scava", "salta", "furtivo", "corre", "emote", "Rimanente",
					"Effetto negativo", "{0} è morto!", "{0} ha poca vita! ({1}%)", "Membri", "Nessun gruppo", "{0} ti invita in un gruppo.", "Accetta", "Rifiuta", " (tu)", "Espelli",
					"Lascia gruppo", "Giocatori online", "Invita", "Nessun altro giocatore sul server.", "Clic: mostra sulla mappa", "nessun dato", "MORTO", "pronto", "N NE E SE S SO O NO", "Tutti i giocatori online sono nel tuo gruppo.",
					"offline", "Attesa {0}s", "{0} è già stato invitato – in attesa di risposta.", "{0} non ha risposto all'invito.", "in combattimento", "al timone", "cavalca", "costruisce", "pesca", "taglia legna",
					"AFK", "pianta", "Capo", "Trascina: dimensione · Maiusc: zoom · Doppio clic: predefinito", "Finestre bloccate – non si può più spostare nulla.", "Indietro", "tutto", "barre e cibo", "solo barre", "barre ed effetti",
					"Ora: {0}", "Clic: {0}", "Nell'inventario vedi sempre tutto", "I tuoi effetti restano visibili nell'inventario", "chiuso", "espandi", "espanso", "comprimi", "affiancati", "uno sotto l'altro",
					"bloccato – non si muove nulla", "sbloccato – trascina per spostare, angolo per ridimensionare", "blocca", "un pannello", "separa le schede – ognuna dove vuoi", "schede separate", "unisci in un pannello", "nascondi questa scheda", "Mostrala di nuovo con HUD nel menu del gruppo", "mostra di nuovo nel pannello",
					"chiudi la mappa", "Spostare e ridimensionare le finestre per ora funziona solo col mouse", "Il supporto al controller è previsto", "sblocca – poi sposta, ridimensiona e separa le schede dei giocatori", "Il pulsante catena del pannello separa le schede dei giocatori", "unisciti al gruppo di {0}", "Anche senza inventario:", "rifiuta l'invito", "lascia il gruppo", "Il membro successivo diventa capo",
					"rendi {0} capo del gruppo", "rimuovi {0} dal gruppo", "invita {0} nel tuo gruppo", "Oppure guarda il giocatore e premi [{0}]", "[{0}] accetta · tieni premuto [{0}] rifiuta", "Finestre sbloccate – sposta, ridimensiona e separa le schede dei giocatori (pulsante catena).", "Ora con l'inventario chiuso: {0}", "o nell'inventario", "Rifiuta (tieni premuto)", "Clic destro: nascondi nel pannello",
					"Trascina: zoom · Maiusc + trascina: larghezza e altezza · Doppio clic: dimensione predefinita", "Effetti nascosti: {0}", "Mostra", "mostra di nuovo tutti gli effetti nascosti nel pannello", "Mostra tutti", "mostra di nuovo {0} nel pannello"
				}
			},
			{
				"pt-BR",
				new string[136]
				{
					"Grupo", "{0} convidou você para um grupo. Aceitar: /party accept – Recusar: /party decline (ou no inventário)", "{0} entrou no grupo.", "{0} recusou o convite.", "O grupo já está cheio.", "Este grupo não existe mais.", "{0} saiu do grupo.", "Você não está mais no grupo.", "Você entrou no grupo.", "Agora você é o líder do grupo.",
					"O líder ficou offline – agora você é o líder.", "{0} ficou offline e foi removido do grupo.", "Grupo criado.", "Apenas o líder pode convidar.", "{0} já está no grupo.", "O grupo está cheio.", "Convite enviado para {0}.", "Nenhum convite pendente.", "Convite recusado.", "Você não está em um grupo.",
					"Você saiu do grupo.", "{0} foi removido do grupo.", "{0} agora é o líder.", "Jogador '{0}' não encontrado (ou nome ambíguo).", "Membro do grupo '{0}' não encontrado.", "Você não está em um grupo. Convidar: /party invite <nome>", " (líder)", "dançando", "acenando", "sentado",
					"comemorando", "rindo", "chorando", "ajoelhado", "apontando", "exibindo", "joinha", "descansando", "chamando", "headbanging",
					"dormindo", "na cama", "nadando", "lutando", "minerando", "pulando", "furtivo", "correndo", "emote", "Restante",
					"Efeito negativo", "{0} morreu!", "{0} está com pouca vida! ({1}%)", "Membros", "Sem grupo", "{0} convidou você para um grupo.", "Aceitar", "Recusar", " (você)", "Expulsar",
					"Sair do grupo", "Jogadores online", "Convidar", "Nenhum outro jogador no servidor.", "Clique: mostrar no mapa", "sem dados", "MORTO", "pronto", "N NE L SE S SO O NO", "Todos os jogadores online estão no seu grupo.",
					"offline", "Aguardando {0}s", "{0} já foi convidado – aguardando resposta.", "{0} não respondeu ao convite.", "em combate", "no leme", "montando", "construindo", "pescando", "cortando lenha",
					"AFK", "plantando", "Líder", "Arrastar: tamanho · Shift: zoom · Clique duplo: padrão", "Janelas travadas – nada pode ser movido.", "Voltar", "tudo", "barras e comida", "só barras", "barras e efeitos",
					"Agora: {0}", "Clique: {0}", "No inventário você sempre vê tudo", "Seus próprios efeitos continuam visíveis no inventário", "recolhido", "expandir", "expandido", "recolher", "lado a lado", "um abaixo do outro",
					"travado – nada se move", "destravado – arraste para mover, canto para redimensionar", "travar", "um painel", "separar cartões – cada um onde quiser", "cartões separados", "juntar em um painel", "ocultar este cartão", "Mostre de novo com HUD no menu do grupo", "mostrar de novo no painel",
					"fechar o mapa", "Mover e redimensionar janelas só funciona com o mouse por enquanto", "O suporte a controle está planejado", "destravar – depois mover, redimensionar e separar os cartões dos jogadores", "O botão de corrente no painel separa os cartões dos jogadores", "entrar no grupo de {0}", "Também sem o inventário:", "recusar o convite", "sair do grupo", "O próximo membro vira líder",
					"tornar {0} líder do grupo", "remover {0} do grupo", "convidar {0} para o seu grupo", "Ou olhe para o jogador e aperte [{0}]", "[{0}] aceitar · segurar [{0}] recusar", "Janelas destravadas – mova, redimensione e separe os cartões dos jogadores (botão de corrente).", "Agora com o inventário fechado: {0}", "ou no inventário", "Recusar (segurar)", "Clique direito: ocultar no painel",
					"Arrastar: zoom · Shift + arrastar: largura e altura · Clique duplo: tamanho padrão", "Efeitos ocultos: {0}", "Mostrar", "mostrar de novo todos os efeitos ocultos no painel", "Mostrar todos", "mostrar {0} de novo no painel"
				}
			},
			{
				"pt-PT",
				new string[136]
				{
					"Grupo", "{0} convidou-te para um grupo. Aceitar: /party accept – Recusar: /party decline (ou no inventário)", "{0} juntou-se ao grupo.", "{0} recusou o convite.", "O grupo já está cheio.", "Este grupo já não existe.", "{0} saiu do grupo.", "Já não estás no grupo.", "Juntaste-te ao grupo.", "Agora és o líder do grupo.",
					"O líder ficou offline – agora és o líder.", "{0} ficou offline e foi removido do grupo.", "Grupo criado.", "Só o líder pode convidar.", "{0} já está no grupo.", "O grupo está cheio.", "Convite enviado a {0}.", "Nenhum convite pendente.", "Convite recusado.", "Não estás em nenhum grupo.",
					"Saíste do grupo.", "{0} foi removido do grupo.", "{0} é agora o líder.", "Jogador '{0}' não encontrado (ou nome ambíguo).", "Membro do grupo '{0}' não encontrado.", "Não estás em nenhum grupo. Convidar: /party invite <nome>", " (líder)", "a dançar", "a acenar", "sentado",
					"a festejar", "a rir", "a chorar", "ajoelhado", "a apontar", "a exibir-se", "polegar para cima", "a descansar", "a chamar", "headbanging",
					"a dormir", "na cama", "a nadar", "a lutar", "a minerar", "a saltar", "furtivo", "a correr", "emote", "Restante",
					"Efeito negativo", "{0} morreu!", "{0} tem pouca vida! ({1}%)", "Membros", "Sem grupo", "{0} convidou-te para um grupo.", "Aceitar", "Recusar", " (tu)", "Expulsar",
					"Sair do grupo", "Jogadores online", "Convidar", "Nenhum outro jogador no servidor.", "Clicar: mostrar no mapa", "sem dados", "MORTO", "pronto", "N NE E SE S SO O NO", "Todos os jogadores online estão no teu grupo.",
					"offline", "A aguardar {0}s", "{0} já foi convidado – a aguardar resposta.", "{0} não respondeu ao convite.", "em combate", "ao leme", "a montar", "a construir", "a pescar", "a cortar lenha",
					"AFK", "a plantar", "Líder", "Arrastar: tamanho · Shift: zoom · Duplo clique: predefinição", "Janelas bloqueadas – nada pode ser movido.", "Voltar", "tudo", "barras e comida", "só barras", "barras e efeitos",
					"Agora: {0}", "Clique: {0}", "No inventário vês sempre tudo", "Os teus efeitos continuam visíveis no inventário", "recolhido", "expandir", "expandido", "recolher", "lado a lado", "um por baixo do outro",
					"bloqueado – nada se move", "desbloqueado – arrasta para mover, canto para redimensionar", "bloquear", "um painel", "separar cartões – cada um onde quiseres", "cartões separados", "juntar num painel", "ocultar este cartão", "Mostra de novo com HUD no menu do grupo", "mostrar de novo no painel",
					"fechar o mapa", "Mover e redimensionar janelas só funciona com o rato por agora", "O suporte para comando está planeado", "desbloquear – depois mover, redimensionar e separar os cartões dos jogadores", "O botão de corrente no painel separa os cartões dos jogadores", "entrar no grupo de {0}", "Também sem o inventário:", "recusar o convite", "sair do grupo", "O membro seguinte passa a líder",
					"tornar {0} líder do grupo", "remover {0} do grupo", "convidar {0} para o teu grupo", "Ou olha para o jogador e carrega em [{0}]", "[{0}] aceitar · manter [{0}] recusar", "Janelas desbloqueadas – move, redimensiona e separa os cartões dos jogadores (botão de corrente).", "Agora com o inventário fechado: {0}", "ou no inventário", "Recusar (manter premido)", "Clique direito: ocultar no painel",
					"Arrastar: zoom · Shift + arrastar: largura e altura · Duplo clique: tamanho predefinido", "Efeitos ocultos: {0}", "Mostrar", "voltar a mostrar todos os efeitos ocultos no painel", "Mostrar todos", "voltar a mostrar {0} no painel"
				}
			},
			{
				"ru",
				new string[136]
				{
					"Группа", "{0} приглашает вас в группу. Принять: /party accept – Отклонить: /party decline (или в инвентаре)", "{0} вступил(а) в группу.", "{0} отклонил(а) приглашение.", "Группа уже заполнена.", "Этой группы больше нет.", "{0} покинул(а) группу.", "Вы больше не в группе.", "Вы вступили в группу.", "Теперь вы лидер группы.",
					"Лидер вышел из игры – теперь лидер вы.", "{0} вышел(а) из игры и был(а) удален(а) из группы.", "Группа создана.", "Приглашать может только лидер.", "{0} уже в группе.", "Группа заполнена.", "Приглашение отправлено: {0}.", "Нет ожидающих приглашений.", "Приглашение отклонено.", "Вы не в группе.",
					"Вы покинули группу.", "{0} удален(а) из группы.", "{0} теперь лидер.", "Игрок '{0}' не найден (или имя неоднозначно).", "Участник группы '{0}' не найден.", "Вы не в группе. Пригласить: /party invite <имя>", " (лидер)", "танцует", "машет", "сидит",
					"ликует", "смеётся", "плачет", "на коленях", "указывает", "красуется", "палец вверх", "отдыхает", "зовёт", "хедбэнгинг",
					"спит", "в кровати", "плывёт", "сражается", "добывает", "прыгает", "крадётся", "бежит", "эмоция", "Осталось",
					"Негативный эффект", "{0} погиб(ла)!", "У {0} мало здоровья! ({1}%)", "Участники", "Нет группы", "{0} приглашает вас в группу.", "Принять", "Отклонить", " (вы)", "Исключить",
					"Покинуть группу", "Игроки онлайн", "Пригласить", "На сервере нет других игроков.", "Клик: показать на карте", "нет данных", "МЁРТВ", "готово", "С СВ В ЮВ Ю ЮЗ З СЗ", "Все игроки онлайн уже в твоей группе.",
					"не в сети", "Ждём {0} с", "{0} уже приглашён – ждём ответа.", "{0} не ответил на приглашение.", "в бою", "у штурвала", "верхом", "строит", "рыбачит", "рубит лес",
					"AFK", "сажает", "Лидер", "Тянуть: размер · Shift: масштаб · Двойной щелчок: по умолчанию", "Окна закреплены – ничего нельзя сдвинуть.", "Назад", "всё", "полосы и еда", "только полосы", "полосы и эффекты",
					"Сейчас: {0}", "Клик: {0}", "В инвентаре всегда видно всё", "Твои эффекты остаются видны в инвентаре", "свёрнуто", "развернуть", "развёрнуто", "свернуть", "рядом", "друг под другом",
					"заблокировано – ничего не двигается", "разблокировано – тяни для перемещения, угол для размера", "заблокировать", "одна панель", "разделить карточки – каждую куда угодно", "отдельные карточки", "объединить в одну панель", "скрыть эту карточку", "Вернуть кнопкой HUD в меню группы", "снова показать на панели",
					"закрыть карту", "Перемещать и менять размер окон пока можно только мышью", "Поддержка контроллера запланирована", "разблокировать – затем двигать, менять размер и разделять карточки игроков", "Кнопка-цепь на панели разделяет карточки игроков", "вступить в группу {0}", "Также без инвентаря:", "отклонить приглашение", "покинуть группу", "Лидером станет следующий участник",
					"сделать {0} лидером группы", "исключить {0} из группы", "пригласить {0} в группу", "Или посмотри на игрока и нажми [{0}]", "[{0}] принять · удерживать [{0}] отклонить", "Окна разблокированы – двигай, меняй размер и разделяй карточки игроков (кнопка-цепь).", "Сейчас при закрытом инвентаре: {0}", "или в инвентаре", "Отклонить (удерживать)", "ПКМ: скрыть на панели",
					"Перетащить: масштаб · Shift + перетащить: ширина и высота · Двойной клик: по умолчанию", "Скрытые эффекты: {0}", "Показать", "снова показать все скрытые эффекты на панели", "Показать все", "снова показать {0} на панели"
				}
			},
			{
				"uk",
				new string[136]
				{
					"Група", "{0} запрошує вас до групи. Прийняти: /party accept – Відхилити: /party decline (або в інвентарі)", "{0} приєднався(-лась) до групи.", "{0} відхилив(-ла) запрошення.", "Група вже заповнена.", "Цієї групи більше не існує.", "{0} покинув(-ла) групу.", "Ви більше не в групі.", "Ви приєдналися до групи.", "Тепер ви лідер групи.",
					"Лідер вийшов з гри – тепер лідер ви.", "{0} вийшов(-ла) з гри та був(-ла) вилучений(-а) з групи.", "Групу створено.", "Запрошувати може лише лідер.", "{0} вже в групі.", "Група заповнена.", "Запрошення надіслано: {0}.", "Немає очікуваних запрошень.", "Запрошення відхилено.", "Ви не в групі.",
					"Ви покинули групу.", "{0} вилучено з групи.", "{0} тепер лідер.", "Гравця '{0}' не знайдено (або ім'я неоднозначне).", "Учасника групи '{0}' не знайдено.", "Ви не в групі. Запросити: /party invite <ім'я>", " (лідер)", "танцює", "махає", "сидить",
					"радіє", "сміється", "плаче", "на колінах", "вказує", "красується", "клас", "відпочиває", "кличе", "хедбенгінг",
					"спить", "у ліжку", "пливе", "бʼється", "видобуває", "стрибає", "крадеться", "біжить", "емоція", "Залишилось",
					"Негативний ефект", "{0} загинув(-ла)!", "У {0} мало здоров'я! ({1}%)", "Учасники", "Немає групи", "{0} запрошує вас до групи.", "Прийняти", "Відхилити", " (ви)", "Вилучити",
					"Покинути групу", "Гравці онлайн", "Запросити", "На сервері немає інших гравців.", "Клік: показати на мапі", "немає даних", "МЕРТВИЙ", "готово", "Пн ПнС С ПдС Пд ПдЗ З ПнЗ", "Усі гравці онлайн уже у твоїй групі.",
					"не в мережі", "Чекаємо {0} с", "{0} вже запрошено – чекаємо відповіді.", "{0} не відповів на запрошення.", "у бою", "за кермом", "верхи", "будує", "рибалить", "рубає дерево",
					"AFK", "садить", "Лідер", "Тягнути: розмір · Shift: масштаб · Подвійний клік: стандарт", "Вікна закріплено – нічого не можна зсунути.", "Назад", "усе", "смуги та їжа", "лише смуги", "смуги та ефекти",
					"Зараз: {0}", "Клік: {0}", "В інвентарі завжди видно все", "Твої ефекти лишаються видимими в інвентарі", "згорнуто", "розгорнути", "розгорнуто", "згорнути", "поруч", "одне під одним",
					"заблоковано – нічого не рухається", "розблоковано – тягни для переміщення, кут для розміру", "заблокувати", "одна панель", "розділити картки – кожну куди завгодно", "окремі картки", "об'єднати в одну панель", "сховати цю картку", "Повернути кнопкою HUD у меню групи", "знову показати на панелі",
					"закрити карту", "Переміщувати й змінювати розмір вікон поки можна лише мишею", "Підтримку контролера заплановано", "розблокувати – потім рухати, змінювати розмір і розділяти картки гравців", "Кнопка-ланцюг на панелі розділяє картки гравців", "приєднатися до групи {0}", "Також без інвентаря:", "відхилити запрошення", "покинути групу", "Лідером стане наступний учасник",
					"зробити {0} лідером групи", "вилучити {0} з групи", "запросити {0} до групи", "Або подивись на гравця й натисни [{0}]", "[{0}] прийняти · утримувати [{0}] відхилити", "Вікна розблоковано – рухай, змінюй розмір і розділяй картки гравців (кнопка-ланцюг).", "Зараз при закритому інвентарі: {0}", "або в інвентарі", "Відхилити (утримувати)", "ПКМ: сховати на панелі",
					"Перетягнути: масштаб · Shift + перетягнути: ширина і висота · Подвійний клік: типовий розмір", "Приховані ефекти: {0}", "Показати", "знову показати всі приховані ефекти на панелі", "Показати всі", "знову показати {0} на панелі"
				}
			},
			{
				"pl",
				new string[136]
				{
					"Drużyna", "{0} zaprasza cię do drużyny. Akceptuj: /party accept – Odrzuć: /party decline (lub w ekwipunku)", "{0} dołączył(a) do drużyny.", "{0} odrzucił(a) zaproszenie.", "Drużyna jest już pełna.", "Ta drużyna już nie istnieje.", "{0} opuścił(a) drużynę.", "Nie jesteś już w drużynie.", "Dołączyłeś(-aś) do drużyny.", "Jesteś teraz liderem drużyny.",
					"Lider jest offline – teraz ty jesteś liderem.", "{0} jest offline i został(a) usunięty(-a) z drużyny.", "Utworzono drużynę.", "Tylko lider może zapraszać.", "{0} jest już w drużynie.", "Drużyna jest pełna.", "Wysłano zaproszenie do {0}.", "Brak oczekujących zaproszeń.", "Odrzucono zaproszenie.", "Nie jesteś w żadnej drużynie.",
					"Opuściłeś(-aś) drużynę.", "{0} został(a) usunięty(-a) z drużyny.", "{0} jest teraz liderem.", "Nie znaleziono gracza '{0}' (lub nazwa niejednoznaczna).", "Nie znaleziono członka drużyny '{0}'.", "Nie jesteś w żadnej drużynie. Zaproś: /party invite <nazwa>", " (lider)", "tańczy", "macha", "siedzi",
					"wiwatuje", "śmieje się", "płacze", "klęczy", "wskazuje", "pręży się", "kciuk w górę", "odpoczywa", "woła", "headbanging",
					"śpi", "w łóżku", "pływa", "walczy", "kopie", "skacze", "skrada się", "biegnie", "emotka", "Pozostało",
					"Negatywny efekt", "{0} zginął(-ęła)!", "{0} ma mało zdrowia! ({1}%)", "Członkowie", "Brak drużyny", "{0} zaprasza cię do drużyny.", "Akceptuj", "Odrzuć", " (ty)", "Wyrzuć",
					"Opuść drużynę", "Gracze online", "Zaproś", "Brak innych graczy na serwerze.", "Kliknij: pokaż na mapie", "brak danych", "MARTWY", "gotowe", "N NE E SE S SW W NW", "Wszyscy gracze online są w twojej grupie.",
					"offline", "Czekam {0}s", "{0} został już zaproszony – czekam na odpowiedź.", "{0} nie odpowiedział na zaproszenie.", "w walce", "za sterem", "jedzie", "buduje", "łowi ryby", "rąbie drewno",
					"AFK", "sadzi", "Lider", "Przeciągnij: rozmiar · Shift: powiększenie · Dwuklik: domyślnie", "Okna zablokowane – nic nie można przesunąć.", "Wróć", "wszystko", "paski i jedzenie", "tylko paski", "paski i efekty",
					"Teraz: {0}", "Kliknij: {0}", "W ekwipunku zawsze widzisz wszystko", "Twoje efekty pozostają widoczne w ekwipunku", "zwinięte", "rozwiń", "rozwinięte", "zwiń", "obok siebie", "jedno pod drugim",
					"zablokowane – nic się nie rusza", "odblokowane – przeciągnij, aby przesunąć, róg zmienia rozmiar", "zablokuj", "jeden panel", "rozdziel karty – każdą gdzie chcesz", "osobne karty", "połącz w jeden panel", "ukryj tę kartę", "Przywróć przyciskiem HUD w menu grupy", "pokaż znowu w panelu",
					"zamknij mapę", "Przesuwanie i zmiana rozmiaru okien na razie tylko myszą", "Obsługa kontrolera jest planowana", "odblokuj – potem przesuwaj, zmieniaj rozmiar i rozdzielaj karty graczy", "Przycisk łańcucha na panelu rozdziela karty graczy", "dołącz do grupy {0}", "Także bez ekwipunku:", "odrzuć zaproszenie", "opuść grupę", "Następny członek zostaje liderem",
					"uczyń {0} liderem grupy", "usuń {0} z grupy", "zaproś {0} do swojej grupy", "Albo spójrz na gracza i naciśnij [{0}]", "[{0}] przyjmij · przytrzymaj [{0}] odrzuć", "Okna odblokowane – przesuwaj, zmieniaj rozmiar i rozdzielaj karty graczy (przycisk łańcucha).", "Teraz przy zamkniętym ekwipunku: {0}", "albo w ekwipunku", "Odrzuć (przytrzymaj)", "Prawy przycisk: ukryj w panelu",
					"Przeciągnij: powiększenie · Shift + przeciągnij: szerokość i wysokość · Dwuklik: domyślny rozmiar", "Ukryte efekty: {0}", "Pokaż", "pokaż ponownie wszystkie ukryte efekty w panelu", "Pokaż wszystkie", "pokaż ponownie {0} w panelu"
				}
			},
			{
				"tr",
				new string[136]
				{
					"Grup", "{0} seni bir gruba davet ediyor. Kabul: /party accept – Reddet: /party decline (veya envanterde)", "{0} gruba katıldı.", "{0} daveti reddetti.", "Grup zaten dolu.", "Bu grup artık mevcut değil.", "{0} gruptan ayrıldı.", "Artık grupta değilsin.", "Gruba katıldın.", "Artık grubun lideri sensin.",
					"Lider çevrimdışı oldu – artık lider sensin.", "{0} çevrimdışı oldu ve gruptan çıkarıldı.", "Grup oluşturuldu.", "Sadece lider davet edebilir.", "{0} zaten grupta.", "Grup dolu.", "{0} adlı oyuncuya davet gönderildi.", "Bekleyen davet yok.", "Davet reddedildi.", "Bir grupta değilsin.",
					"Gruptan ayrıldın.", "{0} gruptan çıkarıldı.", "{0} artık lider.", "'{0}' adlı oyuncu bulunamadı (veya isim belirsiz).", "'{0}' adlı grup üyesi bulunamadı.", "Bir grupta değilsin. Davet et: /party invite <isim>", " (lider)", "dans ediyor", "el sallıyor", "oturuyor",
					"tezahürat yapıyor", "gülüyor", "ağlıyor", "diz çökmüş", "işaret ediyor", "poz veriyor", "başparmak yukarı", "dinleniyor", "çağırıyor", "headbang",
					"uyuyor", "yatakta", "yüzüyor", "savaşıyor", "kazıyor", "zıplıyor", "gizleniyor", "koşuyor", "ifade", "Kalan",
					"Olumsuz etki", "{0} öldü!", "{0} az canla! ({1}%)", "Üyeler", "Grup yok", "{0} seni bir gruba davet ediyor.", "Kabul et", "Reddet", " (sen)", "At",
					"Gruptan ayrıl", "Çevrimiçi oyuncular", "Davet et", "Sunucuda başka oyuncu yok.", "Tıkla: haritada göster", "veri yok", "ÖLÜ", "hazır", "K KD D GD G GB B KB", "Çevrimiçi tüm oyuncular grubunda.",
					"çevrimdışı", "Bekleniyor {0}sn", "{0} zaten davet edildi – yanıt bekleniyor.", "{0} davete yanıt vermedi.", "savaşta", "dümende", "biniyor", "inşa ediyor", "balık tutuyor", "odun kesiyor",
					"AFK", "ekiyor", "Lider", "Sürükle: boyut · Shift: yakınlaştır · Çift tık: varsayılan", "Pencereler kilitlendi – hiçbir şey taşınamaz.", "Geri", "hepsi", "çubuklar ve yemek", "sadece çubuklar", "çubuklar ve efektler",
					"Şu an: {0}", "Tıkla: {0}", "Envanterde her zaman her şeyi görürsün", "Kendi efektlerin envanterde görünür kalır", "daraltılmış", "genişlet", "genişletilmiş", "daralt", "yan yana", "alt alta",
					"kilitli – hiçbir şey kaymaz", "kilit açık – taşımak için sürükle, boyut için köşe", "kilitle", "tek panel", "kartları ayır – her birini istediğin yere", "ayrı kartlar", "tek panelde birleştir", "bu kartı gizle", "Grup menüsünde HUD ile tekrar göster", "panelde tekrar göster",
					"haritayı kapat", "Pencereleri taşımak ve boyutlandırmak şimdilik sadece fareyle", "Kontrolcü desteği planlanıyor", "kilidi aç – sonra oyuncu kartlarını taşı, boyutlandır ve ayır", "Paneldeki zincir düğmesi oyuncu kartlarını ayırır", "{0} grubuna katıl", "Envanter olmadan da:", "daveti reddet", "gruptan ayrıl", "Sıradaki üye lider olur",
					"{0} grubun lideri olsun", "{0} gruptan çıkar", "{0} grubuna davet et", "Ya da oyuncuya bak ve [{0}] bas", "[{0}] kabul · basılı tut [{0}] reddet", "Pencerelerin kilidi açık – oyuncu kartlarını taşı, boyutlandır ve ayır (zincir düğmesi).", "Şu an envanter kapalıyken: {0}", "veya envanterde", "Reddet (basılı tut)", "Sağ tık: panelde gizle",
					"Sürükle: yakınlaştır · Shift + sürükle: genişlik ve yükseklik · Çift tık: varsayılan boyut", "Gizli efektler: {0}", "Göster", "paneldeki tüm gizli efektleri yeniden göster", "Tümünü göster", "{0} panelde yeniden göster"
				}
			},
			{
				"ja",
				new string[136]
				{
					"グループ", "{0}からグループに招待されました。承諾: /party accept – 拒否: /party decline（またはインベントリで）", "{0}がグループに参加しました。", "{0}が招待を拒否しました。", "グループはすでに満員です。", "このグループはもう存在しません。", "{0}がグループから抜けました。", "グループから外れました。", "グループに参加しました。", "あなたがグループのリーダーになりました。",
					"リーダーがオフラインになりました – あなたがリーダーです。", "{0}がオフラインになり、グループから外されました。", "グループを作成しました。", "招待できるのはリーダーだけです。", "{0}はすでにグループにいます。", "グループは満員です。", "{0}に招待を送りました。", "保留中の招待はありません。", "招待を拒否しました。", "グループに入っていません。",
					"グループから抜けました。", "{0}をグループから外しました。", "{0}がリーダーになりました。", "プレイヤー「{0}」が見つかりません（または名前が曖昧です）。", "グループメンバー「{0}」が見つかりません。", "グループに入っていません。招待: /party invite <名前>", "（リーダー）", "ダンス中", "手を振っている", "座っている",
					"応援中", "笑っている", "泣いている", "ひざまずいている", "指さし中", "ポーズ中", "いいね", "休憩中", "呼んでいる", "ヘドバン中",
					"睡眠中", "ベッド", "水泳中", "戦闘中", "採掘中", "ジャンプ中", "忍び足", "走っている", "エモート", "残り時間",
					"デバフ", "{0}が死亡しました！", "{0}の体力が低下！（{1}%）", "メンバー", "グループなし", "{0}からグループに招待されました。", "承諾", "拒否", "（あなた）", "追放",
					"グループを抜ける", "オンラインのプレイヤー", "招待", "サーバーに他のプレイヤーはいません。", "クリック: マップで表示", "データなし", "死亡", "準備完了", "北 北東 東 南東 南 南西 西 北西", "オンラインのプレイヤーは全員グループにいます。",
					"オフライン", "待機中 {0}秒", "{0} はすでに招待済みです – 返事を待っています。", "{0} は招待に応答しませんでした。", "戦闘中", "操舵中", "騎乗中", "建築中", "釣り中", "伐採中",
					"AFK", "植え付け中", "リーダー", "ドラッグ: サイズ変更 · Shift: ズーム · ダブルクリック: 標準", "ウィンドウを固定しました – 移動できません。", "戻る", "すべて", "バーと食事", "バーのみ", "バーと効果",
					"現在: {0}", "クリック: {0}", "インベントリではいつもすべて表示", "自分の効果はインベントリで常に表示", "折りたたみ中", "展開", "展開中", "折りたたむ", "横並び", "縦並び",
					"ロック中 – 何も動かない", "ロック解除中 – ドラッグで移動、角でサイズ変更", "ロック", "1つのパネル", "カードを分離 – それぞれ好きな場所へ", "分離したカード", "1つのパネルにまとめる", "このカードを隠す", "グループメニューのHUDで再表示", "パネルに再表示",
					"マップを閉じる", "ウィンドウの移動とサイズ変更は今はマウスのみ", "コントローラー対応は予定しています", "ロック解除 – プレイヤーのカードを移動・サイズ変更・分離", "パネルのチェーンボタンでプレイヤーのカードを分離", "{0}のグループに参加", "インベントリなしでも:", "招待を断る", "グループを抜ける", "次のメンバーがリーダーになります",
					"{0}をリーダーにする", "{0}をグループから外す", "{0}をグループに招待", "またはプレイヤーを見て[{0}]を押す", "[{0}] 承諾 · [{0}] 長押しで拒否", "ロック解除 – プレイヤーのカードを移動・サイズ変更・分離できます（チェーンボタン）。", "現在（インベントリを閉じた時）: {0}", "またはインベントリで", "断る（長押し）", "右クリック：パネルで非表示",
					"ドラッグ：ズーム · Shift＋ドラッグ：幅と高さ · ダブルクリック：標準サイズ", "非表示の効果：{0}", "表示", "パネルで非表示にした効果をすべて再表示", "すべて表示", "{0} をパネルに再表示"
				}
			},
			{
				"ko",
				new string[136]
				{
					"그룹", "{0}님이 그룹에 초대했습니다. 수락: /party accept – 거절: /party decline (또는 인벤토리에서)", "{0}님이 그룹에 참가했습니다.", "{0}님이 초대를 거절했습니다.", "그룹이 이미 가득 찼습니다.", "이 그룹은 더 이상 존재하지 않습니다.", "{0}님이 그룹을 떠났습니다.", "더 이상 그룹에 속해 있지 않습니다.", "그룹에 참가했습니다.", "이제 그룹의 리더입니다.",
					"리더가 오프라인이 되었습니다 – 이제 당신이 리더입니다.", "{0}님이 오프라인이 되어 그룹에서 제외되었습니다.", "그룹을 만들었습니다.", "리더만 초대할 수 있습니다.", "{0}님은 이미 그룹에 있습니다.", "그룹이 가득 찼습니다.", "{0}님에게 초대를 보냈습니다.", "대기 중인 초대가 없습니다.", "초대를 거절했습니다.", "그룹에 속해 있지 않습니다.",
					"그룹을 떠났습니다.", "{0}님을 그룹에서 제외했습니다.", "{0}님이 이제 리더입니다.", "플레이어 '{0}'을(를) 찾을 수 없습니다 (또는 이름이 모호합니다).", "그룹 멤버 '{0}'을(를) 찾을 수 없습니다.", "그룹에 속해 있지 않습니다. 초대: /party invite <이름>", " (리더)", "춤추는 중", "손 흔드는 중", "앉아 있음",
					"환호 중", "웃는 중", "우는 중", "무릎 꿇음", "가리키는 중", "포즈 중", "엄지 척", "휴식 중", "부르는 중", "헤드뱅잉",
					"수면 중", "침대", "수영 중", "전투 중", "채굴 중", "점프 중", "은신 중", "달리는 중", "감정 표현", "남은 시간",
					"해로운 효과", "{0}님이 사망했습니다!", "{0}님의 체력이 낮습니다! ({1}%)", "멤버", "그룹 없음", "{0}님이 그룹에 초대했습니다.", "수락", "거절", " (나)", "추방",
					"그룹 나가기", "온라인 플레이어", "초대", "서버에 다른 플레이어가 없습니다.", "클릭: 지도에 표시", "데이터 없음", "사망", "준비됨", "북 북동 동 남동 남 남서 서 북서", "온라인 플레이어가 모두 그룹에 있습니다.",
					"오프라인", "대기 중 {0}초", "{0}님은 이미 초대되었습니다 – 응답을 기다리는 중입니다.", "{0}님이 초대에 응답하지 않았습니다.", "전투 중", "조타 중", "탑승 중", "건설 중", "낚시 중", "벌목 중",
					"AFK", "심는 중", "리더", "드래그: 크기 · Shift: 확대 · 더블클릭: 기본값", "창이 잠겼습니다 – 아무것도 옮길 수 없습니다.", "뒤로", "전체", "바와 음식", "바만", "바와 효과",
					"현재: {0}", "클릭: {0}", "인벤토리에서는 항상 전체가 보입니다", "내 효과는 인벤토리에서 계속 보입니다", "접힘", "펼치기", "펼침", "접기", "나란히", "위아래로",
					"잠김 – 아무것도 움직이지 않음", "잠금 해제됨 – 드래그로 이동, 모서리로 크기 조절", "잠그기", "하나의 패널", "카드 분리 – 각각 원하는 곳으로", "분리된 카드", "하나의 패널로 합치기", "이 카드 숨