using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Splatform;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("Deathboard.Client")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Client companion for Deathboard realm servers. Inert everywhere else.")]
[assembly: AssemblyFileVersion("3.0.0.0")]
[assembly: AssemblyInformationalVersion("3.0.0+50a58f88d65ce17edb1ecef1547196a134bc4c9c")]
[assembly: AssemblyProduct("Deathboard.Client")]
[assembly: AssemblyTitle("Deathboard.Client")]
[assembly: AssemblyVersion("3.0.0.0")]
namespace Deathboard
{
	internal struct BoardRow
	{
		public string Name;

		public int Deaths;

		public bool HasSkills;

		public float Combat;

		public float Acro;

		public float Hand;

		public float Power;

		public bool Online;
	}
	internal struct BoardRequest
	{
		public int Protocol;

		public byte Kind;

		public byte Sort;
	}
	internal struct BossTick
	{
		public string Key;

		public string Name;

		public bool Down;
	}
	internal sealed class BoardView
	{
		public int Protocol;

		public byte Kind;

		public byte Sort;

		public string Title = "";

		public string[] Labels = new string[3] { "Combat", "Agility", "Trades" };

		public bool ShowPower = true;

		public string Formula = "";

		public int TotalDeaths;

		public int WorldDay;

		public List<BoardRow> Rows = new List<BoardRow>();

		public List<BossTick> Bosses = new List<BossTick>();
	}
	internal static class BoardPayload
	{
		internal static class BoardKindWire
		{
			public const byte Deaths = 0;

			public const byte Power = 1;

			public const byte Combat = 2;

			public const byte Acro = 3;

			public const byte Hand = 4;

			public const byte Who = 5;

			public const byte Count = 6;
		}

		public const int MaxBosses = 32;

		public const int MaxRows = 200;

		public const int MaxNameChars = 64;

		public const byte SortAscending = 0;

		public const byte SortDescending = 1;

		public static ZPackage WriteRequest(byte kind, byte sort)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(kind);
			val.Write((sort != 0) ? ((byte)1) : ((byte)0));
			return val;
		}

		public static bool TryReadRequest(ZPackage pkg, out BoardRequest request)
		{
			request = default(BoardRequest);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				request.Protocol = pkg.ReadInt();
				request.Kind = pkg.ReadByte();
				request.Sort = ((pkg.ReadByte() != 0) ? ((byte)1) : ((byte)0));
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static ZPackage WriteBoard(byte kind, byte sort, string title, string[] labels, bool showPower, string formula, int totalDeaths, int worldDay, IList<BoardRow> rows, IList<BossTick> bosses)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(kind);
			val.Write((sort != 0) ? ((byte)1) : ((byte)0));
			val.Write(title ?? "");
			string[] array = ((labels != null && labels.Length == 3) ? labels : new string[3] { "Combat", "Agility", "Trades" });
			val.Write(array[0] ?? "");
			val.Write(array[1] ?? "");
			val.Write(array[2] ?? "");
			val.Write(showPower);
			val.Write(formula ?? "");
			val.Write(totalDeaths);
			val.Write(worldDay);
			int num = ((rows != null) ? Math.Min(rows.Count, 200) : 0);
			val.Write(num);
			for (int i = 0; i < num; i++)
			{
				BoardRow boardRow = rows[i];
				val.Write(Trim(boardRow.Name));
				val.Write(boardRow.Deaths);
				val.Write(boardRow.HasSkills);
				val.Write(boardRow.Combat);
				val.Write(boardRow.Acro);
				val.Write(boardRow.Hand);
				val.Write(boardRow.Power);
				val.Write(boardRow.Online);
			}
			int num2 = ((bosses != null) ? Math.Min(bosses.Count, 32) : 0);
			val.Write(num2);
			for (int j = 0; j < num2; j++)
			{
				BossTick bossTick = bosses[j];
				val.Write(Trim(bossTick.Key));
				val.Write(Trim(bossTick.Name));
				val.Write(bossTick.Down);
			}
			return val;
		}

		public static bool TryReadBoard(ZPackage pkg, out BoardView view)
		{
			view = null;
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				BoardView boardView = new BoardView();
				boardView.Protocol = pkg.ReadInt();
				boardView.Kind = pkg.ReadByte();
				boardView.Sort = ((pkg.ReadByte() != 0) ? ((byte)1) : ((byte)0));
				boardView.Title = pkg.ReadString() ?? "";
				boardView.Labels = new string[3]
				{
					pkg.ReadString() ?? "Combat",
					pkg.ReadString() ?? "Agility",
					pkg.ReadString() ?? "Trades"
				};
				boardView.ShowPower = pkg.ReadBool();
				boardView.Formula = pkg.ReadString() ?? "";
				boardView.TotalDeaths = pkg.ReadInt();
				boardView.WorldDay = pkg.ReadInt();
				int num = pkg.ReadInt();
				if (num < 0 || num > 200)
				{
					return false;
				}
				boardView.Rows = new List<BoardRow>(num);
				for (int i = 0; i < num; i++)
				{
					BoardRow item = new BoardRow
					{
						Name = Trim(pkg.ReadString()),
						Deaths = pkg.ReadInt(),
						HasSkills = pkg.ReadBool(),
						Combat = pkg.ReadSingle(),
						Acro = pkg.ReadSingle(),
						Hand = pkg.ReadSingle(),
						Power = pkg.ReadSingle(),
						Online = pkg.ReadBool()
					};
					boardView.Rows.Add(item);
				}
				int num2 = pkg.ReadInt();
				if (num2 < 0 || num2 > 32)
				{
					return false;
				}
				boardView.Bosses = new List<BossTick>(num2);
				for (int j = 0; j < num2; j++)
				{
					BossTick item2 = new BossTick
					{
						Key = Trim(pkg.ReadString()),
						Name = Trim(pkg.ReadString()),
						Down = pkg.ReadBool()
					};
					boardView.Bosses.Add(item2);
				}
				view = boardView;
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static string Trim(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return "?";
			}
			return DeathCause.Sanitize(name, 64);
		}
	}
	internal static class BuildInfo
	{
		public const string ServerName = "Deathboard";

		public const string ServerGuid = "com.deathboard.valheim";

		public const string ClientName = "Deathboard.Client";

		public const string ClientGuid = "com.deathboard.valheim.client";

		public const string DisplayName = "The Great Hall";

		public const string Author = "Zomax";

		public const string Version = "3.0.0";

		public const int Build = 51;

		public static string ServerBanner => "Deathboard v3.0.0 build " + 51;

		public static string ClientBanner => "Deathboard.Client v3.0.0 build " + 51;

		public static string PublicBanner => "The Great Hall v3.0.0 build " + 51;
	}
	internal static class DeathCause
	{
		public const int MaxKeyChars = 64;

		public const char EnvPrefix = '#';

		public const char PlayerPrefix = '@';

		private static readonly string[] HitTypes = new string[25]
		{
			"Undefined", "EnemyHit", "PlayerHit", "Fall", "Drowning", "Burning", "Freezing", "Poisoned", "Water", "Smoke",
			"EdgeOfWorld", "Impact", "Cart", "Tree", "Self", "Structural", "Turret", "Boat", "Stalagtite", "Catapult",
			"CinderFire", "AshlandsOcean", "AshlandsLava", "Incinerator", "DrawBridge"
		};

		private static readonly Dictionary<string, string> EnvLabels = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			{ "Undefined", "Unknown" },
			{ "Fall", "Falling" },
			{ "Drowning", "Drowning" },
			{ "Burning", "Fire" },
			{ "Freezing", "Cold" },
			{ "Poisoned", "Poison" },
			{ "Water", "Deep Water" },
			{ "Smoke", "Smoke" },
			{ "EdgeOfWorld", "Edge of the World" },
			{ "Impact", "Impact" },
			{ "Cart", "Cart" },
			{ "Tree", "Falling Tree" },
			{ "Self", "Own Hand" },
			{ "Structural", "Collapsing Structure" },
			{ "Turret", "Turret" },
			{ "Boat", "Boat" },
			{ "Stalagtite", "Stalagmite" },
			{ "Catapult", "Catapult" },
			{ "CinderFire", "Cinder Fire" },
			{ "AshlandsOcean", "Ashlands Ocean" },
			{ "AshlandsLava", "Ashlands Lava" },
			{ "Incinerator", "Incinerator" },
			{ "DrawBridge", "Drawbridge" }
		};

		private static readonly Dictionary<string, string> EnvVerbs = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			{ "Undefined", "died of unknown causes" },
			{ "Fall", "fell to their death" },
			{ "Drowning", "drowned" },
			{ "Burning", "burned to death" },
			{ "Freezing", "froze to death" },
			{ "Poisoned", "succumbed to poison" },
			{ "Water", "was lost to the deep" },
			{ "Smoke", "choked on smoke" },
			{ "EdgeOfWorld", "sailed off the edge of the world" },
			{ "Impact", "died on impact" },
			{ "Cart", "was run down by a cart" },
			{ "Tree", "was crushed by a falling tree" },
			{ "Self", "died by their own hand" },
			{ "Structural", "was crushed by a collapsing structure" },
			{ "Turret", "was shot down by a turret" },
			{ "Boat", "was run down by a boat" },
			{ "Stalagtite", "was impaled by a stalagmite" },
			{ "Catapult", "was struck by a catapult" },
			{ "CinderFire", "burned in cinder fire" },
			{ "AshlandsOcean", "was claimed by the Ashlands ocean" },
			{ "AshlandsLava", "sank into the lava" },
			{ "Incinerator", "went into the incinerator" },
			{ "DrawBridge", "was crushed by a drawbridge" }
		};

		public static int HitTypeCount => HitTypes.Length;

		public static string HitTypeName(int hitType)
		{
			if (hitType < 0 || hitType >= HitTypes.Length)
			{
				return HitTypes[0];
			}
			return HitTypes[hitType];
		}

		public static string EnvKey(int hitType)
		{
			return "#" + HitTypeName(hitType);
		}

		public static bool IsEnvironmental(string key)
		{
			if (!string.IsNullOrEmpty(key))
			{
				return key[0] == '#';
			}
			return false;
		}

		public static bool IsPlayer(string key)
		{
			if (!string.IsNullOrEmpty(key))
			{
				return key[0] == '@';
			}
			return false;
		}

		public static string KeyFor(int hitType, string attackerKey, bool attackerIsPlayer)
		{
			string text = Trim(attackerKey);
			if (string.IsNullOrEmpty(text))
			{
				return EnvKey(hitType);
			}
			if (text[0] == '@' || text[0] == '#')
			{
				return text;
			}
			if (!attackerIsPlayer)
			{
				return text;
			}
			return "@" + text;
		}

		public static string ShortLabel(string key, string display)
		{
			if (string.IsNullOrEmpty(key))
			{
				return "Unknown";
			}
			if (IsPlayer(key))
			{
				return key.Substring(1);
			}
			if (!IsEnvironmental(key))
			{
				string text = Trim(display);
				if (!string.IsNullOrEmpty(text))
				{
					return text;
				}
				return Trim(key);
			}
			string text2 = key.Substring(1);
			if (!EnvLabels.TryGetValue(text2, out var value))
			{
				return Prettify(text2);
			}
			return value;
		}

		public static string Category(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return "Unknown";
			}
			if (IsPlayer(key))
			{
				return "Viking";
			}
			if (!IsEnvironmental(key))
			{
				return "Creature";
			}
			switch (key.Substring(1))
			{
			case "EnemyHit":
			case "PlayerHit":
				return "Combat";
			case "Catapult":
			case "Fall":
			case "Cart":
			case "Tree":
			case "Boat":
			case "Self":
			case "Impact":
			case "Turret":
			case "Stalagtite":
			case "Structural":
				return "Mishap";
			case "Drowning":
			case "Freezing":
			case "Poisoned":
			case "CinderFire":
			case "Smoke":
			case "Water":
			case "Burning":
			case "EdgeOfWorld":
			case "AshlandsOcean":
				return "Environment";
			default:
				return "Unknown";
			}
		}

		public static string Sentence(string subject, string key, string display)
		{
			string text = (string.IsNullOrEmpty(subject) ? "?" : subject);
			if (string.IsNullOrEmpty(key))
			{
				return text + " has died";
			}
			if (IsPlayer(key))
			{
				return text + " was slain by " + key.Substring(1);
			}
			if (!IsEnvironmental(key))
			{
				return text + " was killed by " + Article(ShortLabel(key, display));
			}
			string text2 = key.Substring(1);
			if (text2 == "EnemyHit")
			{
				return text + " was killed in battle";
			}
			if (text2 == "PlayerHit")
			{
				return text + " was killed by another Viking";
			}
			if (!EnvVerbs.TryGetValue(text2, out var value))
			{
				return text + " has died";
			}
			return text + " " + value;
		}

		private static string Article(string noun)
		{
			if (string.IsNullOrEmpty(noun))
			{
				return "something";
			}
			if (noun.StartsWith("a ", StringComparison.OrdinalIgnoreCase) || noun.StartsWith("an ", StringComparison.OrdinalIgnoreCase) || noun.StartsWith("the ", StringComparison.OrdinalIgnoreCase))
			{
				return noun;
			}
			char c = char.ToLowerInvariant(noun[0]);
			return ((c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') ? "an " : "a ") + noun;
		}

		private static string Prettify(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return "Unknown";
			}
			StringBuilder stringBuilder = new StringBuilder(name.Length + 8);
			for (int i = 0; i < name.Length; i++)
			{
				if (i > 0 && char.IsUpper(name[i]) && !char.IsUpper(name[i - 1]))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(name[i]);
			}
			return stringBuilder.ToString();
		}

		public static string Trim(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "";
			}
			return Sanitize(value, 64).Trim();
		}

		public static string Sanitize(string value, int maxChars)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "";
			}
			int num = Math.Min(value.Length, maxChars);
			char[] array = new char[num];
			for (int i = 0; i < num; i++)
			{
				char c = value[i];
				array[i] = ((c < ' ' || c == '\u007f') ? ' ' : c);
			}
			return new string(array);
		}
	}
	internal sealed class FchAppearance
	{
		public string Beard = "";

		public string Hair = "";

		public float SkinR = 1f;

		public float SkinG = 1f;

		public float SkinB = 1f;

		public float HairR = 1f;

		public float HairG = 1f;

		public float HairB = 1f;

		public int ModelIndex;
	}
	internal static class FchAppearanceReader
	{
		private sealed class Cursor
		{
			private readonly byte[] _data;

			private int _at;

			public Cursor(byte[] data)
			{
				_data = data;
			}

			private void Need(int bytes)
			{
				if (bytes < 0 || _at + bytes > _data.Length)
				{
					throw new FormatException("past the end");
				}
			}

			public void Skip(int bytes)
			{
				Need(bytes);
				_at += bytes;
			}

			public int Int()
			{
				Need(4);
				int result = BitConverter.ToInt32(_data, _at);
				_at += 4;
				return result;
			}

			public float Float()
			{
				Need(4);
				float result = BitConverter.ToSingle(_data, _at);
				_at += 4;
				return result;
			}

			private int StringLength()
			{
				int num = 0;
				int num2 = 0;
				byte b;
				do
				{
					if (num2 >= 35)
					{
						throw new FormatException("bad string length");
					}
					Need(1);
					b = _data[_at++];
					num |= (b & 0x7F) << num2;
					num2 += 7;
				}
				while ((b & 0x80) != 0);
				if (num < 0 || num > 1024)
				{
					throw new FormatException("string too long");
				}
				return num;
			}

			public string String()
			{
				int num = StringLength();
				Need(num);
				string result = Encoding.UTF8.GetString(_data, _at, num);
				_at += num;
				return result;
			}

			public bool SkipString()
			{
				Skip(StringLength());
				return true;
			}
		}

		public const int PlayerSaveVersion = 29;

		public const int InventorySaveVersion = 106;

		private const int MaxCount = 65536;

		private const int MaxStringBytes = 1024;

		private const int MaxModelIndex = 16;

		private const float MaxColour = 4f;

		public static FchAppearance Read(byte[] data)
		{
			if (data == null || data.Length < 8)
			{
				return null;
			}
			Cursor cursor = new Cursor(data);
			try
			{
				if (cursor.Int() != 29)
				{
					return null;
				}
				cursor.Skip(16);
				if (!cursor.SkipString())
				{
					return null;
				}
				cursor.Skip(4);
				if (!SkipInventory(cursor))
				{
					return null;
				}
				if (!SkipStrings(cursor))
				{
					return null;
				}
				if (!SkipStringIntPairs(cursor))
				{
					return null;
				}
				if (!SkipStrings(cursor))
				{
					return null;
				}
				if (!SkipStrings(cursor))
				{
					return null;
				}
				if (!SkipStrings(cursor))
				{
					return null;
				}
				if (!SkipStrings(cursor))
				{
					return null;
				}
				if (!SkipInts(cursor))
				{
					return null;
				}
				if (!SkipStringPairs(cursor))
				{
					return null;
				}
				FchAppearance fchAppearance = new FchAppearance();
				fchAppearance.Beard = cursor.String();
				fchAppearance.Hair = cursor.String();
				if (fchAppearance.Beard == null || fchAppearance.Hair == null)
				{
					return null;
				}
				fchAppearance.SkinR = cursor.Float();
				fchAppearance.SkinG = cursor.Float();
				fchAppearance.SkinB = cursor.Float();
				fchAppearance.HairR = cursor.Float();
				fchAppearance.HairG = cursor.Float();
				fchAppearance.HairB = cursor.Float();
				fchAppearance.ModelIndex = cursor.Int();
				return Plausible(fchAppearance) ? fchAppearance : null;
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static bool Plausible(FchAppearance look)
		{
			if (look.ModelIndex < 0 || look.ModelIndex > 16)
			{
				return false;
			}
			float[] array = new float[6] { look.SkinR, look.SkinG, look.SkinB, look.HairR, look.HairG, look.HairB };
			foreach (float num in array)
			{
				if (float.IsNaN(num) || num < 0f || num > 4f)
				{
					return false;
				}
			}
			if (NameLike(look.Beard))
			{
				return NameLike(look.Hair);
			}
			return false;
		}

		private static bool NameLike(string value)
		{
			if (value == null)
			{
				return false;
			}
			if (value.Length == 0)
			{
				return true;
			}
			if (value.Length > 64)
			{
				return false;
			}
			foreach (char c in value)
			{
				if (!char.IsLetterOrDigit(c) && c != '_' && c != '-')
				{
					return false;
				}
			}
			return true;
		}

		private static bool SkipInventory(Cursor c)
		{
			if (c.Int() != 106)
			{
				return false;
			}
			int num = c.Int();
			if (num < 0 || num > 65536)
			{
				return false;
			}
			for (int i = 0; i < num; i++)
			{
				if (!c.SkipString())
				{
					return false;
				}
				c.Skip(4);
				c.Skip(4);
				c.Skip(8);
				c.Skip(1);
				c.Skip(4);
				c.Skip(4);
				c.Skip(8);
				if (!c.SkipString())
				{
					return false;
				}
				if (!SkipStringPairs(c))
				{
					return false;
				}
				c.Skip(4);
				c.Skip(1);
			}
			return true;
		}

		private static bool SkipStrings(Cursor c)
		{
			int num = c.Int();
			if (num < 0 || num > 65536)
			{
				return false;
			}
			for (int i = 0; i < num; i++)
			{
				if (!c.SkipString())
				{
					return false;
				}
			}
			return true;
		}

		private static bool SkipInts(Cursor c)
		{
			int num = c.Int();
			if (num < 0 || num > 65536)
			{
				return false;
			}
			c.Skip(num * 4);
			return true;
		}

		private static bool SkipStringPairs(Cursor c)
		{
			int num = c.Int();
			if (num < 0 || num > 65536)
			{
				return false;
			}
			for (int i = 0; i < num; i++)
			{
				if (!c.SkipString())
				{
					return false;
				}
				if (!c.SkipString())
				{
					return false;
				}
			}
			return true;
		}

		private static bool SkipStringIntPairs(Cursor c)
		{
			int num = c.Int();
			if (num < 0 || num > 65536)
			{
				return false;
			}
			for (int i = 0; i < num; i++)
			{
				if (!c.SkipString())
				{
					return false;
				}
				c.Skip(4);
			}
			return true;
		}
	}
	internal static class FchSkillReader
	{
		private const int SkillsSaveVersion = 2;

		private const int MaxSkills = 64;

		private const float MaxLevel = 100f;

		private const float MaxAccumulator = 600f;

		public static Dictionary<int, float> FindSkillBlock(byte[] data, Func<int, bool> isValidSkillId)
		{
			if (data == null || data.Length < 8 || isValidSkillId == null)
			{
				return null;
			}
			Dictionary<int, float> result = null;
			int num = -1;
			for (int i = 0; i + 8 <= data.Length; i++)
			{
				if (BitConverter.ToInt32(data, i) != 2)
				{
					continue;
				}
				int num2 = BitConverter.ToInt32(data, i + 4);
				if (num2 < 1 || num2 > 64)
				{
					continue;
				}
				int num3 = i + 8 + num2 * 12;
				if (num3 > data.Length)
				{
					continue;
				}
				Dictionary<int, float> dictionary = ReadTriples(data, i + 8, num2, isValidSkillId);
				if (dictionary == null)
				{
					continue;
				}
				int num4 = num2 * 2;
				if (num3 + 4 <= data.Length)
				{
					int num5 = BitConverter.ToInt32(data, num3);
					if (num5 >= 0 && num5 <= 65536)
					{
						num4++;
					}
				}
				if (num4 > num)
				{
					num = num4;
					result = dictionary;
				}
			}
			return result;
		}

		private static Dictionary<int, float> ReadTriples(byte[] data, int offset, int count, Func<int, bool> isValidSkillId)
		{
			Dictionary<int, float> dictionary = new Dictionary<int, float>(count);
			for (int i = 0; i < count; i++)
			{
				int num = offset + i * 12;
				int num2 = BitConverter.ToInt32(data, num);
				if (!isValidSkillId(num2))
				{
					return null;
				}
				if (dictionary.ContainsKey(num2))
				{
					return null;
				}
				float num3 = BitConverter.ToSingle(data, num + 4);
				if (float.IsNaN(num3) || num3 < 0f || num3 > 100f)
				{
					return null;
				}
				float num4 = BitConverter.ToSingle(data, num + 8);
				if (float.IsNaN(num4) || num4 < 0f || num4 > 600f)
				{
					return null;
				}
				dictionary[num2] = num3;
			}
			return dictionary;
		}
	}
	internal static class MiniJson
	{
		public static void WriteString(StringBuilder sb, string value)
		{
			if (value == null)
			{
				sb.Append("null");
				return;
			}
			sb.Append('"');
			foreach (char c in value)
			{
				switch (c)
				{
				case '"':
					sb.Append("\\\"");
					continue;
				case '\\':
					sb.Append("\\\\");
					continue;
				case '\b':
					sb.Append("\\b");
					continue;
				case '\f':
					sb.Append("\\f");
					continue;
				case '\n':
					sb.Append("\\n");
					continue;
				case '\r':
					sb.Append("\\r");
					continue;
				case '\t':
					sb.Append("\\t");
					continue;
				}
				if (c < ' ')
				{
					StringBuilder stringBuilder = sb.Append("\\u");
					int num = c;
					stringBuilder.Append(num.ToString("x4", CultureInfo.InvariantCulture));
				}
				else
				{
					sb.Append(c);
				}
			}
			sb.Append('"');
		}

		public static object Parse(string json)
		{
			int i = 0;
			object result = ParseValue(json, ref i);
			SkipWhitespace(json, ref i);
			return result;
		}

		public static Dictionary<string, object> AsObject(object value)
		{
			return value as Dictionary<string, object>;
		}

		public static List<object> AsArray(object value)
		{
			return value as List<object>;
		}

		public static string GetString(Dictionary<string, object> obj, string key, string fallback = null)
		{
			if (obj != null && obj.TryGetValue(key, out var value) && value is string result)
			{
				return result;
			}
			return fallback;
		}

		public static int GetInt(Dictionary<string, object> obj, string key, int fallback = 0)
		{
			if (obj != null && obj.TryGetValue(key, out var value))
			{
				if (value is double a)
				{
					return (int)Math.Round(a);
				}
				if (value is string s && int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
				{
					return result;
				}
			}
			return fallback;
		}

		public static float GetFloat(Dictionary<string, object> obj, string key, float fallback = 0f)
		{
			if (obj != null && obj.TryGetValue(key, out var value))
			{
				if (value is double num)
				{
					return (float)num;
				}
				if (value is string s && float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					return result;
				}
			}
			return fallback;
		}

		public static bool GetBool(Dictionary<string, object> obj, string key, bool fallback = false)
		{
			if (obj != null && obj.TryGetValue(key, out var value))
			{
				if (value is bool)
				{
					return (bool)value;
				}
				if (value is string value2 && bool.TryParse(value2, out var result))
				{
					return result;
				}
				if (value is double value3)
				{
					return Math.Abs(value3) > double.Epsilon;
				}
			}
			return fallback;
		}

		private static object ParseValue(string s, ref int i)
		{
			SkipWhitespace(s, ref i);
			if (i >= s.Length)
			{
				throw new FormatException("Unexpected end of JSON input.");
			}
			switch (s[i])
			{
			case '{':
				return ParseObject(s, ref i);
			case '[':
				return ParseArray(s, ref i);
			case '"':
				return ParseString(s, ref i);
			case 't':
				Expect(s, ref i, "true");
				return true;
			case 'f':
				Expect(s, ref i, "false");
				return false;
			case 'n':
				Expect(s, ref i, "null");
				return null;
			default:
				return ParseNumber(s, ref i);
			}
		}

		private static Dictionary<string, object> ParseObject(string s, ref int i)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.Ordinal);
			i++;
			SkipWhitespace(s, ref i);
			if (i < s.Length && s[i] == '}')
			{
				i++;
				return dictionary;
			}
			while (true)
			{
				SkipWhitespace(s, ref i);
				if (i >= s.Length || s[i] != '"')
				{
					throw new FormatException("Expected an object key at offset " + i + ".");
				}
				string key = ParseString(s, ref i);
				SkipWhitespace(s, ref i);
				if (i >= s.Length || s[i] != ':')
				{
					throw new FormatException("Expected ':' at offset " + i + ".");
				}
				i++;
				dictionary[key] = ParseValue(s, ref i);
				SkipWhitespace(s, ref i);
				if (i >= s.Length)
				{
					throw new FormatException("Unterminated object.");
				}
				if (s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (s[i] == '}')
			{
				i++;
				return dictionary;
			}
			throw new FormatException("Expected ',' or '}' at offset " + i + ".");
		}

		private static List<object> ParseArray(string s, ref int i)
		{
			List<object> list = new List<object>();
			i++;
			SkipWhitespace(s, ref i);
			if (i < s.Length && s[i] == ']')
			{
				i++;
				return list;
			}
			while (true)
			{
				list.Add(ParseValue(s, ref i));
				SkipWhitespace(s, ref i);
				if (i >= s.Length)
				{
					throw new FormatException("Unterminated array.");
				}
				if (s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (s[i] == ']')
			{
				i++;
				return list;
			}
			throw new FormatException("Expected ',' or ']' at offset " + i + ".");
		}

		private static string ParseString(string s, ref int i)
		{
			StringBuilder stringBuilder = new StringBuilder();
			i++;
			while (i < s.Length)
			{
				char c = s[i++];
				switch (c)
				{
				case '"':
					return stringBuilder.ToString();
				default:
					stringBuilder.Append(c);
					continue;
				case '\\':
					break;
				}
				if (i >= s.Length)
				{
					break;
				}
				char c2 = s[i++];
				switch (c2)
				{
				case '"':
					stringBuilder.Append('"');
					break;
				case '\\':
					stringBuilder.Append('\\');
					break;
				case '/':
					stringBuilder.Append('/');
					break;
				case 'b':
					stringBuilder.Append('\b');
					break;
				case 'f':
					stringBuilder.Append('\f');
					break;
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 'r':
					stringBuilder.Append('\r');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case 'u':
					if (i + 4 > s.Length)
					{
						throw new FormatException("Truncated unicode escape.");
					}
					stringBuilder.Append((char)ushort.Parse(s.Substring(i, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture));
					i += 4;
					break;
				default:
					throw new FormatException("Unknown escape character '" + c2 + "'.");
				}
			}
			throw new FormatException("Unterminated string.");
		}

		private static double ParseNumber(string s, ref int i)
		{
			int num = i;
			while (i < s.Length && "+-0123456789.eE".IndexOf(s[i]) >= 0)
			{
				i++;
			}
			string text = s.Substring(num, i - num);
			if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				throw new FormatException("Invalid number '" + text + "'.");
			}
			return result;
		}

		private static void Expect(string s, ref int i, string literal)
		{
			if (i + literal.Length > s.Length || string.CompareOrdinal(s, i, literal, 0, literal.Length) != 0)
			{
				throw new FormatException("Expected '" + literal + "' at offset " + i + ".");
			}
			i += literal.Length;
		}

		private static void SkipWhitespace(string s, ref int i)
		{
			while (i < s.Length && char.IsWhiteSpace(s[i]))
			{
				i++;
			}
		}
	}
	internal static class PatchGuard
	{
		public static Action<string> Log;

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

		private static readonly object Lock = new object();

		public static int DisabledCount
		{
			get
			{
				lock (Lock)
				{
					return Disabled.Count;
				}
			}
		}

		public static bool Run(string patchName, Action body)
		{
			return Run(patchName, body, Log);
		}

		public static bool Run(string patchName, Action body, Action<string> log)
		{
			if (body == null)
			{
				return false;
			}
			string patchName2 = (string.IsNullOrEmpty(patchName) ? "<unnamed patch>" : patchName);
			if (IsDisabled(patchName2))
			{
				return false;
			}
			try
			{
				body();
				return true;
			}
			catch (Exception ex)
			{
				Disable(patchName2);
				Report(log, patchName2, ex);
				return false;
			}
		}

		public static bool IsDisabled(string patchName)
		{
			if (string.IsNullOrEmpty(patchName))
			{
				return false;
			}
			lock (Lock)
			{
				bool value;
				return Disabled.TryGetValue(patchName, out value) && value;
			}
		}

		public static void Reset()
		{
			lock (Lock)
			{
				Disabled.Clear();
			}
		}

		private static void Disable(string patchName)
		{
			lock (Lock)
			{
				Disabled[patchName] = true;
			}
		}

		private static void Report(Action<string> log, string patchName, Exception ex)
		{
			if (log == null)
			{
				return;
			}
			try
			{
				log("PATCH DISABLED: " + patchName + " threw and has been switched off for this session. The game is unaffected; the feature behind it is not running. " + ex);
			}
			catch (Exception)
			{
			}
		}
	}
	internal struct SkillProfile
	{
		public bool HasData;

		public float Combat;

		public float Acro;

		public float Hand;

		public static readonly SkillProfile Unknown;
	}
	internal sealed class PowerWeights
	{
		public float Combat = 0.5f;

		public float Acro = 0.25f;

		public float Hand = 0.25f;

		public static readonly PowerWeights Default = new PowerWeights();

		public static PowerWeights Parse(string value, out string error)
		{
			error = null;
			if (string.IsNullOrEmpty(value))
			{
				return Default;
			}
			string[] array = value.Split(new char[3] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length != 3)
			{
				error = "expected three comma-separated numbers, got \"" + value + "\"";
				return Default;
			}
			PowerWeights powerWeights = new PowerWeights();
			if (!float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out powerWeights.Combat) || !float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out powerWeights.Acro) || !float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out powerWeights.Hand))
			{
				error = "could not parse \"" + value + "\" as three numbers";
				return Default;
			}
			return powerWeights;
		}
	}
	internal static class PowerRating
	{
		public const string DefaultFormat = "{name} — {deaths}   {P} ({C},{A},{H})";

		public const string DefaultLabels = "Combat,Agility,Trades";

		public static float Compute(SkillProfile profile, PowerWeights weights)
		{
			if (!profile.HasData)
			{
				return 0f;
			}
			PowerWeights powerWeights = weights ?? PowerWeights.Default;
			return powerWeights.Combat * profile.Combat + powerWeights.Acro * profile.Acro + powerWeights.Hand * profile.Hand;
		}

		public static int Display(float value)
		{
			return (int)Math.Round(value, MidpointRounding.AwayFromZero);
		}

		private static string Number(float value)
		{
			return Display(value).ToString(CultureInfo.InvariantCulture);
		}

		public static bool HasVisibleRating(SkillProfile profile, PowerWeights weights)
		{
			if (!profile.HasData)
			{
				return false;
			}
			if (Display(Compute(profile, weights)) == 0 && Display(profile.Combat) == 0 && Display(profile.Acro) == 0)
			{
				return Display(profile.Hand) != 0;
			}
			return true;
		}

		public static string StatsBlock(SkillProfile profile, PowerWeights weights)
		{
			if (!HasVisibleRating(profile, weights))
			{
				return "";
			}
			return Number(Compute(profile, weights)) + " (" + Number(profile.Combat) + "," + Number(profile.Acro) + "," + Number(profile.Hand) + ")";
		}

		public static string Line(string format, string name, int deaths, SkillProfile profile, PowerWeights weights, bool showPower)
		{
			string text = (string.IsNullOrEmpty(format) ? "{name} — {deaths}   {P} ({C},{A},{H})" : format);
			if (!showPower || !HasVisibleRating(profile, weights))
			{
				text = TrimAtPower(text);
			}
			return text.Replace("{name}", name ?? "?").Replace("{deaths}", deaths.ToString(CultureInfo.InvariantCulture)).Replace("{P}", Number(Compute(profile, weights)))
				.Replace("{C}", Number(profile.Combat))
				.Replace("{A}", Number(profile.Acro))
				.Replace("{H}", Number(profile.Hand));
		}

		public static string LegendLine(string format, string[] labels, bool showPower)
		{
			string text = (string.IsNullOrEmpty(format) ? "{name} — {deaths}   {P} ({C},{A},{H})" : format);
			if (!showPower)
			{
				text = TrimAtPower(text);
			}
			string[] array = ((labels != null && labels.Length == 3) ? labels : ParseLabels("Combat,Agility,Trades"));
			return text.Replace("{name}", "NAME").Replace("{deaths}", "DEATHS").Replace("{P}", "P")
				.Replace("{C}", array[0])
				.Replace("{A}", array[1])
				.Replace("{H}", array[2]);
		}

		public static string FormulaText(PowerWeights weights, string[] labels)
		{
			PowerWeights powerWeights = weights ?? PowerWeights.Default;
			string[] array = ((labels != null && labels.Length == 3) ? labels : ParseLabels("Combat,Agility,Trades"));
			return "Power Level = " + Percent(powerWeights.Combat) + " " + array[0] + " + " + Percent(powerWeights.Acro) + " " + array[1] + " + " + Percent(powerWeights.Hand) + " " + array[2];
		}

		private static string Percent(float weight)
		{
			float num = weight * 100f;
			return ((Math.Abs(num - (float)Math.Round(num)) < 0.05f) ? ((int)Math.Round(num)).ToString(CultureInfo.InvariantCulture) : num.ToString("0.#", CultureInfo.InvariantCulture)) + "%";
		}

		public static string[] ParseLabels(string value)
		{
			string[] array = (value ?? "").Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length != 3)
			{
				array = "Combat,Agility,Trades".Split(new char[1] { ',' });
			}
			string[] array2 = new string[3];
			for (int i = 0; i < 3; i++)
			{
				array2[i] = array[i].Trim();
			}
			return array2;
		}

		private static string TrimAtPower(string format)
		{
			int num = format.IndexOf("{P}", StringComparison.Ordinal);
			if (num >= 0)
			{
				return format.Substring(0, num).TrimEnd(Array.Empty<char>());
			}
			return format;
		}

		public static float BucketSum(IList<int> bucket, IDictionary<int, float> levels)
		{
			if (bucket == null || bucket.Count == 0)
			{
				return 0f;
			}
			float num = 0f;
			for (int i = 0; i < bucket.Count; i++)
			{
				if (levels != null && levels.TryGetValue(bucket[i], out var value))
				{
					num += value;
				}
			}
			return num;
		}

		public static void AppendLine(StringBuilder sb, string line)
		{
			if (sb.Length > 0)
			{
				sb.Append('\n');
			}
			sb.Append(line);
		}
	}
	internal struct ProfileCause
	{
		public string Key;

		public string Display;

		public int Count;
	}
	internal struct ProfileDeath
	{
		public string Utc;

		public int Day;

		public string Key;

		public string Display;
	}
	internal struct ProfileStat
	{
		public string Key;

		public string Label;

		public byte Group;

		public string Value;

		public float Raw;
	}
	internal struct ProfileSkill
	{
		public int Id;

		public string Label;

		public byte Group;

		public float Level;
	}
	internal struct ProfileEquip
	{
		public string Prefab;

		public byte Slot;

		public byte Quality;
	}
	internal struct ProfileRequest
	{
		public int Protocol;

		public string Name;
	}
	internal sealed class ProfileView
	{
		public int Protocol;

		public string Name = "";

		public bool Found;

		public bool Online;

		public int Deaths;

		public int Attributed;

		public bool HasSkills;

		public float Combat;

		public float Acro;

		public float Hand;

		public float Power;

		public string[] Labels = new string[3] { "Combat", "Agility", "Trades" };

		public string FirstSeenUtc = "";

		public string LastSeenUtc = "";

		public List<ProfileCause> Causes = new List<ProfileCause>();

		public List<ProfileDeath> Recent = new List<ProfileDeath>();

		public List<ProfileStat> Stats = new List<ProfileStat>();

		public List<ProfileCause> Kills = new List<ProfileCause>();

		public List<ProfileSkill> Skills = new List<ProfileSkill>();

		public List<ProfileEquip> Equipment = new List<ProfileEquip>();
	}
	internal static class ProfilePayload
	{
		public const int MaxCauses = 256;

		public const int MaxRecent = 64;

		public const int MaxStats = 128;

		public const int MaxKills = 256;

		public const int MaxSkills = 64;

		public const int MaxEquipment = 24;

		public static ZPackage WriteRequest(string name)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(BoardPayload.Trim(name));
			return val;
		}

		public static bool TryReadRequest(ZPackage pkg, out ProfileRequest request)
		{
			request = default(ProfileRequest);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				request.Protocol = pkg.ReadInt();
				request.Name = BoardPayload.Trim(pkg.ReadString());
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static ZPackage WriteProfile(ProfileView view)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(BoardPayload.Trim(view.Name));
			val.Write(view.Found);
			val.Write(view.Online);
			val.Write(view.Deaths);
			val.Write(view.Attributed);
			val.Write(view.HasSkills);
			val.Write(view.Combat);
			val.Write(view.Acro);
			val.Write(view.Hand);
			val.Write(view.Power);
			string[] array = ((view.Labels != null && view.Labels.Length == 3) ? view.Labels : new string[3] { "Combat", "Agility", "Trades" });
			val.Write(array[0] ?? "");
			val.Write(array[1] ?? "");
			val.Write(array[2] ?? "");
			val.Write(view.FirstSeenUtc ?? "");
			val.Write(view.LastSeenUtc ?? "");
			int num = ((view.Causes != null) ? Math.Min(view.Causes.Count, 256) : 0);
			val.Write(num);
			for (int i = 0; i < num; i++)
			{
				ProfileCause profileCause = view.Causes[i];
				val.Write(DeathCause.Trim(profileCause.Key));
				val.Write(DeathCause.Trim(profileCause.Display));
				val.Write(profileCause.Count);
			}
			int num2 = ((view.Recent != null) ? Math.Min(view.Recent.Count, 64) : 0);
			val.Write(num2);
			for (int j = 0; j < num2; j++)
			{
				ProfileDeath profileDeath = view.Recent[j];
				val.Write(profileDeath.Utc ?? "");
				val.Write(profileDeath.Day);
				val.Write(DeathCause.Trim(profileDeath.Key));
				val.Write(DeathCause.Trim(profileDeath.Display));
			}
			int num3 = ((view.Stats != null) ? Math.Min(view.Stats.Count, 128) : 0);
			val.Write(num3);
			for (int k = 0; k < num3; k++)
			{
				ProfileStat profileStat = view.Stats[k];
				val.Write(DeathCause.Trim(profileStat.Key));
				val.Write(BoardPayload.Trim(profileStat.Label));
				val.Write(profileStat.Group);
				val.Write(BoardPayload.Trim(profileStat.Value));
				val.Write(profileStat.Raw);
			}
			int num4 = ((view.Kills != null) ? Math.Min(view.Kills.Count, 256) : 0);
			val.Write(num4);
			for (int l = 0; l < num4; l++)
			{
				ProfileCause profileCause2 = view.Kills[l];
				val.Write(DeathCause.Trim(profileCause2.Key));
				val.Write(DeathCause.Trim(profileCause2.Display));
				val.Write(profileCause2.Count);
			}
			int num5 = ((view.Skills != null) ? Math.Min(view.Skills.Count, 64) : 0);
			val.Write(num5);
			for (int m = 0; m < num5; m++)
			{
				ProfileSkill profileSkill = view.Skills[m];
				val.Write(profileSkill.Id);
				val.Write(BoardPayload.Trim(profileSkill.Label));
				val.Write(profileSkill.Group);
				val.Write(profileSkill.Level);
			}
			int num6 = ((view.Equipment != null) ? Math.Min(view.Equipment.Count, 24) : 0);
			val.Write(num6);
			for (int n = 0; n < num6; n++)
			{
				ProfileEquip profileEquip = view.Equipment[n];
				val.Write(DeathCause.Trim(profileEquip.Prefab));
				val.Write(profileEquip.Slot);
				val.Write(profileEquip.Quality);
			}
			return val;
		}

		public static bool TryReadProfile(ZPackage pkg, out ProfileView view)
		{
			view = null;
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				ProfileView profileView = new ProfileView();
				profileView.Protocol = pkg.ReadInt();
				profileView.Name = BoardPayload.Trim(pkg.ReadString());
				profileView.Found = pkg.ReadBool();
				profileView.Online = pkg.ReadBool();
				profileView.Deaths = pkg.ReadInt();
				profileView.Attributed = pkg.ReadInt();
				profileView.HasSkills = pkg.ReadBool();
				profileView.Combat = pkg.ReadSingle();
				profileView.Acro = pkg.ReadSingle();
				profileView.Hand = pkg.ReadSingle();
				profileView.Power = pkg.ReadSingle();
				profileView.Labels = new string[3]
				{
					pkg.ReadString() ?? "Combat",
					pkg.ReadString() ?? "Agility",
					pkg.ReadString() ?? "Trades"
				};
				profileView.FirstSeenUtc = pkg.ReadString() ?? "";
				profileView.LastSeenUtc = pkg.ReadString() ?? "";
				int num = pkg.ReadInt();
				if (num < 0 || num > 256)
				{
					return false;
				}
				profileView.Causes = new List<ProfileCause>(num);
				for (int i = 0; i < num; i++)
				{
					ProfileCause item = new ProfileCause
					{
						Key = DeathCause.Trim(pkg.ReadString()),
						Display = DeathCause.Trim(pkg.ReadString()),
						Count = pkg.ReadInt()
					};
					if (item.Count > 0 && !string.IsNullOrEmpty(item.Key))
					{
						profileView.Causes.Add(item);
					}
				}
				int num2 = pkg.ReadInt();
				if (num2 < 0 || num2 > 64)
				{
					return false;
				}
				profileView.Recent = new List<ProfileDeath>(num2);
				for (int j = 0; j < num2; j++)
				{
					ProfileDeath item2 = new ProfileDeath
					{
						Utc = (pkg.ReadString() ?? ""),
						Day = pkg.ReadInt(),
						Key = DeathCause.Trim(pkg.ReadString()),
						Display = DeathCause.Trim(pkg.ReadString())
					};
					if (!string.IsNullOrEmpty(item2.Key))
					{
						profileView.Recent.Add(item2);
					}
				}
				int num3 = pkg.ReadInt();
				if (num3 < 0 || num3 > 128)
				{
					return false;
				}
				profileView.Stats = new List<ProfileStat>(num3);
				for (int k = 0; k < num3; k++)
				{
					ProfileStat item3 = new ProfileStat
					{
						Key = DeathCause.Trim(pkg.ReadString()),
						Label = BoardPayload.Trim(pkg.ReadString()),
						Group = pkg.ReadByte(),
						Value = BoardPayload.Trim(pkg.ReadString()),
						Raw = pkg.ReadSingle()
					};
					if (!string.IsNullOrEmpty(item3.Key))
					{
						profileView.Stats.Add(item3);
					}
				}
				int num4 = pkg.ReadInt();
				if (num4 < 0 || num4 > 256)
				{
					return false;
				}
				profileView.Kills = new List<ProfileCause>(num4);
				for (int l = 0; l < num4; l++)
				{
					ProfileCause item4 = new ProfileCause
					{
						Key = DeathCause.Trim(pkg.ReadString()),
						Display = DeathCause.Trim(pkg.ReadString()),
						Count = pkg.ReadInt()
					};
					if (item4.Count > 0 && !string.IsNullOrEmpty(item4.Key))
					{
						profileView.Kills.Add(item4);
					}
				}
				int num5 = pkg.ReadInt();
				if (num5 < 0 || num5 > 64)
				{
					return false;
				}
				profileView.Skills = new List<ProfileSkill>(num5);
				for (int m = 0; m < num5; m++)
				{
					ProfileSkill item5 = new ProfileSkill
					{
						Id = pkg.ReadInt(),
						Label = BoardPayload.Trim(pkg.ReadString()),
						Group = pkg.ReadByte(),
						Level = pkg.ReadSingle()
					};
					if (item5.Level > 0f)
					{
						profileView.Skills.Add(item5);
					}
				}
				int num6 = pkg.ReadInt();
				if (num6 < 0 || num6 > 24)
				{
					return false;
				}
				profileView.Equipment = new List<ProfileEquip>(num6);
				for (int n = 0; n < num6; n++)
				{
					ProfileEquip item6 = new ProfileEquip
					{
						Prefab = DeathCause.Trim(pkg.ReadString()),
						Slot = pkg.ReadByte(),
						Quality = pkg.ReadByte()
					};
					if (!string.IsNullOrEmpty(item6.Prefab))
					{
						profileView.Equipment.Add(item6);
					}
				}
				view = profileView;
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}
	}
	internal static class RealmProtocol
	{
		internal struct Hello
		{
			public int Protocol;

			public int ClientBuild;

			public string SteamId;

			public string CharacterName;
		}

		internal struct HelloAck
		{
			public int Protocol;

			public int ServerBuild;

			public bool RealmMode;

			public bool KickUnmodded;

			public bool RemoteBoard;

			public bool AcceptsSkills;

			public bool AcceptsCharUploads;

			public bool AcceptsDeathReports;

			public bool AcceptsStats;

			public string ServerLabel;
		}

		internal struct SkillsReport
		{
			public int Protocol;

			public string SteamId;

			public string CharacterName;

			public Dictionary<int, float> Levels;
		}

		internal struct DeathReport
		{
			public int Protocol;

			public string SteamId;

			public string CharacterName;

			public byte HitType;

			public string AttackerKey;

			public string AttackerDisplay;

			public bool AttackerIsPlayer;
		}

		internal struct StatsReport
		{
			public int Protocol;

			public string SteamId;

			public string CharacterName;

			public int SessionNonce;

			public Dictionary<int, float> Counters;

			public Dictionary<string, float> Mod;

			public Dictionary<string, float> Enemies;

			public List<EquippedItem> Equipment;
		}

		internal struct EquippedItem
		{
			public string Prefab;

			public byte Slot;

			public byte Quality;
		}

		internal enum UploadReason : byte
		{
			Interval,
			Death,
			Logout,
			Inventory
		}

		internal struct CharUpload
		{
			public int Protocol;

			public string SteamId;

			public string CharacterName;

			public int Generation;

			public UploadReason Reason;

			public byte[] Blob;

			public byte[] World;
		}

		internal struct CharOffer
		{
			public int Protocol;

			public string CharacterName;
		}

		internal struct CharPush
		{
			public int Protocol;

			public int Generation;

			public byte[] Blob;

			public byte[] World;
		}

		internal struct CharApplied
		{
			public int Protocol;

			public int Generation;

			public bool Ok;

			public string Note;
		}

		public const byte PacketVersion = 9;

		public const int ProtocolVersion = 9;

		public const string RpcHello = "Deathboard_Hello";

		public const string RpcHelloAck = "Deathboard_HelloAck";

		public const string RpcSkills = "Deathboard_Skills";

		public const string RpcCharOffer = "Deathboard_CharOffer";

		public const string RpcCharPush = "Deathboard_CharPush";

		public const string RpcCharApplied = "Deathboard_CharApplied";

		public const string RpcCharUpload = "Deathboard_CharUpload";

		public const string RpcBoardReq = "Deathboard_BoardReq";

		public const string RpcBoard = "Deathboard_Board";

		public const string RpcDeathReport = "Deathboard_DeathReport";

		public const string RpcProfileReq = "Deathboard_ProfileReq";

		public const string RpcProfile = "Deathboard_Profile";

		public const string RpcStats = "Deathboard_Stats";

		public const int MaxReportedSkills = 128;

		public const int MaxEquipment = 24;

		public const int MaxSnapshotBytes = 4194304;

		public static ZPackage WriteHello(string steamId, string characterName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(51);
			val.Write(steamId ?? "");
			val.Write(characterName ?? "");
			return val;
		}

		public static bool TryReadHello(ZPackage pkg, out Hello hello)
		{
			hello = default(Hello);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				hello.Protocol = pkg.ReadInt();
				hello.ClientBuild = pkg.ReadInt();
				hello.SteamId = pkg.ReadString();
				hello.CharacterName = pkg.ReadString();
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static ZPackage WriteHelloAck(bool realmMode, bool kickUnmodded, bool remoteBoard, bool acceptsSkills, bool acceptsCharUploads, bool acceptsDeathReports, bool acceptsStats, string serverLabel)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(51);
			val.Write(realmMode);
			val.Write(kickUnmodded);
			val.Write(remoteBoard);
			val.Write(acceptsSkills);
			val.Write(acceptsCharUploads);
			val.Write(acceptsDeathReports);
			val.Write(acceptsStats);
			val.Write(serverLabel ?? "");
			return val;
		}

		public static bool TryReadHelloAck(ZPackage pkg, out HelloAck ack)
		{
			ack = default(HelloAck);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				ack.Protocol = pkg.ReadInt();
				ack.ServerBuild = pkg.ReadInt();
				ack.RealmMode = pkg.ReadBool();
				ack.KickUnmodded = pkg.ReadBool();
				ack.RemoteBoard = pkg.ReadBool();
				ack.AcceptsSkills = pkg.ReadBool();
				ack.AcceptsCharUploads = pkg.ReadBool();
				ack.AcceptsDeathReports = pkg.ReadBool();
				ack.AcceptsStats = pkg.ReadBool();
				ack.ServerLabel = pkg.ReadString();
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static ZPackage WriteSkills(string steamId, string characterName, Dictionary<int, float> levels)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(steamId ?? "");
			val.Write(characterName ?? "");
			int num = ((levels != null) ? Math.Min(levels.Count, 128) : 0);
			val.Write(num);
			if (levels != null)
			{
				int num2 = 0;
				foreach (KeyValuePair<int, float> level in levels)
				{
					if (num2 >= num)
					{
						break;
					}
					val.Write(level.Key);
					val.Write(level.Value);
					num2++;
				}
			}
			return val;
		}

		public static bool TryReadSkills(ZPackage pkg, out SkillsReport report)
		{
			report = default(SkillsReport);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				report.Protocol = pkg.ReadInt();
				report.SteamId = pkg.ReadString();
				report.CharacterName = pkg.ReadString();
				int num = pkg.ReadInt();
				if (num < 0 || num > 128)
				{
					return false;
				}
				Dictionary<int, float> dictionary = new Dictionary<int, float>(num);
				for (int i = 0; i < num; i++)
				{
					int key = pkg.ReadInt();
					float num2 = pkg.ReadSingle();
					if (float.IsNaN(num2) || num2 < 0f)
					{
						num2 = 0f;
					}
					if (num2 > 100f)
					{
						num2 = 100f;
					}
					dictionary[key] = num2;
				}
				report.Levels = dictionary;
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static ZPackage WriteDeathReport(string steamId, string characterName, byte hitType, string attackerKey, string attackerDisplay, bool attackerIsPlayer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(steamId ?? "");
			val.Write(characterName ?? "");
			val.Write(hitType);
			val.Write(DeathCause.Trim(attackerKey));
			val.Write(DeathCause.Trim(attackerDisplay));
			val.Write(attackerIsPlayer);
			return val;
		}

		public static bool TryReadDeathReport(ZPackage pkg, out DeathReport report)
		{
			report = default(DeathReport);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				report.Protocol = pkg.ReadInt();
				report.SteamId = pkg.ReadString();
				report.CharacterName = pkg.ReadString();
				byte b = pkg.ReadByte();
				report.HitType = (byte)((b < DeathCause.HitTypeCount) ? b : 0);
				report.AttackerKey = DeathCause.Trim(pkg.ReadString());
				report.AttackerDisplay = DeathCause.Trim(pkg.ReadString());
				report.AttackerIsPlayer = pkg.ReadBool();
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static ZPackage WriteStats(string steamId, string characterName, int sessionNonce, Dictionary<int, float> counters, Dictionary<string, float> mod, Dictionary<string, float> enemies, List<EquippedItem> equipment)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(steamId ?? "");
			val.Write(characterName ?? "");
			val.Write(sessionNonce);
			WriteIntMap(val, counters, 256);
			WriteStringMap(val, mod, 64);
			WriteStringMap(val, enemies, 512);
			int num = ((equipment != null) ? Math.Min(equipment.Count, 24) : 0);
			val.Write(num);
			for (int i = 0; i < num; i++)
			{
				EquippedItem equippedItem = equipment[i];
				val.Write(DeathCause.Trim(equippedItem.Prefab));
				val.Write(equippedItem.Slot);
				val.Write(equippedItem.Quality);
			}
			return val;
		}

		private static void WriteIntMap(ZPackage pkg, Dictionary<int, float> map, int cap)
		{
			int num = ((map != null) ? Math.Min(map.Count, cap) : 0);
			pkg.Write(num);
			if (map == null)
			{
				return;
			}
			int num2 = 0;
			foreach (KeyValuePair<int, float> item in map)
			{
				if (num2 >= num)
				{
					break;
				}
				pkg.Write(item.Key);
				pkg.Write(item.Value);
				num2++;
			}
		}

		private static void WriteStringMap(ZPackage pkg, Dictionary<string, float> map, int cap)
		{
			int num = ((map != null) ? Math.Min(map.Count, cap) : 0);
			pkg.Write(num);
			if (map == null)
			{
				return;
			}
			int num2 = 0;
			foreach (KeyValuePair<string, float> item in map)
			{
				if (num2 >= num)
				{
					break;
				}
				pkg.Write(DeathCause.Trim(item.Key));
				pkg.Write(item.Value);
				num2++;
			}
		}

		public static bool TryReadStats(ZPackage pkg, out StatsReport report)
		{
			report = default(StatsReport);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				report.Protocol = pkg.ReadInt();
				report.SteamId = pkg.ReadString();
				report.CharacterName = pkg.ReadString();
				report.SessionNonce = pkg.ReadInt();
				int num = pkg.ReadInt();
				if (num < 0 || num > 256)
				{
					return false;
				}
				report.Counters = new Dictionary<int, float>(num);
				for (int i = 0; i < num; i++)
				{
					int key = pkg.ReadInt();
					float value = pkg.ReadSingle();
					if (Sane(value))
					{
						report.Counters[key] = value;
					}
				}
				if (!TryReadStringMap(pkg, 64, out report.Mod))
				{
					return false;
				}
				if (!TryReadStringMap(pkg, 512, out report.Enemies))
				{
					return false;
				}
				int num2 = pkg.ReadInt();
				if (num2 < 0 || num2 > 24)
				{
					return false;
				}
				report.Equipment = new List<EquippedItem>(num2);
				for (int j = 0; j < num2; j++)
				{
					EquippedItem item = new EquippedItem
					{
						Prefab = DeathCause.Trim(pkg.ReadString()),
						Slot = pkg.ReadByte(),
						Quality = pkg.ReadByte()
					};
					if (!string.IsNullOrEmpty(item.Prefab))
					{
						report.Equipment.Add(item);
					}
				}
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static bool TryReadStringMap(ZPackage pkg, int cap, out Dictionary<string, float> map)
		{
			map = null;
			int num = pkg.ReadInt();
			if (num < 0 || num > cap)
			{
				return false;
			}
			map = new Dictionary<string, float>(num, StringComparer.Ordinal);
			for (int i = 0; i < num; i++)
			{
				string text = DeathCause.Trim(pkg.ReadString());
				float value = pkg.ReadSingle();
				if (!string.IsNullOrEmpty(text) && Sane(value))
				{
					map[text] = value;
				}
			}
			return true;
		}

		private static bool Sane(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return value >= 0f;
			}
			return false;
		}

		public static ZPackage WriteCharUpload(string steamId, string characterName, int generation, UploadReason reason, byte[] blob, byte[] world)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(steamId ?? "");
			val.Write(characterName ?? "");
			val.Write(generation);
			val.Write((byte)reason);
			val.Write(blob ?? new byte[0]);
			val.Write(world ?? new byte[0]);
			return val;
		}

		public static bool TryReadCharUpload(ZPackage pkg, out CharUpload upload)
		{
			upload = default(CharUpload);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				upload.Protocol = pkg.ReadInt();
				upload.SteamId = pkg.ReadString();
				upload.CharacterName = pkg.ReadString();
				upload.Generation = pkg.ReadInt();
				byte b = pkg.ReadByte();
				upload.Reason = (UploadReason)((b <= 3) ? b : 0);
				byte[] array = pkg.ReadByteArray();
				if (array == null || array.Length == 0)
				{
					return false;
				}
				if (array.Length > 4194304)
				{
					return false;
				}
				upload.Blob = array;
				byte[] array2 = pkg.ReadByteArray();
				upload.World = ((array2 != null && array2.Length <= 1048576) ? array2 : null);
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static ZPackage WriteCharOffer(string characterName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(characterName ?? "");
			return val;
		}

		public static bool TryReadCharOffer(ZPackage pkg, out CharOffer offer)
		{
			offer = default(CharOffer);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				offer.Protocol = pkg.ReadInt();
				offer.CharacterName = pkg.ReadString();
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static ZPackage WriteCharPush(int generation, byte[] blob, byte[] world)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(generation);
			val.Write(blob ?? new byte[0]);
			val.Write(world ?? new byte[0]);
			return val;
		}

		public static bool TryReadCharPush(ZPackage pkg, out CharPush push)
		{
			push = default(CharPush);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				push.Protocol = pkg.ReadInt();
				push.Generation = pkg.ReadInt();
				byte[] array = pkg.ReadByteArray();
				if (array == null || array.Length == 0)
				{
					return false;
				}
				if (array.Length > 4194304)
				{
					return false;
				}
				push.Blob = array;
				byte[] array2 = pkg.ReadByteArray();
				push.World = ((array2 != null && array2.Length <= 1048576) ? array2 : null);
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static ZPackage WriteCharApplied(int generation, bool ok, string note)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)9);
			val.Write(9);
			val.Write(generation);
			val.Write(ok);
			val.Write(note ?? "");
			return val;
		}

		public static bool TryReadCharApplied(ZPackage pkg, out CharApplied applied)
		{
			applied = default(CharApplied);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				pkg.SetPos(0);
				if (pkg.ReadByte() != 9)
				{
					return false;
				}
				applied.Protocol = pkg.ReadInt();
				applied.Generation = pkg.ReadInt();
				applied.Ok = pkg.ReadBool();
				applied.Note = pkg.ReadString();
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}
	}
	internal static class RealmWorldData
	{
		private const byte Version = 1;

		public const int MaxBytes = 1048576;

		public static byte[] Capture(PlayerProfile profile)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (profile == null)
			{
				return null;
			}
			try
			{
				profile.SaveLogoutPoint();
				if ((Object)(object)Minimap.instance != (Object)null)
				{
					Minimap.instance.SaveMapData();
				}
			}
			catch (Exception)
			{
			}
			try
			{
				ZPackage val = new ZPackage();
				val.Write((byte)1);
				WritePoint(val, profile.HaveLogoutPoint(), profile.HaveLogoutPoint() ? profile.GetLogoutPoint() : Vector3.zero);
				WritePoint(val, profile.HaveDeathPoint(), profile.HaveDeathPoint() ? profile.GetDeathPoint() : Vector3.zero);
				WritePoint(val, profile.HaveCustomSpawnPoint(), profile.HaveCustomSpawnPoint() ? profile.GetCustomSpawnPoint() : Vector3.zero);
				val.Write(profile.GetHomePoint());
				byte[] mapData = profile.GetMapData();
				val.Write(mapData ?? new byte[0]);
				byte[] array = val.GetArray();
				return (array != null && array.Length <= 1048576) ? array : null;
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static bool Apply(PlayerProfile profile, byte[] blob, out byte[] mapData)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			mapData = null;
			if (profile == null || blob == null || blob.Length == 0)
			{
				return false;
			}
			try
			{
				ZPackage val = new ZPackage(blob);
				if (val.ReadByte() != 1)
				{
					return false;
				}
				if (ReadPoint(val, out var point))
				{
					profile.SetLogoutPoint(point);
				}
				else
				{
					profile.ClearLoguoutPoint();
				}
				if (ReadPoint(val, out var point2))
				{
					profile.SetDeathPoint(point2);
				}
				if (ReadPoint(val, out var point3))
				{
					profile.SetCustomSpawnPoint(point3);
				}
				else
				{
					profile.ClearCustomSpawnPoint();
				}
				profile.SetHomePoint(val.ReadVector3());
				byte[] array = val.ReadByteArray();
				if (array != null && array.Length != 0)
				{
					profile.SetMapData(array);
					mapData = array;
				}
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static void WritePoint(ZPackage pkg, bool have, Vector3 point)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			pkg.Write(have);
			pkg.Write(point);
		}

		private static bool ReadPoint(ZPackage pkg, out Vector3 point)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			bool result = pkg.ReadBool();
			point = pkg.ReadVector3();
			return result;
		}
	}
	internal static class SkillBuckets
	{
		public static readonly SkillType[] Combat;

		public static readonly SkillType[] Athletics;

		public static readonly SkillType[] Hand;

		public static readonly int[] CombatIds;

		public static readonly int[] AthleticsIds;

		public static readonly int[] HandIds;

		private static int[] ToIds(SkillType[] types)
		{
			int[] array = new int[types.Length];
			for (int i = 0; i < types.Length; i++)
			{
				array[i] = (int)types[i];
			}
			return array;
		}

		public static SkillProfile Profile(IDictionary<int, float> levels)
		{
			if (levels == null)
			{
				return SkillProfile.Unknown;
			}
			return new SkillProfile
			{
				HasData = true,
				Combat = PowerRating.BucketSum(CombatIds, levels),
				Acro = PowerRating.BucketSum(AthleticsIds, levels),
				Hand = PowerRating.BucketSum(HandIds, levels)
			};
		}

		public static bool IsRealSkillId(int id)
		{
			if (id == 0 || id == 999)
			{
				return false;
			}
			return Enum.IsDefined(typeof(SkillType), id);
		}

		static SkillBuckets()
		{
			SkillType[] array = new SkillType[13];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			Combat = (SkillType[])(object)array;
			SkillType[] array2 = new SkillType[5];
			RuntimeHelpers.InitializeArray(array2, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			Athletics = (SkillType[])(object)array2;
			SkillType[] array3 = new SkillType[6];
			RuntimeHelpers.InitializeArray(array3, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			Hand = (SkillType[])(object)array3;
			CombatIds = ToIds(Combat);
			AthleticsIds = ToIds(Athletics);
			HandIds = ToIds(Hand);
		}
	}
	internal enum StatGroup
	{
		Combat,
		Craft,
		Land,
		Travel,
		Death
	}
	internal sealed class StatDef
	{
		public string Key = "";

		public int Ordinal = -1;

		public string Label = "";

		public StatGroup Group;

		public bool IsDistance;
	}
	internal static class StatCatalog
	{
		public const string ModBlocks = "blocks";

		public const string ModParries = "parries";

		public const int MaxCounters = 256;

		public const int MaxModCounters = 64;

		public const int MaxEnemyRows = 512;

		private static readonly List<StatDef> All = new List<StatDef>
		{
			new StatDef
			{
				Key = "kills",
				Ordinal = 6,
				Label = "Monsters Slain",
				Group = StatGroup.Combat
			},
			new StatDef
			{
				Key = "bosskills",
				Ordinal = 85,
				Label = "Bosses Felled",
				Group = StatGroup.Combat
			},
			new StatDef
			{
				Key = "blocks",
				Ordinal = -1,
				Label = "Blocks",
				Group = StatGroup.Combat
			},
			new StatDef
			{
				Key = "parries",
				Ordinal = -1,
				Label = "Parries",
				Group = StatGroup.Combat
			},
			new StatDef
			{
				Key = "crafts",
				Ordinal = 13,
				Label = "Items Crafted",
				Group = StatGroup.Craft
			},
			new StatDef
			{
				Key = "builds",
				Ordinal = 2,
				Label = "Pieces Built",
				Group = StatGroup.Craft
			},
			new StatDef
			{
				Key = "trees",
				Ordinal = 28,
				Label = "Trees Felled",
				Group = StatGroup.Land
			},
			new StatDef
			{
				Key = "mines",
				Ordinal = 38,
				Label = "Ore Mined",
				Group = StatGroup.Land
			},
			new StatDef
			{
				Key = "dist",
				Ordinal = 16,
				Label = "Distance Travelled",
				Group = StatGroup.Travel,
				IsDistance = true
			},
			new StatDef
			{
				Key = "sail",
				Ordinal = 19,
				Label = "Distance Sailed",
				Group = StatGroup.Travel,
				IsDistance = true
			}
		};

		private static readonly string[] DeathByLabels = new string[25]
		{
			"Unknown", "Enemies", "Vikings", "Falling", "Drowning", "Fire", "Cold", "Poison", "Smoke", "Deep Water",
			"Edge of the World", "Impact", "Carts", "Falling Trees", "Own Hand", "Structures", "Turrets", "Boats", "Stalagmites", "Catapults",
			"Cinder Fire", "The Ashlands Ocean", "Incinerators", "Drawbridges", "Ashlands Lava"
		};

		private static readonly int[] DeathByOrdinals = new int[25]
		{
			55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
			65, 66, 67, 68, 69, 70, 71, 72, 73, 105,
			106, 107, 108, 203, 204
		};

		private static readonly Dictionary<string, StatDef> ByKey = BuildIndex();

		private static readonly Dictionary<int, StatDef> ByOrdinal = BuildOrdinalIndex();

		public const int GroupCount = 5;

		private static Dictionary<string, StatDef> BuildIndex()
		{
			Dictionary<string, StatDef> dictionary = new Dictionary<string, StatDef>(StringComparer.Ordinal);
			foreach (StatDef item in Definitions())
			{
				dictionary[item.Key] = item;
			}
			return dictionary;
		}

		private static Dictionary<int, StatDef> BuildOrdinalIndex()
		{
			Dictionary<int, StatDef> dictionary = new Dictionary<int, StatDef>();
			foreach (StatDef item in Definitions())
			{
				if (item.Ordinal >= 0)
				{
					dictionary[item.Ordinal] = item;
				}
			}
			return dictionary;
		}

		public static IEnumerable<StatDef> Definitions()
		{
			for (int i = 0; i < All.Count; i++)
			{
				yield return All[i];
			}
			for (int i = 0; i < DeathByLabels.Length; i++)
			{
				yield return new StatDef
				{
					Key = "death." + i,
					Ordinal = DeathByOrdinals[i],
					Label = DeathByLabels[i],
					Group = StatGroup.Death
				};
			}
		}

		public static List<StatDef> InGroup(StatGroup group)
		{
			List<StatDef> list = new List<StatDef>();
			foreach (StatDef item in Definitions())
			{
				if (item.Group == group)
				{
					list.Add(item);
				}
			}
			return list;
		}

		public static bool TryByKey(string key, out StatDef def)
		{
			def = null;
			if (!string.IsNullOrEmpty(key))
			{
				return ByKey.TryGetValue(key, out def);
			}
			return false;
		}

		public static bool TryByOrdinal(int ordinal, out StatDef def)
		{
			return ByOrdinal.TryGetValue(ordinal, out def);
		}

		public static string GroupLabel(StatGroup group)
		{
			return group switch
			{
				StatGroup.Combat => "COMBAT", 
				StatGroup.Craft => "CRAFT", 
				StatGroup.Land => "LAND", 
				StatGroup.Travel => "TRAVEL", 
				StatGroup.Death => "CAUSE OF DEATH", 
				_ => "OTHER", 
			};
		}

		public static string Format(StatDef def, float value)
		{
			if (def != null && def.IsDistance)
			{
				if (value >= 1000f)
				{
					return (value / 1000f).ToString("0.0", CultureInfo.InvariantCulture) + " km";
				}
				return ((int)value).ToString(CultureInfo.InvariantCulture) + " m";
			}
			return Thousands((int)value);
		}

		public static string Thousands(int value)
		{
			return value.ToString("#,0", CultureInfo.InvariantCulture);
		}

		public static string PrettyToken(string token)
		{
			if (string.IsNullOrEmpty(token))
			{
				return "";
			}
			string text = token;
			if (text[0] == '$')
			{
				text = text.Substring(1);
			}
			string[] array = new string[4] { "enemy_", "npc_", "item_", "character_" };
			for (int i = 0; i < array.Length; i++)
			{
				if (text.StartsWith(array[i], StringComparison.OrdinalIgnoreCase))
				{
					text = text.Substring(array[i].Length);
					break;
				}
			}
			if (text.Length == 0)
			{
				return token;
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length + 4);
			bool flag = true;
			foreach (char c in text)
			{
				if (c == '_' || c == ' ')
				{
					stringBuilder.Append(' ');
					flag = true;
				}
				else
				{
					stringBuilder.Append(flag ? char.ToUpperInvariant(c) : c);
					flag = false;
				}
			}
			return stringBuilder.ToString();
		}
	}
}
namespace Deathboard.Client
{
	internal static class BlockCounter
	{
		private const float PerfectBlockWindow = 0.25f;

		private const float NotBlocking = -1f;

		private static readonly FieldInfo BlockTimerField = AccessTools.Field(typeof(Humanoid), "m_blockTimer");

		public static float Blocks;

		public static float Parries;

		public static void Reset()
		{
			Blocks = 0f;
			Parries = 0f;
		}

		internal static void Note(Humanoid blocker)
		{
			if (BlockTimerField == null || (Object)(object)blocker == (Object)null || (Object)(object)blocker != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			float num;
			try
			{
				num = (float)BlockTimerField.GetValue(blocker);
			}
			catch (Exception)
			{
				return;
			}
			if (!(num <= -1f))
			{
				Blocks += 1f;
				if (num < 0.25f)
				{
					Parries += 1f;
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class BlockCounterPatch
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(Humanoid), "BlockAttack", new Type[2]
			{
				typeof(HitData),
				typeof(Character)
			}, (Type[])null);
		}

		private static void Prefix(Humanoid __instance)
		{
			try
			{
				BlockCounter.Note(__instance);
			}
			catch (Exception)
			{
			}
		}
	}
	internal static class BossIcons
	{
		private static readonly Dictionary<string, string[]> Candidates = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"defeated_eikthyr",
				new string[1] { "TrophyEikthyr" }
			},
			{
				"defeated_gdking",
				new string[3] { "TrophyTheElder", "TrophyGDKing", "TrophyElder" }
			},
			{
				"defeated_bonemass",
				new string[1] { "TrophyBonemass" }
			},
			{
				"defeated_dragon",
				new string[3] { "TrophyDragonQueen", "TrophyModer", "TrophyDragon" }
			},
			{
				"defeated_goblinking",
				new string[2] { "TrophyGoblinKing", "TrophyYagluth" }
			},
			{
				"defeated_queen",
				new string[2] { "TrophySeekerQueen", "TrophyQueen" }
			},
			{
				"defeated_fader",
				new string[1] { "TrophyFader" }
			}
		};

		private static readonly Dictionary<string, string> Stems = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "defeated_eikthyr", "eikthyr" },
			{ "defeated_gdking", "elder" },
			{ "defeated_bonemass", "bonemass" },
			{ "defeated_dragon", "dragon" },
			{ "defeated_goblinking", "goblin" },
			{ "defeated_queen", "seeker" },
			{ "defeated_fader", "fader" }
		};

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

		private static ObjectDB _resolvedAgainst;

		private static readonly List<string> Resolved = new List<string>();

		private static readonly List<string> Missing = new List<string>();

		private static bool _reported;

		public static Sprite For(string globalKey)
		{
			if (string.IsNullOrEmpty(globalKey))
			{
				return null;
			}
			try
			{
				ObjectDB instance = ObjectDB.instance;
				if ((Object)(object)instance == (Object)null || instance.m_items == null)
				{
					return null;
				}
				if (instance != _resolvedAgainst)
				{
					_resolvedAgainst = instance;
					Cache.Clear();
					Resolved.Clear();
					Missing.Clear();
					_reported = false;
				}
				if (Cache.TryGetValue(globalKey, out var value))
				{
					return value;
				}
				Sprite val = Resolve(instance, globalKey);
				Cache[globalKey] = val;
				(((Object)(object)val != (Object)null) ? Resolved : Missing).Add(globalKey);
				return val;
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static string ReportOnce()
		{
			if (_reported || (Resolved.Count == 0 && Missing.Count == 0))
			{
				return null;
			}
			_reported = true;
			return "Boss icons resolved " + Resolved.Count + "/" + (Resolved.Count + Missing.Count) + ((Missing.Count > 0) ? (". No trophy prefab found for: " + string.Join(", ", Missing.ToArray()) + " - those bosses draw without an icon. Add the right prefab name to BossIcons.Candidates.") : ".");
		}

		private static Sprite Resolve(ObjectDB db, string globalKey)
		{
			if (Candidates.TryGetValue(globalKey, out var value))
			{
				for (int i = 0; i < value.Length; i++)
				{
					Sprite val = IconOf(db.GetItemPrefab(value[i]));
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
			}
			if (!Stems.TryGetValue(globalKey, out var value2))
			{
				return null;
			}
			for (int j = 0; j < db.m_items.Count; j++)
			{
				GameObject val2 = db.m_items[j];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				string name = ((Object)val2).name;
				if (!string.IsNullOrEmpty(name) && name.IndexOf("Trophy", StringComparison.OrdinalIgnoreCase) >= 0 && name.IndexOf(value2, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					Sprite val3 = IconOf(val2);
					if ((Object)(object)val3 != (Object)null)
					{
						return val3;
					}
				}
			}
			return null;
		}

		private static Sprite IconOf(GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null || component.m_itemData == null || component.m_itemData.m_shared == null)
			{
				return null;
			}
			Sprite[] icons = component.m_itemData.m_shared.m_icons;
			if (icons == null || icons.Length == 0)
			{
				return null;
			}
			return icons[0];
		}

		public static void Draw(Rect rect, Sprite sprite, Color tint)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)sprite == (Object)null) && !((Object)(object)sprite.texture == (Object)null))
			{
				Rect textureRect = sprite.textureRect;
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((Rect)(ref textureRect)).x / (float)((Texture)sprite.texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)sprite.texture).height, ((Rect)(ref textureRect)).width / (float)((Texture)sprite.texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)sprite.texture).height);
				Color color = GUI.color;
				GUI.color = tint;
				GUI.DrawTextureWithTexCoords(rect, (Texture)(object)sprite.texture, val, true);
				GUI.color = color;
			}
		}
	}
	internal sealed class ClientConfig
	{
		public readonly ConfigEntry<bool> Enabled;

		public readonly ConfigEntry<float> HandshakeTimeoutSeconds;

		public readonly ConfigEntry<KeyCode> LadderKey;

		public readonly ConfigEntry<float> LadderRefreshSeconds;

		public readonly ConfigEntry<bool> LadderBlocksInput;

		public readonly ConfigEntry<float> LadderScale;

		public ClientConfig(ConfigFile config)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			Enabled = config.Bind<bool>("General", "Enabled", true, "Master switch. False makes this plugin do nothing at all, on every server.");
			HandshakeTimeoutSeconds = config.Bind<float>("General", "HandshakeTimeoutSeconds", 8f, new ConfigDescription("How long to wait for a realm server to answer before deciding this is an ordinary server and going inert for the session.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 60f), Array.Empty<object>()));
			LadderKey = config.Bind<KeyCode>("Ladder", "Key", (KeyCode)288, "Key that opens and closes the leaderboard window. Vanilla Valheim binds F5 (console), F2, F9, F11, Ctrl+F1 and Ctrl+F3, and leaves the rest alone - but mods do claim F-keys, PlantEasily takes F6/F8/F10 for one. F7 is clear of all of those. Change it if something on your setup wants F7.");
			LadderRefreshSeconds = config.Bind<float>("Ladder", "RefreshSeconds", 5f, new ConfigDescription("How often the open window asks the server for a fresh board. The server rate-limits requests to one per second per player regardless of what is set here.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 60f), Array.Empty<object>()));
			LadderBlocksInput = config.Bind<bool>("Ladder", "BlocksInput", true, "True stops your character moving, looking and attacking while the window is open, the same way the inventory does. False leaves the game fully playable behind the window, but then the mouse is shared between looking around and clicking the tabs.");
			LadderScale = config.Bind<float>("Ladder", "Scale", 1f, new ConfigDescription("Size multiplier for the window. The window already scales with screen height; this is for taste.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2.5f), Array.Empty<object>()));
		}
	}
	[HarmonyPatch]
	internal static class ClientPatches
	{
		private const int LeaseFrames = 1;

		private static int _openOnFrame = -1;

		private static int _blockedOnFrame = -1;

		private static bool WindowOpen
		{
			get
			{
				if (_openOnFrame >= 0)
				{
					return Time.frameCount - _openOnFrame <= 1;
				}
				return false;
			}
		}

		private static bool InputBlocked
		{
			get
			{
				if (_blockedOnFrame >= 0)
				{
					return Time.frameCount - _blockedOnFrame <= 1;
				}
				return false;
			}
		}

		public static void RenewOpen()
		{
			_openOnFrame = Time.frameCount;
		}

		public static void RenewInputBlock()
		{
			_blockedOnFrame = Time.frameCount;
		}

		public static void Release()
		{
			_openOnFrame = -1;
			_blockedOnFrame = -1;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerController), "TakeInput")]
		private static void PlayerControllerTakeInput(ref bool __result)
		{
			if (InputBlocked)
			{
				__result = false;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "TakeInput")]
		private static void PlayerTakeInput(Player __instance, ref bool __result)
		{
			if (InputBlocked && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				__result = false;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameCamera), "UpdateMouseCapture")]
		private static void GameCameraUpdateMouseCapture()
		{
			if (WindowOpen)
			{
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
		}
	}
	[BepInPlugin("com.deathboard.valheim.client", "The Great Hall", "3.0.0")]
	public sealed class DeathboardClientPlugin : BaseUnityPlugin
	{
		private ClientConfig _config;

		private RealmSession _session;

		private LadderClient _ladderClient;

		private LadderGui _ladder;

		private SkillReporter _skills;

		private SnapshotUploader _uploader;

		private RealmProfile _realmProfile;

		private RealmConsentGui _consent;

		private DeathReporter _deaths;

		private StatsReporter _stats;

		private ProfileGui _profile;

		private Harmony _harmony;

		private Harmony _logoutHarmony;

		private Harmony _spawnGateHarmony;

		private Harmony _deathHarmony;

		private Harmony _blockHarmony;

		internal static DeathboardClientPlugin Instance { get; private set; }

		internal static bool IsHeadless => (int)SystemInfo.graphicsDeviceType == 4;

		internal RealmSession Session => _session;

		internal SnapshotUploader Uploader => _uploader;

		internal RealmProfile RealmProfile => _realmProfile;

		internal DeathReporter Deaths => _deaths;

		private void Awake()
		{
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Expected O, but got Unknown
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Expected O, but got Unknown
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			Instance = this;
			LogInfo("===== " + BuildInfo.ClientBanner + " starting =====");
			if (IsHeadless)
			{
				LogInfo("Headless build detected; standing down. The server half of Deathboard runs from Deathboard.dll.");
				return;
			}
			_config = new ClientConfig(((BaseUnityPlugin)this).Config);
			if (!_config.Enabled.Value)
			{
				LogInfo("Disabled by config; doing nothing.");
				return;
			}
			_session = new RealmSession(() => _config.HandshakeTimeoutSeconds.Value, LogInfo, LogWarn);
			_ladderClient = new LadderClient(_session, () => _config.LadderRefreshSeconds.Value, LogWarn);
			_ladder = new LadderGui(_ladderClient, _session, () => _config.LadderKey.Value, () => _config.LadderScale.Value, () => _config.LadderBlocksInput.Value);
			_profile = new ProfileGui(_ladderClient, () => _config.LadderScale.Value);
			_skills = new SkillReporter(_session, LogInfo, LogWarn);
			_deaths = new DeathReporter(_session, LogInfo, LogWarn);
			_stats = new StatsReporter(_session, LogInfo, LogWarn);
			_uploader = new SnapshotUploader(_session, LogInfo, LogWarn);
			_consent = new RealmConsentGui(() => (!((Object)(object)ZNet.instance == (Object)null)) ? ZNet.instance.GetWorldName() : null, LogWarn);
			_realmProfile = new RealmProfile(_session, _consent, LogInfo, LogWarn);
			try
			{
				_harmony = new Harmony("com.deathboard.valheim.client");
				_harmony.PatchAll(typeof(ClientPatches));
			}
			catch (Exception ex)
			{
				LogWarn("Could not install the leaderboard input patches: " + ex.Message + ". The window will still open, but the mouse stays captured.");
				_harmony = null;
			}
			try
			{
				_logoutHarmony = new Harmony("com.deathboard.valheim.client.logout");
				_logoutHarmony.PatchAll(typeof(SnapshotLogoutPatch));
			}
			catch (Exception ex2)
			{
				LogWarn("Could not install the logout upload patch: " + ex2.Message + ". Snapshots still upload on the interval and on death.");
				_logoutHarmony = null;
			}
			try
			{
				_spawnGateHarmony = new Harmony("com.deathboard.valheim.client.spawngate");
				_spawnGateHarmony.PatchAll(typeof(RealmSpawnGate));
			}
			catch (Exception ex3)
			{
				LogWarn("Could not install the spawn gate: " + ex3.Message + ". Realm characters still work; a very slow handshake will disconnect instead of waiting.");
				_spawnGateHarmony = null;
			}
			try
			{
				_deathHarmony = new Harmony("com.deathboard.valheim.client.death");
				_deathHarmony.PatchAll(typeof(DeathReportPatch));
			}
			catch (Exception ex4)
			{
				LogWarn("Could not install the death report patch: " + ex4.Message + ". Deaths are still counted by the server; they just will not say what killed you.");
				_deathHarmony = null;
			}
			try
			{
				_blockHarmony = new Harmony("com.deathboard.valheim.client.block");
				_blockHarmony.PatchAll(typeof(BlockCounterPatch));
			}
			catch (Exception ex5)
			{
				LogWarn("Could not install the block counter: " + ex5.Message + ". Every other stat still reports; blocks and parries will read zero.");
				_blockHarmony = null;
			}
			LogInfo("Ready. Will greet each dedicated server once and go inert if it does not answer. Press " + ((object)_config.LadderKey.Value/*cast due to .constrained prefix*/).ToString() + " in game for the leaderboard.");
		}

		private void Update()
		{
			if (_session == null)
			{
				return;
			}
			try
			{
				_session.Tick();
				if (_ladder != null)
				{
					_ladder.Tick();
				}
				if (_skills != null)
				{
					_skills.Tick();
				}
				if (_stats != null)
				{
					_stats.Tick();
				}
				if (_realmProfile != null)
				{
					_realmProfile.Tick();
				}
				if (_uploader != null)
				{
					_uploader.Tick();
				}
			}
			catch (Exception ex)
			{
				LogWarn("Realm tick failed, standing down: " + ex);
				_session = null;
				_ladder = null;
				_ladderClient = null;
				_profile = null;
				_skills = null;
				_deaths = null;
				_stats = null;
				_uploader = null;
				_realmProfile = null;
				if (_consent != null)
				{
					_consent.Prompt = null;
				}
				ClientPatches.Release();
			}
		}

		private void OnGUI()
		{
			if (_consent != null && _consent.Showing)
			{
				try
				{
					_consent.Draw();
				}
				catch (Exception ex)
				{
					LogWarn("Consent window draw failed: " + ex);
				}
			}
			if (_ladder == null)
			{
				return;
			}
			try
			{
				_ladder.Draw();
			}
			catch (Exception ex2)
			{
				LogWarn("Leaderboard draw failed; closing it: " + ex2);
				_ladder.Close();
			}
			if (_profile == null)
			{
				return;
			}
			if (!LadderGui.IsOpen)
			{
				_profile.Close();
				return;
			}
			try
			{
				_profile.Draw();
			}
			catch (Exception ex3)
			{
				LogWarn("Profile window draw failed; closing it: " + ex3);
				_profile.Close();
			}
		}

		private void OnDestroy()
		{
			Instance = null;
			ClientPatches.Release();
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
				_harmony = null;
			}
			if (_logoutHarmony != null)
			{
				_logoutHarmony.UnpatchSelf();
				_logoutHarmony = null;
			}
			if (_spawnGateHarmony != null)
			{
				_spawnGateHarmony.UnpatchSelf();
				_spawnGateHarmony = null;
			}
			if (_deathHarmony != null)
			{
				_deathHarmony.UnpatchSelf();
				_deathHarmony = null;
			}
			if (_blockHarmony != null)
			{
				_blockHarmony.UnpatchSelf();
				_blockHarmony = null;
			}
		}

		private void LogInfo(string message)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)("[Deathboard.Client] " + message));
		}

		private void LogWarn(string message)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("[Deathboard.Client] " + message));
		}
	}
	[HarmonyPatch]
	internal static class DeathReportPatch
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(Player), "OnDeath", (Type[])null, (Type[])null);
		}

		private static void Postfix(Player __instance)
		{
			try
			{
				DeathboardClientPlugin instance = DeathboardClientPlugin.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.Deaths != null && !((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					instance.Deaths.ReportDeath(__instance);
				}
			}
			catch (Exception)
			{
			}
		}
	}
	internal sealed class DeathReporter
	{
		private static readonly FieldInfo LastHitField = AccessTools.Field(typeof(Character), "m_lastHit");

		private const float MinReportIntervalSeconds = 2f;

		private readonly RealmSession _session;

		private readonly Action<string> _logInfo;

		private readonly Action<string> _logWarning;

		private float _lastSentAt = -999f;

		private bool _announced;

		public bool Available
		{
			get
			{
				if (_session != null && _session.Server.AcceptsDeathReports)
				{
					return _session.BoardAvailable;
				}
				return false;
			}
		}

		public DeathReporter(RealmSession session, Action<string> logInfo, Action<string> logWarning)
		{
			_session = session;
			_logInfo = logInfo;
			_logWarning = logWarning;
		}

		public void ReportDeath(Player player)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected I4, but got Unknown
			if (!Available || (Object)(object)player == (Object)null)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup - _lastSentAt < 2f)
			{
				return;
			}
			string text = LocalSteamId();
			string text2 = LocalCharacterName();
			if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text2))
			{
				byte hitType = 0;
				string key = "";
				string display = "";
				bool isPlayer = false;
				HitData val = ReadLastHit(player);
				if (val != null)
				{
					hitType = (byte)(int)val.m_hitType;
					Describe(val, out key, out display, out isPlayer);
				}
				try
				{
					ZRoutedRpc.instance.InvokeRoutedRPC("Deathboard_DeathReport", new object[1] { RealmProtocol.WriteDeathReport(text, text2, hitType, key, display, isPlayer) });
				}
				catch (Exception ex)
				{
					_logWarning("Could not send death report: " + ex.Message);
					return;
				}
				_lastSentAt = realtimeSinceStartup;
				if (!_announced)
				{
					_announced = true;
					_logInfo("Reporting what killed you to the server, so the death line and the Killed By list can say. Your death count itself is measured by the server, not sent by you.");
				}
			}
		}

		private HitData ReadLastHit(Player player)
		{
			if (LastHitField == null)
			{
				return null;
			}
			try
			{
				object? value = LastHitField.GetValue(player);
				return (HitData)((value is HitData) ? value : null);
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static void Describe(HitData hit, out string key, out string display, out bool isPlayer)
		{
			key = "";
			display = "";
			isPlayer = false;
			try
			{
				if (!hit.HaveAttacker())
				{
					return;
				}
				Character attacker = hit.GetAttacker();
				if ((Object)(object)attacker == (Object)null)
				{
					return;
				}
				if (attacker.IsPlayer())
				{
					Player val = (Player)(object)((attacker is Player) ? attacker : null);
					string text = (((Object)(object)val != (Object)null) ? val.GetPlayerName() : attacker.m_name);
					if (!string.IsNullOrEmpty(text))
					{
						isPlayer = true;
						key = text;
						display = text;
					}
				}
				else
				{
					key = PrefabName(attacker);
					display = attacker.GetHoverName();
					if (string.IsNullOrEmpty(key))
					{
						key = display;
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private static string PrefabName(Character character)
		{
			string text = (((Object)(object)((Component)character).gameObject == (Object)null) ? "" : ((Object)((Component)character).gameObject).name);
			if (string.IsNullOrEmpty(text))
			{
				return "";
			}
			int num = text.IndexOf("(Clone)", StringComparison.Ordinal);
			return ((num >= 0) ? text.Substring(0, num) : text).Trim();
		}

		private static string LocalCharacterName()
		{
			Game instance = Game.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			PlayerProfile playerProfile = instance.GetPlayerProfile();
			if (playerProfile != null)
			{
				return playerProfile.GetName();
			}
			return null;
		}

		private static string LocalSteamId()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				PlatformUserID platformUserID = ((IUser)PlatformManager.DistributionPlatform.LocalUser).PlatformUserID;
				return ((PlatformUserID)(ref platformUserID)).IsValid ? platformUserID.m_userID : null;
			}
			catch (Exception)
			{
				return null;
			}
		}
	}
	internal static class GuiTextures
	{
		public static Texture2D Solid(Color color)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing