using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using UnityEngine;
using UnityEngine.Rendering;
using ValheimMoments.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ValheimMoments")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.23.2.0")]
[assembly: AssemblyInformationalVersion("0.23.2+843a04a0cdca497472f3afcc175d172032bdee69")]
[assembly: AssemblyProduct("ValheimMoments")]
[assembly: AssemblyTitle("ValheimMoments")]
[assembly: AssemblyVersion("0.23.2.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ValheimMoments
{
	internal sealed class AcquisitionHighlights
	{
		private sealed class Batch
		{
			internal string Kind;

			internal double Due;

			internal BossKill Event;
		}

		private readonly List<Batch> batches = new List<Batch>();

		internal void Add(string kind, LootItem item, string player, double now)
		{
			if ((!(kind != "c") || !(kind != "w")) && item != null && item.Quantity > 0)
			{
				Batch batch = batches.Find((Batch b) => b.Kind == kind);
				if (batch == null)
				{
					batch = new Batch
					{
						Kind = kind,
						Due = now + 0.25,
						Event = new BossKill
						{
							Acquired = true,
							EnemyKey = ((kind == "c") ? "a treasure chest" : "the world"),
							PlayerName = player,
							Loot = new BossLoot()
						}
					};
					batches.Add(batch);
				}
				batch.Event.Loot.AddEpic(item);
			}
		}

		internal void Poll(double now, string minimum, Func<string, bool> enabled, Action<BossKill> accept)
		{
			int num = 0;
			while (num < batches.Count)
			{
				Batch batch = batches[num];
				if (now < batch.Due)
				{
					num++;
					continue;
				}
				batches.RemoveAt(num);
				if (enabled(batch.Kind) && BossLootFilter.TryRank(minimum, out var rank) && batch.Event.Loot.Items.Exists((LootItem item) => item.Rank >= rank))
				{
					accept(batch.Event);
				}
			}
		}

		internal void Clear()
		{
			batches.Clear();
		}
	}
	internal enum BossNameMode
	{
		KillCredit,
		FinalBlow,
		Both
	}
	internal static class BossAttribution
	{
		private sealed class Context
		{
			internal string Enemy;

			internal string Name;

			internal string Credits;

			internal string EventId;

			internal string Subject;
		}

		private const string RpcName = "ValheimMoments_BossFinalBlow_v1";

		private const string CreditRpcName = "ValheimMoments_KillCredits_v1";

		private const string EventRpcName = "ValheimMoments_KillEvent_v1";

		private static readonly FieldInfo LastHit = typeof(Character).GetField("m_lastHit", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo NetworkView = AccessTools.Field(typeof(Character), "m_nview");

		private const string SubjectRpcName = "ValheimMoments_CinematicSubject_v1";

		private static readonly AttributionInbox subjectInbox = new AttributionInbox(80);

		internal static Func<Character, string> CinematicSubject;

		[ThreadStatic]
		private static Context current;

		private static ZRoutedRpc registered;

		private static readonly AttributionInbox inbox = new AttributionInbox();

		private static readonly AttributionInbox creditInbox = new AttributionInbox(1024);

		private static readonly AttributionInbox eventInbox = new AttributionInbox(32);

		private static readonly Stopwatch clock = Stopwatch.StartNew();

		internal static Action<string> OnDiagnostic;

		internal static string ResolveCredits(Character victim)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				object? obj = NetworkView?.GetValue(victim);
				object? obj2 = ((obj is ZNetView) ? obj : null);
				ZDO val = ((obj2 != null) ? ((ZNetView)obj2).GetZDO() : null);
				if (val == null || (Object)(object)ZNet.instance == (Object)null)
				{
					return null;
				}
				List<string> list = new List<string>();
				string text = ZDOVars.s_attackers.ToString();
				foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
				{
					if (!string.IsNullOrEmpty(player.m_name) && val.GetBool(text + player.m_name, false))
					{
						list.Add(player.m_name);
					}
				}
				return FormatCredits(list);
			}
			catch
			{
				return null;
			}
		}

		internal static string FormatCredits(IEnumerable<string> players)
		{
			List<string> list = new List<string>();
			foreach (string player in players)
			{
				string text = (player ?? "").Replace("\r", " ").Replace("\n", " ").Replace("*", "")
					.Replace("`", "")
					.Trim();
				if (text.Length > 80)
				{
					text = text.Substring(0, char.IsHighSurrogate(text[79]) ? 79 : 80);
				}
				if (text.Length != 0 && !list.Contains(text))
				{
					list.Add(text);
				}
			}
			list.Sort(StringComparer.OrdinalIgnoreCase);
			string text2 = "";
			for (int i = 0; i < list.Count; i++)
			{
				if (text2.Length + list[i].Length + 2 > 980)
				{
					return text2 + " (+" + (list.Count - i) + " more)";
				}
				text2 = text2 + ((text2.Length == 0) ? "" : ", ") + list[i];
			}
			if (text2.Length != 0)
			{
				return text2;
			}
			return null;
		}

		internal static string CreditLabel(string credits, string local)
		{
			if (!string.IsNullOrWhiteSpace(credits))
			{
				return credits;
			}
			return (string.IsNullOrWhiteSpace(local) ? "A player" : local) + " (full list unavailable)";
		}

		internal static string Resolve(HitData hit, out string reason)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if (hit == null)
			{
				reason = "no recorded damage";
				return null;
			}
			if (((ZDOID)(ref hit.m_attacker)).IsNone())
			{
				string text = PeriodicAttribution.Resolve(hit);
				if (text != null)
				{
					reason = "resolved single-source periodic damage";
					return text;
				}
			}
			Character attacker = hit.GetAttacker();
			Player val = (Player)(object)((attacker is Player) ? attacker : null);
			if ((Object)(object)val != (Object)null)
			{
				reason = "resolved player object";
				return val.GetPlayerName();
			}
			if ((Object)(object)attacker == (Object)null && !((ZDOID)(ref hit.m_attacker)).IsNone() && (Object)(object)ZNet.instance != (Object)null)
			{
				foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
				{
					if (player.m_characterID == hit.m_attacker)
					{
						reason = "resolved exact player network ID";
						return player.m_name;
					}
				}
			}
			reason = "hit=" + ((object)Unsafe.As<HitType, HitType>(ref hit.m_hitType)/*cast due to .constrained prefix*/).ToString() + ", " + (((Object)(object)attacker != (Object)null) ? "non-player attacker" : (((ZDOID)(ref hit.m_attacker)).IsNone() ? "no attacker ID" : "attacker ID not in player list"));
			return null;
		}

		internal static void Install(Harmony harmony)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_004d: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Character), "OnDeath", Type.EmptyTypes, (Type[])null), new HarmonyMethod(typeof(BossAttribution), "BeforeDeath", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(BossAttribution), "AfterDeath", (Type[])null), (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Game), "RegisterKill", new Type[6]
			{
				typeof(long),
				typeof(string),
				typeof(int),
				typeof(KillModifiers),
				typeof(int),
				typeof(bool)
			}, (Type[])null), new HarmonyMethod(typeof(BossAttribution), "BeforeSendCredit", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			foreach (ConstructorInfo declaredConstructor in AccessTools.GetDeclaredConstructors(typeof(ZRoutedRpc), (bool?)null))
			{
				harmony.Patch((MethodBase)declaredConstructor, (HarmonyMethod)null, new HarmonyMethod(typeof(BossAttribution), "AfterRouterCreated", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			EnsureRegistered(ZRoutedRpc.instance);
		}

		private static void AfterRouterCreated(ZRoutedRpc __instance)
		{
			EnsureRegistered(__instance);
		}

		private static void EnsureRegistered(ZRoutedRpc router)
		{
			try
			{
				if (router == null || registered == router)
				{
					return;
				}
				router.Register<string, string>("ValheimMoments_BossFinalBlow_v1", (Action<long, string, string>)Receive);
				router.Register<string, string>("ValheimMoments_KillCredits_v1", (Action<long, string, string>)delegate(long sender, string enemy, string names)
				{
					creditInbox.Add(sender, enemy, names, clock.Elapsed.TotalSeconds);
				});
				router.Register<string, string>("ValheimMoments_CinematicSubject_v1", (Action<long, string, string>)delegate(long sender, string enemy, string id)
				{
					subjectInbox.Add(sender, enemy, id, clock.Elapsed.TotalSeconds);
				});
				router.Register<string, string>("ValheimMoments_KillEvent_v1", (Action<long, string, string>)delegate(long sender, string enemy, string id)
				{
					if (HighlightDirector.ValidId(id))
					{
						eventInbox.Add(sender, enemy, id, clock.Elapsed.TotalSeconds);
					}
				});
				registered = router;
				inbox.Clear();
				creditInbox.Clear();
				eventInbox.Clear();
				subjectInbox.Clear();
			}
			catch
			{
			}
		}

		private static void Receive(long sender, string enemy, string name)
		{
			inbox.Add(sender, enemy, name, clock.Elapsed.TotalSeconds);
		}

		private static void BeforeDeath(Character __instance, out Context __state)
		{
			__state = current;
			current = null;
			try
			{
				if (!__instance.IsOwner() || __instance is Player)
				{
					return;
				}
				current = new Context
				{
					Enemy = __instance.m_name,
					EventId = Guid.NewGuid().ToString("N")
				};
				current.Subject = CinematicSubject?.Invoke(__instance);
				object? obj = LastHit?.GetValue(__instance);
				string reason;
				string name = Resolve((HitData)((obj is HitData) ? obj : null), out reason);
				current.Name = name;
				current.Credits = ResolveCredits(__instance);
				try
				{
					OnDiagnostic?.Invoke(reason);
				}
				catch
				{
				}
			}
			catch
			{
			}
		}

		private static void AfterDeath(Context __state)
		{
			current = __state;
		}

		private static void BeforeSendCredit(long playerPeerID, string enemyName, int bossNumber)
		{
			try
			{
				if (current != null && !(current.Enemy != enemyName))
				{
					try
					{
						ZRoutedRpc.instance.InvokeRoutedRPC(playerPeerID, "ValheimMoments_KillEvent_v1", new object[2] { enemyName, current.EventId });
					}
					catch
					{
					}
					if (current.Subject != null)
					{
						ZRoutedRpc.instance.InvokeRoutedRPC(playerPeerID, "ValheimMoments_CinematicSubject_v1", new object[2] { enemyName, current.Subject });
					}
					ZRoutedRpc.instance.InvokeRoutedRPC(playerPeerID, "ValheimMoments_BossFinalBlow_v1", new object[2]
					{
						enemyName,
						current.Name ?? ""
					});
					ZRoutedRpc.instance.InvokeRoutedRPC(playerPeerID, "ValheimMoments_KillCredits_v1", new object[2]
					{
						enemyName,
						current.Credits ?? ""
					});
				}
			}
			catch
			{
			}
		}

		internal static string Take(long sender, string enemy)
		{
			if (sender == 0L && current != null && current.Enemy == enemy)
			{
				return current.Name;
			}
			string text = inbox.Take(sender, enemy, clock.Elapsed.TotalSeconds);
			try
			{
				OnDiagnostic?.Invoke((text == null) ? "owner metadata missing or expired" : ((text.Length == 0) ? "owner reported no player attacker" : "received owner attribution"));
			}
			catch
			{
			}
			return text;
		}

		internal static string TakeCredits(long sender, string enemy)
		{
			if (sender == 0L && current != null && current.Enemy == enemy)
			{
				return current.Credits;
			}
			return creditInbox.Take(sender, enemy, clock.Elapsed.TotalSeconds);
		}

		internal static string TakeEvent(long sender, string enemy)
		{
			if (sender == 0L && current != null && current.Enemy == enemy)
			{
				return current.EventId;
			}
			return eventInbox.Take(sender, enemy, clock.Elapsed.TotalSeconds);
		}

		internal static string TakeSubject(long sender, string enemy)
		{
			if (sender != 0L || current == null || !(current.Enemy == enemy))
			{
				return subjectInbox.Take(sender, enemy, clock.Elapsed.TotalSeconds);
			}
			return current.Subject;
		}

		internal static void Clear()
		{
			current = null;
			inbox.Clear();
			creditInbox.Clear();
			eventInbox.Clear();
			subjectInbox.Clear();
			OnDiagnostic = null;
			CinematicSubject = null;
		}
	}
	internal sealed class AttributionInbox
	{
		private sealed class Entry
		{
			internal long Sender;

			internal string Enemy;

			internal string Name;

			internal double Time;
		}

		private readonly List<Entry> entries = new List<Entry>();

		private readonly int maximumName;

		internal AttributionInbox(int maximumName = 256)
		{
			this.maximumName = maximumName;
		}

		internal void Add(long sender, string enemy, string name, double now)
		{
			if (!string.IsNullOrEmpty(enemy) && enemy.Length <= 256 && name != null && name.Length <= maximumName)
			{
				entries.RemoveAll((Entry e) => now - e.Time > 5.0 || (e.Sender == sender && e.Enemy == enemy));
				if (entries.Count >= 64)
				{
					entries.RemoveAt(0);
				}
				entries.Add(new Entry
				{
					Sender = sender,
					Enemy = enemy,
					Name = name,
					Time = now
				});
			}
		}

		internal string Take(long sender, string enemy, double now)
		{
			entries.RemoveAll((Entry e) => now - e.Time > 5.0);
			int num = entries.FindIndex((Entry e) => e.Sender == sender && e.Enemy == enemy);
			if (num < 0)
			{
				return null;
			}
			string name = entries[num].Name;
			entries.RemoveAt(num);
			return name;
		}

		internal void Clear()
		{
			entries.Clear();
		}
	}
	internal sealed class BossKill
	{
		internal string EnemyKey;

		internal string PlayerName;

		internal string FinalBlowName;

		internal string CreditNames;

		internal string EventId;

		internal string CinematicSubject;

		internal int BossNumber;

		internal bool FirstKill;

		internal bool Acquired;

		internal bool Special;

		internal BossLoot Loot;
	}
	internal static class BossKillDetector
	{
		private sealed class State
		{
			internal PlayerProfile Profile;

			internal string EnemyKey;

			internal int BossNumber;

			internal float Count;

			internal string FinalBlowName;

			internal string CreditNames;

			internal string EventId;

			internal string Subject;

			internal BossLoot Loot;
		}

		internal static Action<BossKill> OnKill;

		internal static Action<BossKill> OnLootKill;

		internal static Func<bool> ObserveOrdinary;

		internal static Action OnError;

		private const BindingFlags Fields = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private static readonly FieldInfo Stats = typeof(PlayerProfile).GetField("m_playerStats", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		internal static bool TryCount(PlayerProfile profile, string key, out float count)
		{
			count = 0f;
			try
			{
				if (!(Stats?.GetValue(profile) is Array { Length: not 0 } array))
				{
					return false;
				}
				object value = array.GetValue(0);
				if (!((value?.GetType().GetField("m_enemyStats", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))?.GetValue(value) is Dictionary<string, float>[] array2) || array2.Length == 0 || array2[0] == null || string.IsNullOrEmpty(key))
				{
					return false;
				}
				array2[0].TryGetValue(key, out count);
				return !float.IsNaN(count) && !float.IsInfinity(count) && count >= 0f;
			}
			catch
			{
				return false;
			}
		}

		internal static void Install(Harmony harmony)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00cc: Expected O, but got Unknown
			MethodInfo method = typeof(Game).GetMethod("RPC_RegisterKill", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[6]
			{
				typeof(long),
				typeof(string),
				typeof(int),
				typeof(int),
				typeof(int),
				typeof(bool)
			}, null);
			if (method == null || method.ReturnType != typeof(void))
			{
				throw new MissingMethodException("Expected Game.RPC_RegisterKill signature not found.");
			}
			harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(BossKillDetector), "Prefix", (Type[])null), new HarmonyMethod(typeof(BossKillDetector), "Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void Prefix(Game __instance, long sender, string enemyName, int bossNumber, out State __state)
		{
			__state = null;
			try
			{
				string eventId = BossAttribution.TakeEvent(sender, enemyName);
				string subject = BossAttribution.TakeSubject(sender, enemyName);
				string finalBlowName = BossAttribution.Take(sender, enemyName);
				string creditNames = BossAttribution.TakeCredits(sender, enemyName);
				if (bossNumber <= 0)
				{
					Func<bool> observeOrdinary = ObserveOrdinary;
					if (observeOrdinary == null || !observeOrdinary())
					{
						return;
					}
				}
				BossLoot loot = BossLootDetector.Take(sender, enemyName);
				PlayerProfile playerProfile = __instance.GetPlayerProfile();
				if (!TryCount(playerProfile, enemyName, out var count))
				{
					ReportError();
					return;
				}
				__state = new State
				{
					Profile = playerProfile,
					EnemyKey = enemyName,
					BossNumber = bossNumber,
					Count = count,
					FinalBlowName = finalBlowName,
					CreditNames = creditNames,
					Loot = loot,
					EventId = eventId,
					Subject = subject
				};
			}
			catch
			{
				ReportError();
			}
		}

		private static void Postfix(State __state)
		{
			if (__state == null)
			{
				return;
			}
			try
			{
				if (!TryCount(__state.Profile, __state.EnemyKey, out var count))
				{
					ReportError();
				}
				else if (!(count <= __state.Count))
				{
					((__state.BossNumber > 0) ? OnKill : OnLootKill)?.Invoke(new BossKill
					{
						EnemyKey = __state.EnemyKey,
						BossNumber = __state.BossNumber,
						PlayerName = __state.Profile.GetName(),
						FirstKill = (__state.Count == 0f),
						FinalBlowName = __state.FinalBlowName,
						CreditNames = __state.CreditNames,
						Loot = __state.Loot,
						EventId = __state.EventId,
						CinematicSubject = __state.Subject
					});
				}
			}
			catch
			{
				ReportError();
			}
		}

		private static void ReportError()
		{
			try
			{
				OnError?.Invoke();
			}
			catch
			{
			}
		}
	}
	internal sealed class LootItem
	{
		internal string Id;

		internal string Name;

		internal int Quantity;

		internal int Rank = -1;

		internal int Sockets;

		internal string Rarity = "";

		internal string Color = "";

		internal string Modifiers = "";

		internal bool Unidentified;
	}
	internal sealed class BossLoot
	{
		internal readonly string Id = Guid.NewGuid().ToString("N");

		internal readonly List<LootItem> Items = new List<LootItem>();

		internal bool Observed;

		internal bool Incomplete;

		internal bool Pending;

		internal int Revision;

		internal void AddEpic(LootItem item)
		{
			if (item == null || string.IsNullOrEmpty(item.Name) || string.IsNullOrEmpty(item.Id) || item.Quantity <= 0 || Items.Count >= 64)
			{
				Incomplete = true;
				return;
			}
			Items.Add(item);
			Observed = true;
		}

		internal void Add(string id, string name, long quantity)
		{
			if (string.IsNullOrEmpty(id) || string.IsNullOrEmpty(name) || quantity <= 0)
			{
				Incomplete = true;
				return;
			}
			if (id.Length > 128 || name.Length > 256 || quantity > int.MaxValue)
			{
				Incomplete = true;
				return;
			}
			LootItem lootItem = Items.Find((LootItem i) => i.Id == id && i.Name == name);
			if (lootItem != null)
			{
				if (quantity > int.MaxValue - lootItem.Quantity)
				{
					Incomplete = true;
				}
				else
				{
					lootItem.Quantity += (int)quantity;
				}
			}
			else if (Items.Count < 64)
			{
				Items.Add(new LootItem
				{
					Id = id,
					Name = name,
					Quantity = (int)quantity
				});
			}
			else
			{
				Incomplete = true;
			}
		}

		internal string Display(int maximum, bool quantity, Func<string, string> localize, bool showRarity = true, bool showModifiers = true, bool showSockets = true, bool showUnidentified = true)
		{
			if (!Observed)
			{
				return "unavailable";
			}
			if (Items.Count == 0)
			{
				if (!Incomplete)
				{
					return "No items generated.";
				}
				return "unavailable";
			}
			List<LootItem> list = new List<LootItem>();
			foreach (LootItem item in Items)
			{
				list.Add(new LootItem
				{
					Id = item.Id,
					Name = localize(item.Name),
					Quantity = item.Quantity,
					Rank = item.Rank,
					Rarity = localize(item.Rarity),
					Color = item.Color,
					Modifiers = localize(item.Modifiers),
					Sockets = item.Sockets,
					Unidentified = item.Unidentified
				});
			}
			list.Sort(delegate(LootItem a, LootItem b)
			{
				int num3 = b.Rank.CompareTo(a.Rank);
				if (num3 != 0)
				{
					return num3;
				}
				num3 = StringComparer.OrdinalIgnoreCase.Compare(a.Name, b.Name);
				return (num3 == 0) ? StringComparer.Ordinal.Compare(a.Id, b.Id) : num3;
			});
			maximum = Math.Max(1, Math.Min(20, maximum));
			List<string> list2 = new List<string>();
			for (int num = 0; num < Math.Min(maximum, list.Count); num++)
			{
				LootItem lootItem = list[num];
				string text = ((showRarity && lootItem.Rank >= 0) ? (Marker(lootItem.Color) + " " + WithRarity(lootItem.Name, lootItem.Rarity)) : lootItem.Name);
				list2.Add("* " + text + (quantity ? (" ×" + lootItem.Quantity) : "") + ((showUnidentified && lootItem.Unidentified) ? " (unidentified)" : ""));
				if (!lootItem.Unidentified && showModifiers && !string.IsNullOrEmpty(lootItem.Modifiers))
				{
					string[] array = lootItem.Modifiers.Replace("\r\n", "\n").Replace('\r', '\n').Split('\n');
					foreach (string text2 in array)
					{
						if (!string.IsNullOrWhiteSpace(text2))
						{
							list2.Add("  * -# " + text2.Trim());
						}
					}
				}
				if (!lootItem.Unidentified && showSockets && lootItem.Sockets > 0)
				{
					list2.Add("  * -# Sockets: " + lootItem.Sockets);
				}
			}
			if (list.Count > maximum)
			{
				list2.Add("+" + (list.Count - maximum) + " more item types");
			}
			if (Incomplete)
			{
				list2.Add("Some loot details unavailable.");
			}
			if (Pending)
			{
				list2.Add("Additional Epic Loot details unavailable before upload.");
			}
			return string.Join("\n", list2);
		}

		private static string WithRarity(string name, string rarity)
		{
			string text = (rarity ?? "").Trim();
			if (text.Length == 0)
			{
				return name;
			}
			string text2 = (name ?? "").TrimStart();
			while (text2.StartsWith(text, StringComparison.OrdinalIgnoreCase))
			{
				if (text2.Length == text.Length)
				{
					return text;
				}
				if (!char.IsWhiteSpace(text2[text.Length]))
				{
					break;
				}
				text2 = text2.Substring(text.Length).TrimStart();
			}
			return text + ((text2.Length == 0) ? "" : (" " + text2));
		}

		private static string Marker(string color)
		{
			if (color == null || color.Length != 7 || color[0] != '#' || !int.TryParse(color.Substring(1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
			{
				return "◆";
			}
			int[] array = new int[7] { 4359668, 10181046, 15965202, 15022389, 4431943, 16635957, 15658734 };
			string[] array2 = new string[7] { "\ud83d\udd35", "\ud83d\udfe3", "\ud83d\udfe0", "\ud83d\udd34", "\ud83d\udfe2", "\ud83d\udfe1", "⚪" };
			int num = 0;
			int num2 = int.MaxValue;
			for (int i = 0; i < array.Length; i++)
			{
				int num3 = (result >> 16) - (array[i] >> 16);
				int num4 = ((result >> 8) & 0xFF) - ((array[i] >> 8) & 0xFF);
				int num5 = (result & 0xFF) - (array[i] & 0xFF);
				int num6 = num3 * num3 + num4 * num4 + num5 * num5;
				if (num6 < num2)
				{
					num2 = num6;
					num = i;
				}
			}
			return array2[num];
		}

		internal string Encode()
		{
			using MemoryStream memoryStream = new MemoryStream();
			using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true))
			{
				binaryWriter.Write(2);
				binaryWriter.Write(Observed);
				binaryWriter.Write(Incomplete);
				binaryWriter.Write(Pending);
				binaryWriter.Write(Revision);
				binaryWriter.Write(Items.Count);
				foreach (LootItem item in Items)
				{
					binaryWriter.Write(item.Id);
					binaryWriter.Write(item.Name);
					binaryWriter.Write(item.Quantity);
					binaryWriter.Write(item.Rank);
					binaryWriter.Write(item.Rarity);
					binaryWriter.Write(item.Color);
					binaryWriter.Write(item.Modifiers);
					binaryWriter.Write(item.Sockets);
					binaryWriter.Write(item.Unidentified);
				}
			}
			return Convert.ToBase64String(memoryStream.ToArray());
		}

		internal static BossLoot Decode(string encoded)
		{
			if (encoded == null || encoded.Length > 524288)
			{
				return null;
			}
			try
			{
				using MemoryStream memoryStream = new MemoryStream(Convert.FromBase64String(encoded));
				using BinaryReader binaryReader = new BinaryReader(memoryStream, Encoding.UTF8);
				if (binaryReader.ReadInt32() != 2)
				{
					return null;
				}
				BossLoot bossLoot = new BossLoot
				{
					Observed = binaryReader.ReadBoolean(),
					Incomplete = binaryReader.ReadBoolean(),
					Pending = binaryReader.ReadBoolean(),
					Revision = binaryReader.ReadInt32()
				};
				if (bossLoot.Revision < 0)
				{
					return null;
				}
				int num = binaryReader.ReadInt32();
				if (num < 0 || num > 64)
				{
					return null;
				}
				for (int i = 0; i < num; i++)
				{
					string text = binaryReader.ReadString();
					string text2 = binaryReader.ReadString();
					int num2 = binaryReader.ReadInt32();
					if (text.Length == 0 || text.Length > 128 || text2.Length == 0 || text2.Length > 256 || num2 <= 0)
					{
						return null;
					}
					LootItem lootItem = new LootItem
					{
						Id = text,
						Name = text2,
						Quantity = num2,
						Rank = binaryReader.ReadInt32(),
						Rarity = binaryReader.ReadString(),
						Color = binaryReader.ReadString(),
						Modifiers = binaryReader.ReadString(),
						Sockets = binaryReader.ReadInt32(),
						Unidentified = binaryReader.ReadBoolean()
					};
					if (lootItem.Rank < -1 || lootItem.Rank > 100 || lootItem.Rarity.Length > 64 || lootItem.Color.Length > 16 || lootItem.Modifiers.Length > 1024 || lootItem.Sockets < 0 || lootItem.Sockets > 64)
					{
						return null;
					}
					bossLoot.Items.Add(lootItem);
				}
				return (memoryStream.Position == memoryStream.Length) ? bossLoot : null;
			}
			catch
			{
				return null;
			}
		}
	}
	internal sealed class LootInbox
	{
		private sealed class Entry
		{
			internal long Sender;

			internal string Enemy;

			internal string Token;

			internal double Time;

			internal bool Taken;

			internal bool Completed;

			internal BossLoot Loot = new BossLoot();
		}

		private readonly List<Entry> entries = new List<Entry>();

		private void Prune(double now)
		{
			entries.RemoveAll((Entry e) => now - e.Time > 30.0);
		}

		internal void Announce(long sender, string enemy, string token, double now)
		{
			if (string.IsNullOrEmpty(enemy) || enemy.Length > 256 || token == null || token.Length != 32 || !Guid.TryParseExact(token, "N", out var _))
			{
				return;
			}
			Prune(now);
			if (!entries.Exists((Entry e) => e.Sender == sender && e.Token == token))
			{
				if (entries.Count >= 64)
				{
					entries.RemoveAt(0);
				}
				entries.Add(new Entry
				{
					Sender = sender,
					Enemy = enemy,
					Token = token,
					Time = now
				});
			}
		}

		internal BossLoot Take(long sender, string enemy, double now)
		{
			Prune(now);
			Entry entry = entries.FindLast((Entry e) => !e.Taken && e.Sender == sender && e.Enemy == enemy && now - e.Time <= 5.0);
			if (entry == null)
			{
				return null;
			}
			entry.Taken = true;
			return entry.Loot;
		}

		internal void Complete(long sender, string token, string payload, double now)
		{
			Prune(now);
			Entry entry = entries.Find((Entry e) => e.Sender == sender && e.Token == token);
			if (entry != null)
			{
				BossLoot bossLoot = BossLoot.Decode(payload);
				if (bossLoot != null && (!entry.Completed || bossLoot.Revision > entry.Loot.Revision))
				{
					entry.Loot.Items.Clear();
					entry.Loot.Items.AddRange(bossLoot.Items);
					entry.Loot.Observed = bossLoot.Observed;
					entry.Loot.Incomplete = bossLoot.Incomplete;
					entry.Loot.Pending = bossLoot.Pending;
					entry.Loot.Revision = bossLoot.Revision;
					entry.Completed = true;
				}
			}
		}

		internal void Clear()
		{
			entries.Clear();
		}
	}
	internal static class BossLootDetector
	{
		private sealed class Context
		{
			internal Character Character;

			internal BossLoot Loot = new BossLoot();

			internal HashSet<long> Recipients = new HashSet<long>();

			internal HashSet<ItemData> EpicItems = new HashSet<ItemData>();

			internal int PendingRagdolls;
		}

		private const string CreditRpc = "ValheimMoments_BossLootCredit_v2";

		private const string ResultRpc = "ValheimMoments_BossLootResult_v2";

		private static readonly FieldInfo DropCharacter = typeof(CharacterDrop).GetField("m_character", BindingFlags.Instance | BindingFlags.NonPublic);

		[ThreadStatic]
		private static Context current;

		private static readonly LootInbox inbox = new LootInbox();

		private static readonly Stopwatch clock = Stopwatch.StartNew();

		private static ZRoutedRpc registered;

		private static bool enabled;

		private static ConditionalWeakTable<object, Context> ragdolls = new ConditionalWeakTable<object, Context>();

		internal static Action<int> OnObserved;

		internal static Action OnError;

		internal static void EnableEpic(Harmony harmony)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_007f: Expected O, but got Unknown
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Ragdoll), "Setup", (Type[])null, (Type[])null), new HarmonyMethod(typeof(BossLootDetector), "BeforeRagdollSetup", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Ragdoll), "SpawnLoot", (Type[])null, (Type[])null), new HarmonyMethod(typeof(BossLootDetector), "BeforeRagdollLoot", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(BossLootDetector), "AfterRagdollLoot", (Type[])null), (HarmonyMethod)null);
		}

		private static void BeforeRagdollSetup(object __instance, CharacterDrop characterDrop)
		{
			try
			{
				if (current != null && DropCharacter.GetValue(characterDrop) == current.Character)
				{
					ragdolls.Remove(__instance);
					ragdolls.Add(__instance, current);
					current.PendingRagdolls++;
					current.Loot.Pending = true;
				}
			}
			catch
			{
				Error();
			}
		}

		private static void BeforeRagdollLoot(object __instance, out Context __state)
		{
			__state = current;
			current = ((enabled && ragdolls.TryGetValue(__instance, out var value)) ? value : null);
		}

		private static void AfterRagdollLoot(object __instance, Context __state, Exception __exception)
		{
			Context context = current;
			current = __state;
			try
			{
				if (context != null)
				{
					ragdolls.Remove(__instance);
					context.PendingRagdolls = Math.Max(0, context.PendingRagdolls - 1);
					context.Loot.Pending = context.PendingRagdolls > 0;
					if (__exception != null)
					{
						context.Loot.Incomplete = true;
					}
					Publish(context);
					if (!context.Loot.Pending)
					{
						context.EpicItems.Clear();
					}
				}
			}
			catch
			{
				Error();
			}
		}

		internal static void RecordEpic(List<GameObject> objects)
		{
			if (!enabled || current == null || objects == null)
			{
				return;
			}
			foreach (GameObject @object in objects)
			{
				try
				{
					ItemData val2 = (((Object)(object)@object == (Object)null) ? null : @object.GetComponent<ItemDrop>()?.m_itemData);
					if (current.EpicItems.Count >= 256)
					{
						current.Loot.Incomplete = true;
						break;
					}
					if (val2 != null && current.EpicItems.Add(val2))
					{
						current.Loot.AddEpic(EpicLootAdapter.Read(val2, ((Object)@object).name));
						OnObserved?.Invoke(current.Loot.Items.Count);
					}
				}
				catch
				{
					current.Loot.Incomplete = true;
					Error();
				}
			}
		}

		internal static void Install(Harmony harmony)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_006b: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			if (DropCharacter == null)
			{
				throw new MissingFieldException("CharacterDrop.m_character");
			}
			enabled = true;
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Character), "OnDeath", Type.EmptyTypes, (Type[])null), new HarmonyMethod(typeof(BossLootDetector), "BeforeDeath", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(BossLootDetector), "AfterDeath", (Type[])null), (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(CharacterDrop), "GenerateDropList", Type.EmptyTypes, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(BossLootDetector), "AfterRoll", (Type[])null)
			{
				priority = 0
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Game), "RegisterKill", new Type[6]
			{
				typeof(long),
				typeof(string),
				typeof(int),
				typeof(KillModifiers),
				typeof(int),
				typeof(bool)
			}, (Type[])null), new HarmonyMethod(typeof(BossLootDetector), "BeforeCredit", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			foreach (ConstructorInfo declaredConstructor in AccessTools.GetDeclaredConstructors(typeof(ZRoutedRpc), (bool?)null))
			{
				harmony.Patch((MethodBase)declaredConstructor, (HarmonyMethod)null, new HarmonyMethod(typeof(BossLootDetector), "Register", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			Register(ZRoutedRpc.instance);
		}

		private static void Register(ZRoutedRpc __instance)
		{
			try
			{
				if (__instance == null || registered == __instance)
				{
					return;
				}
				__instance.Register<string, string>("ValheimMoments_BossLootCredit_v2", (Action<long, string, string>)delegate(long sender, string enemy, string token)
				{
					if (enabled)
					{
						inbox.Announce(sender, enemy, token, clock.Elapsed.TotalSeconds);
					}
				});
				__instance.Register<string, string>("ValheimMoments_BossLootResult_v2", (Action<long, string, string>)delegate(long sender, string token, string payload)
				{
					if (enabled)
					{
						inbox.Complete(sender, token, payload, clock.Elapsed.TotalSeconds);
					}
				});
				registered = __instance;
				inbox.Clear();
			}
			catch
			{
				Error();
			}
		}

		private static void BeforeDeath(Character __instance, out Context __state)
		{
			__state = current;
			current = null;
			try
			{
				if (!enabled || !__instance.IsOwner())
				{
					return;
				}
				if (!__instance.IsBoss())
				{
					Func<bool> observeOrdinary = BossKillDetector.ObserveOrdinary;
					if (observeOrdinary == null || !observeOrdinary())
					{
						return;
					}
				}
				current = new Context
				{
					Character = __instance
				};
			}
			catch
			{
				Error();
			}
		}

		private static void AfterDeath(Context __state, Exception __exception)
		{
			Context context = current;
			current = __state;
			try
			{
				if (context != null)
				{
					if (__exception != null)
					{
						context.Loot.Incomplete = true;
					}
					Publish(context);
				}
			}
			catch
			{
				Error();
			}
		}

		private static void Publish(Context context)
		{
			context.Loot.Revision++;
			string text = context.Loot.Encode();
			foreach (long recipient in context.Recipients)
			{
				try
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(recipient, "ValheimMoments_BossLootResult_v2", new object[2]
					{
						context.Loot.Id,
						text
					});
				}
				catch
				{
					Error();
				}
			}
		}

		private static void BeforeCredit(long playerPeerID, string enemyName, int bossNumber)
		{
			try
			{
				if (current != null && !(current.Character.m_name != enemyName) && current.Recipients.Add(playerPeerID))
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(playerPeerID, "ValheimMoments_BossLootCredit_v2", new object[2]
					{
						enemyName,
						current.Loot.Id
					});
				}
			}
			catch
			{
				Error();
			}
		}

		internal static BossLoot Take(long sender, string enemy)
		{
			if (sender == 0L && current != null && current.Character.m_name == enemy)
			{
				return current.Loot;
			}
			return inbox.Take(sender, enemy, clock.Elapsed.TotalSeconds);
		}

		private static void AfterRoll(CharacterDrop __instance, List<KeyValuePair<GameObject, int>> __result)
		{
			try
			{
				if (current == null || DropCharacter.GetValue(__instance) != current.Character)
				{
					return;
				}
				if (__result == null)
				{
					current.Loot.Incomplete = true;
					return;
				}
				current.Loot.Observed = true;
				foreach (KeyValuePair<GameObject, int> item in __result)
				{
					if ((Object)(object)item.Key == (Object)null || item.Value <= 0)
					{
						current.Loot.Incomplete = true;
						continue;
					}
					ItemDrop component = item.Key.GetComponent<ItemDrop>();
					if ((Object)(object)component == (Object)null || component.m_itemData?.m_shared == null)
					{
						current.Loot.Incomplete = true;
					}
					else
					{
						current.Loot.Add(((Object)item.Key).name, component.m_itemData.m_shared.m_name, (long)item.Value * (long)component.m_itemData.m_stack);
					}
				}
				OnObserved?.Invoke(current.Loot.Items.Count);
			}
			catch
			{
				if (current != null)
				{
					current.Loot.Incomplete = true;
				}
				Error();
			}
		}

		private static void Error()
		{
			try
			{
				OnError?.Invoke();
			}
			catch
			{
			}
		}

		internal static void Clear()
		{
			enabled = false;
			current = null;
			ragdolls = new ConditionalWeakTable<object, Context>();
			inbox.Clear();
			OnObserved = null;
			OnError = null;
		}
	}
	internal enum LootDecision
	{
		Accept,
		Wait,
		Reject
	}
	internal static class BossLootFilter
	{
		private static readonly Dictionary<string, int> ranks = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

		internal static void SetRarities(Type enumType)
		{
			ranks.Clear();
			foreach (object value in Enum.GetValues(enumType))
			{
				ranks[Enum.GetName(enumType, value)] = Convert.ToInt32(value);
			}
		}

		internal static bool TryRank(string name, out int rank)
		{
			rank = -1;
			if (string.Equals(name?.Trim(), "None", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return ranks.TryGetValue(name?.Trim() ?? "", out rank);
		}

		internal static LootDecision Decide(BossLoot loot, int minimum, bool deadlineReached)
		{
			if (minimum < 0)
			{
				return LootDecision.Accept;
			}
			if (loot != null)
			{
				foreach (LootItem item in loot.Items)
				{
					if (item.Rank >= minimum)
					{
						return LootDecision.Accept;
					}
				}
			}
			if (!deadlineReached && (loot == null || loot.Pending))
			{
				return LootDecision.Wait;
			}
			return LootDecision.Reject;
		}

		internal static LootDecision Evaluate(BossLoot loot, bool enabled, bool firstKill, bool firstBypasses, string minimumName, bool deadlineReached, out string reason)
		{
			if (!enabled)
			{
				reason = "rarity filter disabled";
				return LootDecision.Accept;
			}
			if (firstKill && firstBypasses)
			{
				reason = "first recorded boss kill bypasses rarity";
				return LootDecision.Accept;
			}
			if (!TryRank(minimumName, out var rank))
			{
				reason = "rarity name unsupported or Epic Loot unavailable";
				return LootDecision.Reject;
			}
			LootDecision lootDecision = Decide(loot, rank, deadlineReached);
			reason = lootDecision switch
			{
				LootDecision.Wait => "awaiting boss loot", 
				LootDecision.Accept => "observed loot meets threshold (or threshold is None)", 
				_ => "no observed item met rarity threshold", 
			};
			return lootDecision;
		}
	}
	internal enum CinematicMovement
	{
		Orbit,
		RiseAndReveal,
		ZoomIn
	}
	internal sealed class CinematicCamera : IDisposable
	{
		private sealed class Shot
		{
			internal string Key;

			internal byte Kind;

			internal double Started;

			internal RaidMedia Media;

			internal Task<string> Worker;

			internal CaptureBuffer.Clip Clip;

			internal byte[] Data;

			internal string Caption;

			internal bool Letterbox;
		}

		internal const string SpawnStamp = "ValheimMoments_CinematicSpawn";

		private readonly List<Shot> shots = new List<Shot>();

		private readonly string root;

		private readonly string helper;

		private readonly Action<string> log;

		private Camera camera;

		private RenderTexture target;

		private CaptureBuffer buffer;

		private Shot active;

		private Transform subject;

		private Vector3 focus;

		private Vector3 direction;

		private float radius;

		private float distanceScale;

		private float panDegrees;

		private float focusHeight;

		private bool rise;

		private bool zoomIn;

		private bool flipImage;

		private double nextFrame;

		private double submitted;

		private AsyncGPUReadbackRequest request;

		private bool reading;

		private bool disposed;

		private int quality;

		internal bool Busy => active != null;

		internal CinematicCamera(string root, string helper, Action<string> log)
		{
			this.root = root;
			this.helper = helper;
			this.log = log;
		}

		internal static string Subject(Character character)
		{
			object obj;
			if (character == null)
			{
				obj = null;
			}
			else
			{
				ZNetView component = ((Component)character).GetComponent<ZNetView>();
				obj = ((component != null) ? component.GetZDO() : null);
			}
			return ((object)Unsafe.As<ZDOID, ZDOID>(ref ((ZDO)(obj?)).m_uid)/*cast due to .constrained prefix*/).ToString();
		}

		private static void BeforeView(out bool __state)
		{
			__state = AccessTools.Field(typeof(ZNetView), "m_initZDO")?.GetValue(null) == null;
		}

		private static void AfterView(ZNetView __instance, bool __state)
		{
			try
			{
				Character component = ((Component)__instance).GetComponent<Character>();
				if (__state && (Object)(object)component != (Object)null && !(component is Player) && __instance.IsOwner() && (Object)(object)ZNet.instance != (Object)null)
				{
					ZDO zDO = __instance.GetZDO();
					if (zDO != null)
					{
						zDO.Set("ValheimMoments_CinematicSpawn", ZNet.instance.GetTime().Ticks);
					}
				}
			}
			catch
			{
			}
		}

		internal static void Install(Harmony harmony)
		{
			//IL_0027: 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_0049: Expected O, but got Unknown
			//IL_0049: Expected O, but got Unknown
			harmony.Patch((MethodBase)AccessTools.Method(typeof(ZNetView), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(typeof(CinematicCamera), "BeforeView", (Type[])null), new HarmonyMethod(typeof(CinematicCamera), "AfterView", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		internal bool Start(string key, byte kind, Vector3 center, Transform follow, float size, double now, int q, float distanceMultiplier = 2f, float sweepDegrees = 70f, CinematicMovement movement = CinematicMovement.Orbit, string caption = null, bool letterbox = true, bool flip = true)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			if (disposed || active != null || shots.Exists((Shot s) => s.Worker != null) || (Object)(object)Camera.main == (Object)null || string.IsNullOrEmpty(key) || shots.Exists((Shot s) => s.Key == key && s.Kind == kind) || Vector3.Distance(((Component)Camera.main).transform.position, center) > 100f)
			{
				return false;
			}
			Tick(now);
			if (shots.Count >= 4)
			{
				return false;
			}
			try
			{
				GameObject val = new GameObject("Valheim Moments cinematic camera")
				{
					hideFlags = (HideFlags)61
				};
				camera = val.AddComponent<Camera>();
				camera.CopyFrom(Camera.main);
				((Behaviour)camera).enabled = false;
				((Component)camera).tag = "Untagged";
				camera.stereoTargetEye = (StereoTargetEyeMask)0;
				camera.fieldOfView = 55f;
				camera.nearClipPlane = 0.15f;
				camera.farClipPlane = Mathf.Min(camera.farClipPlane, 250f);
				Camera obj = camera;
				obj.cullingMask &= -33;
				target = new RenderTexture(640, 360, 24, (RenderTextureFormat)0)
				{
					hideFlags = (HideFlags)61
				};
				target.Create();
				camera.targetTexture = target;
				camera.aspect = 1.7777778f;
				buffer = new CaptureBuffer(640, 360, 10, 0.1, 4.0, 50331648L);
				buffer.TryTriggerSegment(now, 4.0);
				active = new Shot
				{
					Key = key,
					Kind = kind,
					Started = now,
					Media = new RaidMedia(root),
					Caption = (caption ?? CinematicPacket.Label(kind)),
					Letterbox = letterbox
				};
				shots.Add(active);
				subject = follow;
				focus = center;
				quality = q;
				radius = Mathf.Clamp(size * 2.8f, 7f, 24f);
				focusHeight = radius / 5.6f;
				distanceScale = Mathf.Clamp(distanceMultiplier, 1f, 3f);
				panDegrees = Mathf.Clamp(sweepDegrees, 0f, 180f);
				rise = movement == CinematicMovement.RiseAndReveal;
				zoomIn = movement == CinematicMovement.ZoomIn;
				flipImage = flip;
				direction = ((Component)Camera.main).transform.position - center;
				direction.y = 0f;
				if (((Vector3)(ref direction)).sqrMagnitude < 0.1f)
				{
					direction = Vector3.back;
				}
				((Vector3)(ref direction)).Normalize();
				nextFrame = now;
				return true;
			}
			catch (Exception ex)
			{
				log("Camera setup skipped: " + ex.GetType().Name);
				CancelActive();
				return false;
			}
		}

		internal void Render(double now)
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: 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_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			if (active == null || disposed)
			{
				return;
			}
			try
			{
				Drain();
				if (now >= active.Started + 4.0)
				{
					if (reading)
					{
						return;
					}
					CaptureBuffer.Clip clip = buffer.TryComplete(now);
					if (clip == null || clip.Count < 10)
					{
						clip?.Release();
						CancelActive();
						return;
					}
					Shot shot = active;
					shot.Clip = clip;
					int q = quality;
					bool flip = flipImage;
					shot.Worker = shot.Media.Start(delegate(CancellationToken token)
					{
						string result = EncoderClient.Encode(clip, helper, shot.Media.Opening, 640, 360, q, flip, token);
						EncoderClient.Compose(helper, shot.Media.Opening, null, shot.Media.Combined, q, token, shot.Caption, cinematic: true, shot.Letterbox);
						if (new FileInfo(shot.Media.Combined).Length <= 4194304)
						{
							shot.Data = File.ReadAllBytes(shot.Media.Combined);
						}
						return result;
					});
					active = null;
					ReleaseCamera();
					buffer = null;
				}
				else
				{
					if (reading || now < nextFrame)
					{
						return;
					}
					nextFrame = now + 0.1;
					float num = Mathf.SmoothStep(0f, 1f, (float)((now - active.Started) / 4.0));
					if ((Object)(object)subject != (Object)null)
					{
						focus = Vector3.Lerp(focus, subject.position + Vector3.up * focusHeight, 0.15f);
					}
					float num2 = (rise ? Mathf.Lerp(7f, 15f, num) : (radius * Mathf.Lerp(1f, 0.88f, num))) * distanceScale;
					float num3 = (rise ? Mathf.Lerp(3f, 15f, num) : (radius * 0.35f)) * distanceScale;
					if (zoomIn)
					{
						float num4 = Mathf.Lerp(2f, 1f, num);
						num2 = radius * num4;
						num3 = radius * 0.35f * num4;
					}
					Vector3 val = Quaternion.AngleAxis(zoomIn ? 0f : Mathf.Lerp((0f - panDegrees) / 2f, panDegrees / 2f, num), Vector3.up) * direction * num2 + Vector3.up * num3;
					val = Vector3.ClampMagnitude(val, 80f);
					Vector3 val2 = focus + val;
					int mask = LayerMask.GetMask(new string[6] { "Default", "static_solid", "terrain", "piece", "Default_small", "small_solid" });
					if (Blocked(focus, val2, mask, out var hit))
					{
						for (int num5 = 1; num5 <= 3; num5++)
						{
							Vector3 val3 = focus + Vector3.ClampMagnitude(val + Vector3.up * (float)(num5 * 6), 80f);
							if (!Blocked(focus, val3, mask, out var _))
							{
								val2 = val3;
								break;
							}
						}
					}
					if (Blocked(focus, val2, mask, out hit))
					{
						if (((RaycastHit)(ref hit)).distance < 2f)
						{
							CancelActive();
							return;
						}
						Vector3 point = ((RaycastHit)(ref hit)).point;
						Vector3 val4 = focus - ((RaycastHit)(ref hit)).point;
						val2 = point + ((Vector3)(ref val4)).normalized * 0.5f;
					}
					((Component)camera).transform.SetPositionAndRotation(val2, Quaternion.LookRotation(focus - val2, Vector3.up));
					RenderTexture val5 = RenderTexture.active;
					try
					{
						camera.Render();
					}
					finally
					{
						RenderTexture.active = val5;
					}
					submitted = now;
					request = AsyncGPUReadback.Request((Texture)(object)target, 0, (TextureFormat)4, (Action<AsyncGPUReadbackRequest>)null);
					reading = true;
				}
			}
			catch (Exception ex)
			{
				log("Camera shot skipped: " + ex.GetType().Name);
				CancelActive();
			}
		}

		private static bool Blocked(Vector3 center, Vector3 destination, int mask, out RaycastHit hit)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = destination - center;
			return Physics.SphereCast(center, 0.6f, ((Vector3)(ref val)).normalized, ref hit, ((Vector3)(ref val)).magnitude, mask, (QueryTriggerInteraction)1);
		}

		private void Drain()
		{
			//IL_003c: 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)
			if (reading && ((AsyncGPUReadbackRequest)(ref request)).done)
			{
				reading = false;
				if (((AsyncGPUReadbackRequest)(ref request)).hasError)
				{
					throw new IOException("Camera readback");
				}
				NativeArray<byte> data = ((AsyncGPUReadbackRequest)(ref request)).GetData<byte>(0);
				byte[] array = new byte[data.Length];
				data.CopyTo(array);
				buffer.AddFrame(array, submitted);
			}
		}

		internal void Tick(double now)
		{
			foreach (Shot item in new List<Shot>(shots))
			{
				if (item.Worker != null && item.Worker.IsCompleted)
				{
					if (item.Worker.IsFaulted || item.Worker.IsCanceled)
					{
						item.Data = null;
					}
					_ = item.Worker.Exception;
					item.Clip?.Release();
					item.Clip = null;
					item.Worker = null;
					item.Media.Dispose();
					if (item.Data == null)
					{
						shots.Remove(item);
					}
				}
				if (item != active && item.Worker == null && now - item.Started > 1800.0)
				{
					shots.Remove(item);
				}
			}
		}

		internal List<CinematicPacket.Shot> Take(string key)
		{
			List<CinematicPacket.Shot> list = new List<CinematicPacket.Shot>();
			foreach (Shot item in new List<Shot>(shots))
			{
				if (item.Key == key && item.Worker == null && item.Data != null)
				{
					list.Add(new CinematicPacket.Shot
					{
						Kind = item.Kind,
						Pixels = item.Data
					});
					shots.Remove(item);
				}
			}
			list.Sort((CinematicPacket.Shot a, CinematicPacket.Shot b) => a.Kind.CompareTo(b.Kind));
			return list;
		}

		internal bool Pending(string key)
		{
			return shots.Exists((Shot s) => s.Key == key && (s == active || s.Worker != null));
		}

		private void ReleaseCamera()
		{
			if (reading)
			{
				((AsyncGPUReadbackRequest)(ref request)).WaitForCompletion();
				reading = false;
			}
			if ((Object)(object)camera != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)camera).gameObject);
			}
			camera = null;
			if ((Object)(object)target != (Object)null)
			{
				target.Release();
				Object.Destroy((Object)(object)target);
			}
			target = null;
			subject = null;
		}

		private void CancelActive()
		{
			if (active != null)
			{
				active.Media.Dispose();
				shots.Remove(active);
				active = null;
			}
			ReleaseCamera();
			buffer = null;
		}

		public void Dispose()
		{
			if (disposed)
			{
				return;
			}
			disposed = true;
			CancelActive();
			foreach (Shot shot in shots)
			{
				shot.Media.Dispose();
				if (shot.Worker != null)
				{
					try
					{
						shot.Worker.GetAwaiter().GetResult();
					}
					catch
					{
					}
				}
				shot.Clip?.Release();
			}
			shots.Clear();
		}
	}
	internal static class CinematicPacket
	{
		internal sealed class Shot
		{
			internal byte Kind;

			internal byte[] Pixels;
		}

		internal const uint Chunk = 1229147478u;

		internal const int Limit = 10485760;

		internal static byte[] Strip(byte[] input, out List<Shot> shots)
		{
			shots = new List<Shot>();
			if (input.Length < 20 || input.Length > 10485760)
			{
				throw new InvalidDataException("Camera packet size");
			}
			using MemoryStream memoryStream = new MemoryStream(input, writable: false);
			using BinaryReader binaryReader = new BinaryReader(memoryStream);
			using MemoryStream memoryStream2 = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream2);
			if (binaryReader.ReadUInt32() != 1179011410 || binaryReader.ReadUInt32() != input.Length - 8 || binaryReader.ReadUInt32() != 1346520407)
			{
				throw new InvalidDataException("Camera packet header");
			}
			binaryWriter.Write(1179011410);
			binaryWriter.Write(0);
			binaryWriter.Write(1346520407);
			HashSet<byte> hashSet = new HashSet<byte>();
			while (memoryStream.Position < memoryStream.Length)
			{
				if (memoryStream.Length - memoryStream.Position < 8)
				{
					throw new InvalidDataException("Camera packet chunk");
				}
				uint num = binaryReader.ReadUInt32();
				uint num2 = binaryReader.ReadUInt32();
				if ((long)num2 + (long)(num2 & 1) > memoryStream.Length - memoryStream.Position)
				{
					throw new InvalidDataException("Camera packet length");
				}
				if (num == 1229147478)
				{
					if (num2 < 22 || shots.Count == 2)
					{
						throw new InvalidDataException("Camera packet count");
					}
					byte num3 = binaryReader.ReadByte();
					byte b = binaryReader.ReadByte();
					if (num3 != 1 || b < 1 || b > 4 || !hashSet.Add(b))
					{
						throw new InvalidDataException("Camera packet role");
					}
					byte[] array = binaryReader.ReadBytes((int)(num2 - 2));
					if (ContainsCamera(array))
					{
						throw new InvalidDataException("Nested camera packet");
					}
					Strip(array, out var _);
					shots.Add(new Shot
					{
						Kind = b,
						Pixels = array
					});
				}
				else
				{
					binaryWriter.Write(num);
					binaryWriter.Write(num2);
					binaryWriter.Write(binaryReader.ReadBytes((int)num2));
					if ((num2 & 1) != 0)
					{
						binaryWriter.Write((byte)0);
					}
				}
				if ((num2 & 1) != 0 && binaryReader.ReadByte() != 0)
				{
					throw new InvalidDataException("Camera packet padding");
				}
			}
			binaryWriter.Flush();
			memoryStream2.Position = 4L;
			binaryWriter.Write((int)memoryStream2.Length - 8);
			return memoryStream2.ToArray();
		}

		private static bool ContainsCamera(byte[] data)
		{
			if (data.Length < 12)
			{
				return false;
			}
			using MemoryStream memoryStream = new MemoryStream(data, writable: false);
			using BinaryReader binaryReader = new BinaryReader(memoryStream);
			memoryStream.Position = 12L;
			while (memoryStream.Length - memoryStream.Position >= 8)
			{
				uint num = binaryReader.ReadUInt32();
				uint num2 = binaryReader.ReadUInt32();
				if (num == 1229147478)
				{
					return true;
				}
				long num3 = memoryStream.Position + num2 + (num2 & 1);
				if (num3 > memoryStream.Length)
				{
					return false;
				}
				memoryStream.Position = num3;
			}
			return false;
		}

		internal static void Attach(string file, IList<Shot> shots)
		{
			if (shots.Count == 0)
			{
				return;
			}
			List<Shot> shots2;
			byte[] buffer = Strip(File.ReadAllBytes(file), out shots2);
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
			binaryWriter.Write(buffer);
			HashSet<byte> hashSet = new HashSet<byte>();
			foreach (Shot shot in shots)
			{
				if (hashSet.Count != 2 && hashSet.Add(shot.Kind) && shot.Kind >= 1 && shot.Kind <= 4 && shot.Pixels != null && memoryStream.Length + shot.Pixels.Length + 10 + (shot.Pixels.Length & 1) <= 10485760 && !ContainsCamera(shot.Pixels))
				{
					Strip(shot.Pixels, out shots2);
					binaryWriter.Write(1229147478u);
					binaryWriter.Write(shot.Pixels.Length + 2);
					binaryWriter.Write((byte)1);
					binaryWriter.Write(shot.Kind);
					binaryWriter.Write(shot.Pixels);
					if ((shot.Pixels.Length & 1) != 0)
					{
						binaryWriter.Write((byte)0);
					}
				}
			}
			memoryStream.Position = 4L;
			binaryWriter.Write((int)memoryStream.Length - 8);
			string text = file + ".partial";
			try
			{
				File.WriteAllBytes(text, memoryStream.ToArray());
				File.Replace(text, file, null);
			}
			finally
			{
				if (File.Exists(text))
				{
					File.Delete(text);
				}
			}
		}

		internal static string Label(byte kind)
		{
			return kind switch
			{
				3 => "Raid opening", 
				2 => "Enemy aftermath", 
				1 => "Enemy arrival", 
				_ => "Biome discovery", 
			};
		}
	}
	internal sealed class ClipRelay : IDisposable
	{
		private sealed class Waiting
		{
			internal RelayFile File;

			internal ZRpc Peer;

			internal ZNet Origin;

			internal double Deadline;

			internal double Heartbeat;

			internal Action<string> Ready;
		}

		private const string Rpc = "ValheimMoments_ClipRelay_v2";

		private readonly Func<string, bool> allow;

		private readonly Func<int> limit;

		private readonly Action<RelayFile, string, Action<RelayOutcome>> deliver;

		private readonly string directory;

		internal Func<RelayFile, string, long, Func<bool>, Func<Action<string>, bool>, Action<RelayOutcome>, bool> Collect;

		private readonly Dictionary<ZRpc, Waiting> waiting = new Dictionary<ZRpc, Waiting>();

		private readonly Dictionary<ZRpc, long> peerIds = new Dictionary<ZRpc, long>();

		private long nextPeerId;

		private readonly Action<string> log;

		private readonly Func<ZRpc, bool> allowPeer;

		private readonly Func<ZRpc, string, double, bool> acceptEvent;

		private Action<RelayOutcome> outgoingCompletion;

		private readonly HashSet<ZRpc> registered = new HashSet<ZRpc>();

		private readonly Dictionary<ZRpc, double> nextOffer = new Dictionary<ZRpc, double>();

		private ZNet session;

		private ZRpc source;

		private ZRpc target;

		private ZRpc deliveryPeer;

		private RelayFile incoming;

		private RelayFile delivery;

		private int outgoingSize;

		private Task<int> preparation;

		private Task<byte[]> reading;

		private Task<string> cleanup;

		private string outgoingFile;

		private bool keepOutgoing;

		private string offeredKind;

		private string offeredMessage;

		private string offeredEventId;

		private bool offeredFirst;

		private string outgoingId;

		private int sent;

		private int acknowledged;

		private double now;

		private double incomingDeadline;

		private double incomingEnd;

		private double outgoingDeadline;

		private double outgoingEnd;

		private double nextSend;

		private double nextTick;

		private bool delivering;

		private bool awaitingOffer;

		private bool waitingResult;

		private bool disposed;

		internal string LastMessageLink { get; private set; }

		internal bool DeliveryPeerConnected
		{
			get
			{
				if (deliveryPeer != null && registered.Contains(deliveryPeer))
				{
					return deliveryPeer.IsConnected();
				}
				return false;
			}
		}

		internal void PublishReceipt(string id, string link)
		{
			if (!MomentGallery.ValidLink(link) || (Object)(object)session == (Object)null || !session.IsServer())
			{
				return;
			}
			if (delivery != null && delivery.Id == id && deliveryPeer != null)
			{
				Send(deliveryPeer, "L|" + id + "|" + link);
			}
			foreach (Waiting value in waiting.Values)
			{
				if (value.File.Id == id)
				{
					Send(value.Peer, "L|" + id + "|" + link);
				}
			}
		}

		internal void PublishDeliveryReceipt(string link)
		{
			if (delivery != null)
			{
				PublishReceipt(delivery.Id, link);
			}
		}

		internal ClipRelay(Func<string, bool> allow, Func<int> limit, Action<RelayFile, string, Action<RelayOutcome>> deliver, Action<string> log, Func<ZRpc, bool> allowPeer = null, Func<ZRpc, string, double, bool> acceptEvent = null, string directory = null)
		{
			this.allow = allow;
			this.limit = limit;
			this.deliver = deliver;
			this.log = log;
			this.allowPeer = allowPeer ?? ((Func<ZRpc, bool>)((ZRpc rpc) => true));
			this.acceptEvent = acceptEvent ?? ((Func<ZRpc, string, double, bool>)((ZRpc rpc, string kind, double now) => true));
			this.directory = directory ?? Path.Combine(Path.GetTempPath(), "ValheimMoments-Relay");
		}

		internal void Tick(double time)
		{
			if (disposed)
			{
				return;
			}
			now = time;
			if (cleanup != null && cleanup.IsCompleted)
			{
				log(cleanup.GetAwaiter().GetResult());
				cleanup = null;
			}
			if (now < nextTick)
			{
				return;
			}
			nextTick = now + 0.05;
			ZNet instance = ZNet.instance;
			if (session != instance)
			{
				Reset();
				session = instance;
			}
			if ((Object)(object)session == (Object)null)
			{
				return;
			}
			HashSet<ZRpc> live = new HashSet<ZRpc>();
			foreach (ZNetPeer peer in session.GetPeers())
			{
				if (peer.IsReady() && peer.m_rpc.IsConnected())
				{
					live.Add(peer.m_rpc);
					if (!peerIds.ContainsKey(peer.m_rpc))
					{
						peerIds.Add(peer.m_rpc, ++nextPeerId);
					}
					if (registered.Add(peer.m_rpc))
					{
						peer.m_rpc.Register<string>("ValheimMoments_ClipRelay_v2", (Action<ZRpc, string>)Receive);
					}
				}
			}
			registered.RemoveWhere((ZRpc rpc) => !live.Contains(rpc));
			List<ZRpc> list = new List<ZRpc>();
			foreach (KeyValuePair<ZRpc, double> item in nextOffer)
			{
				if (!live.Contains(item.Key))
				{
					list.Add(item.Key);
				}
			}
			foreach (ZRpc item2 in list)
			{
				nextOffer.Remove(item2);
			}
			foreach (ZRpc item3 in new List<ZRpc>(peerIds.Keys))
			{
				if (!live.Contains(item3))
				{
					peerIds.Remove(item3);
				}
			}
			foreach (Waiting item4 in new List<Waiting>(waiting.Values))
			{
				if (!live.Contains(item4.Peer) || now >= item4.Deadline || !allowPeer(item4.Peer) || !allow(item4.File.Kind))
				{
					FinishWaiting(item4, item4.File.Complete ? RelayOutcome.Unknown : RelayOutcome.Failed, abandoned: true);
				}
				else if (now >= item4.Heartbeat)
				{
					Send(item4.Peer, "W|" + item4.File.Id + "|0");
					item4.Heartbeat = now + 5.0;
				}
			}
			if (source != null && (!live.Contains(source) || now > incomingDeadline || now > incomingEnd))
			{
				RejectIncoming();
			}
			PollIncoming();
			if (target != null && (!live.Contains(target) || now > outgoingDeadline || now > outgoingEnd))
			{
				EndInterrupted("Transfer ended or host unavailable; local clip retained.");
			}
			if (preparation != null && preparation.IsCompleted)
			{
				Task<int> task = preparation;
				preparation = null;
				try
				{
					int result = task.GetAwaiter().GetResult();
					if (target != null)
					{
						if (result == 0)
						{
							EndOutgoing("Clip could not be read or exceeds 10 MiB; local copy retained.");
							return;
						}
						outgoingSize = result;
						outgoingDeadline = now + 10.0;
						Send(target, "B|" + outgoingId + "|" + offeredKind + "|" + result + "|" + RelayProtocol.Text(offeredMessage) + "|" + (offeredEventId ?? "-") + "|" + (offeredFirst ? "1" : "0"));
					}
				}
				catch
				{
					EndOutgoing("Clip could not be read or exceeds 10 MiB; local copy retained.");
				}
			}
			if (outgoingSize <= 0 || awaitingOffer || waitingResult || sent != acknowledged || !(now >= nextSend))
			{
				return;
			}
			try
			{
				if (reading == null)
				{
					reading = RelayFile.ReadChunk(outgoingFile, sent, outgoingSize);
				}
				else if (reading.IsCompleted)
				{
					byte[] result2 = reading.GetAwaiter().GetResult();
					reading = null;
					if (result2 == null || result2.Length == 0)
					{
						EndOutgoing("Clip could not be read; local copy retained.");
						return;
					}
					int num = result2.Length;
					int num2 = sent;
					sent += num;
					nextSend = now + 0.05;
					Send(target, "C|" + outgoingId + "|" + num2 + "|" + Convert.ToBase64String(result2));
				}
			}
			catch
			{
				EndInterrupted("Clip transfer failed; local copy retained.");
			}
		}

		internal bool Offer(ZNet capturedSession, string file, string kind, string message, bool saveLocalCopy = true, Action<RelayOutcome> completed = null, string eventId = null, bool personalFirst = false)
		{
			if (disposed || (Object)(object)session == (Object)null || session != capturedSession || session.IsServer() || outgoingSize > 0 || preparation != null || cleanup != null || target != null)
			{
				return false;
			}
			if (!RelayProtocol.ValidKind(kind) || message == null || message.Length > 2000 || (eventId != null && !HighlightDirector.ValidId(eventId)))
			{
				return false;
			}
			ZNetPeer serverPeer = session.GetServerPeer();
			if (serverPeer == null || !registered.Contains(serverPeer.m_rpc))
			{
				return false;
			}
			try
			{
				target = serverPeer.m_rpc;
				outgoingId = Guid.NewGuid().ToString("N");
				LastMessageLink = null;
				outgoingCompletion = completed;
				outgoingFile = file;
				keepOutgoing = saveLocalCopy;
				offeredKind = kind;
				offeredMessage = message;
				offeredEventId = eventId;
				offeredFirst = personalFirst;
				sent = (acknowledged = 0);
				awaitingOffer = true;
				waitingResult = false;
				outgoingDeadline = now + 10.0;
				outgoingEnd = now + 1230.0;
				preparation = RelayFile.Inspect(file);
				log("Offered clip to host; client webhook and bot-name settings are ignored.");
				return true;
			}
			catch
			{
				EndOutgoing("Could not offer clip to host; local copy retained.");
				return false;
			}
		}

		private void Receive(ZRpc rpc, string packet)
		{
			if (disposed || (Object)(object)session == (Object)null || session != ZNet.instance || !registered.Contains(rpc) || !rpc.IsConnected() || packet == null || packet.Length > 24000)
			{
				return;
			}
			try
			{
				string[] array = packet.Split('|');
				if (array.Length >= 2 && RelayProtocol.ValidId(array[1]))
				{
					if (session.IsServer())
					{
						ReceiveHost(rpc, array);
					}
					else if (target == rpc && array[1] == outgoingId)
					{
						ReceiveClient(array);
					}
				}
			}
			catch
			{
				log("Invalid relay data ignored.");
			}
		}

		private void ReceiveHost(ZRpc rpc, string[] p)
		{
			int result;
			if (p[0] == "B" && p.Length == 7)
			{
				if (nextOffer.TryGetValue(rpc, out var value) && now < value)
				{
					Send(rpc, "R|" + p[1] + "|0");
					return;
				}
				nextOffer[rpc] = now + 15.0;
				if ((Collect == null && (source != null || delivering)) || waiting.ContainsKey(rpc) || waiting.Count >= 16 || !allowPeer(rpc) || !RelayProtocol.ValidKind(p[2]) || !allow(p[2]) || !int.TryParse(p[3], out var size))
				{
					Send(rpc, "R|" + p[1] + "|0");
					return;
				}
				string message = RelayProtocol.ReadText(p[4]);
				if (p[6] != "0" && p[6] != "1")
				{
					Send(rpc, "R|" + p[1] + "|0");
					return;
				}
				RelayFile offered;
				try
				{
					offered = new RelayFile(directory, p[1], p[2], message, size, limit(), (p[5] == "-") ? null : p[5], p[6] == "1");
				}
				catch
				{
					Send(rpc, "R|" + p[1] + "|0");
					return;
				}
				if (!acceptEvent(rpc, p[2], now))
				{
					offered.Dispose();
					Send(rpc, "R|" + p[1] + "|0");
				}
				else if (Collect != null)
				{
					Waiting entry = new Waiting
					{
						File = offered,
						Peer = rpc,
						Origin = session,
						Deadline = now + 1200.0
					};
					waiting.Add(rpc, entry);
					string arg = "Connected player";
					foreach (ZNetPeer peer in session.GetPeers())
					{
						if (peer.m_rpc == rpc)
						{
							arg = peer.m_playerName;
							break;
						}
					}
					bool flag = false;
					try
					{
						flag = Collect(offered, arg, peerIds[rpc], () => IsWaiting(entry), delegate(Action<string> ready)
						{
							if (!IsWaiting(entry) || source != null || delivering)
							{
								return false;
							}
							entry.Ready = ready;
							incoming = offered;
							source = rpc;
							incomingDeadline = now + 30.0;
							incomingEnd = now + 30.0 + Math.Ceiling((double)size / 16384.0) * 0.5;
							Send(rpc, "A|" + offered.Id + "|0");
							return true;
						}, delegate(RelayOutcome outcome)
						{
							FinishWaiting(entry, outcome);
						});
					}
					catch
					{
					}
					if (!flag)
					{
						FinishWaiting(entry, RelayOutcome.Omitted);
						return;
					}
					Send(rpc, "W|" + offered.Id + "|0");
					entry.Heartbeat = now + 5.0;
				}
				else
				{
					incoming = offered;
					source = rpc;
					incomingDeadline = now + 30.0;
					incomingEnd = now + 30.0 + Math.Ceiling((double)size / 16384.0) * 0.5;
					Send(rpc, "A|" + p[1] + "|0");
				}
			}
			else if (p[0] == "C" && p.Length == 4 && source == rpc && incoming != null && incoming.Id == p[1] && (!allowPeer(rpc) || !allow(incoming.Kind) || !int.TryParse(p[2], out result) || !incoming.BeginAdd(result, Convert.FromBase64String(p[3]))))
			{
				RejectIncoming();
			}
		}

		private void PollIncoming()
		{
			if (incoming == null || source == null)
			{
				return;
			}
			int num = incoming.Poll();
			if (num == 0)
			{
				return;
			}
			ZRpc rpc = source;
			if (num < 0 || !allowPeer(rpc) || !allow(incoming.Kind))
			{
				RejectIncoming();
				return;
			}
			incomingDeadline = now + 30.0;
			if (num == 1)
			{
				Send(rpc, "A|" + incoming.Id + "|" + incoming.Received);
				return;
			}
			RelayFile complete = incoming;
			incoming = null;
			source = null;
			if (waiting.TryGetValue(rpc, out var value) && value.File == complete)
			{
				Send(rpc, "A|" + complete.Id + "|" + complete.Received);
				Action<string> ready = value.Ready;
				value.Ready = null;
				try
				{
					ready?.Invoke(complete.FilePath);
					return;
				}
				catch
				{
					FinishWaiting(value, RelayOutcome.Failed);
					return;
				}
			}
			delivering = true;
			deliveryPeer = rpc;
			delivery = complete;
			ZNet origin = session;
			string arg = "Connected player";
			foreach (ZNetPeer peer in session.GetPeers())
			{
				if (peer.m_rpc == rpc)
				{
					arg = peer.m_playerName;
					break;
				}
			}
			Send(rpc, "A|" + complete.Id + "|" + complete.Received);
			try
			{
				deliver(complete, arg, delegate(RelayOutcome outcome)
				{
					complete.Dispose();
					if (!disposed && origin == session && delivery == complete)
					{
						delivering = false;
						deliveryPeer = null;
						delivery = null;
						if (registered.Contains(rpc))
						{
							ZRpc rpc2 = rpc;
							string id = complete.Id;
							int num2 = (int)outcome;
							Send(rpc2, "R|" + id + "|" + num2);
						}
					}
				});
			}
			catch
			{
				complete.Dispose();
				delivering = false;
				deliveryPeer = null;
				delivery = null;
				Send(rpc, "R|" + complete.Id + "|0");
			}
		}

		private void ReceiveClient(string[] p)
		{
			if (outgoingSize == 0 || p.Length != 3)
			{
				return;
			}
			int result;
			if (p[0] == "L" && waitingResult && acknowledged == outgoingSize && MomentGallery.ValidLink(p[2]))
			{
				LastMessageLink = p[2];
			}
			else if (p[0] == "W" && (awaitingOffer || waitingResult))
			{
				outgoingDeadline = now + 30.0;
			}
			else if (p[0] == "R")
			{
				if (p[2] == "1")
				{
					if (!waitingResult || acknowledged != outgoingSize)
					{
						return;
					}
					if (!keepOutgoing)
					{
						string file = outgoingFile;
						cleanup = Task.Run(delegate
						{
							try
							{
								File.Delete(file);
								return "Host uploaded clip to Discord; local copy removed.";
							}
							catch
							{
								return "Host uploaded clip to Discord; local copy could not be removed.";
							}
						});
						EndOutgoing("Host uploaded clip to Discord; removing local copy.", RelayOutcome.Uploaded);
					}
					else
					{
						EndOutgoing("Host uploaded clip to Discord; local copy retained.", RelayOutcome.Uploaded);
					}
				}
				else if (p[2] == "0")
				{
					EndOutgoing("Host declined or could not deliver clip; local copy retained.");
				}
				else if (p[2] == "2")
				{
					EndOutgoing("Host omitted this perspective; local copy retained.", RelayOutcome.Omitted);
				}
				else if (p[2] == "3" && waitingResult)
				{
					EndOutgoing("Delivery unknown; check Discord before retrying. Local clip retained.", RelayOutcome.Unknown);
				}
			}
			else if (!(p[0] != "A") && int.TryParse(p[2], out result) && result == sent)
			{
				acknowledged = result;
				awaitingOffer = false;
				if (sent == outgoingSize)
				{
					waitingResult = true;
					outgoingDeadline = now + 90.0;
				}
				else
				{
					outgoingDeadline = now + 30.0;
				}
			}
		}

		private static void Send(ZRpc rpc, string packet)
		{
			rpc.Invoke("ValheimMoments_ClipRelay_v2", new object[1] { packet });
		}

		private void RejectIncoming()
		{
			if (source != null && waiting.TryGetValue(source, out var value) && value.File == incoming)
			{
				FinishWaiting(value, RelayOutcome.Failed);
				return;
			}
			if (source != null && source.IsConnected() && incoming != null)
			{
				Send(source, "R|" + incoming.Id + "|0");
			}
			incoming?.Dispose();
			incoming = null;
			source = null;
		}

		private bool IsWaiting(Waiting entry)
		{
			if (!disposed && session == entry.Origin && waiting.TryGetValue(entry.Peer, out var value) && value == entry && registered.Contains(entry.Peer))
			{
				return entry.Peer.IsConnected();
			}
			return false;
		}

		private void FinishWaiting(Waiting entry, RelayOutcome outcome, bool abandoned = false)
		{
			if (IsWaiting(entry))
			{
				ZRpc peer = entry.Peer;
				string id = entry.File.Id;
				int num = (int)outcome;
				Send(peer, "R|" + id + "|" + num);
			}
			if (waiting.TryGetValue(entry.Peer, out var value) && value == entry)
			{
				waiting.Remove(entry.Peer);
			}
			if (incoming == entry.File)
			{
				incoming = null;
				source = null;
			}
			Action<string> ready = entry.Ready;
			entry.Ready = null;
			ready?.Invoke(null);
			if (!abandoned || !entry.File.Complete)
			{
				entry.File.Dispose();
			}
		}

		internal void StopSending()
		{
			if (target != null)
			{
				EndInterrupted("Client relay disabled; local clip retained.");
			}
		}

		private void EndInterrupted(string reason)
		{
			bool flag = outgoingSize > 0 && sent == outgoingSize;
			EndOutgoing(reason + (flag ? " Delivery unknown; check Discord before retrying." : ""), flag ? RelayOutcome.Unknown : RelayOutcome.Failed);
		}

		private void EndOutgoing(string reason, RelayOutcome outcome = RelayOutcome.Failed)
		{
			Action<RelayOutcome> action = outgoingCompletion;
			outgoingCompletion = null;
			outgoingSize = 0;
			reading = null;
			target = null;
			outgoingId = null;
			outgoingFile = null;
			log(reason);
			try
			{
				action?.Invoke(outcome);
			}
			catch
			{
				log("Clip completion observer unavailable.");
			}
		}

		private void Reset()
		{
			if (target != null)
			{
				EndInterrupted("Session changed; local clip retained.");
			}
			foreach (Waiting item in new List<Waiting>(waiting.Values))
			{
				FinishWaiting(item, RelayOutcome.Failed, abandoned: true);
			}
			waiting.Clear();
			peerIds.Clear();
			nextPeerId = 0L;
			incoming?.Dispose();
			incoming = null;
			source = null;
			delivering = false;
			deliveryPeer = null;
			delivery = null;
			registered.Clear();
			nextOffer.Clear();
		}

		public void Dispose()
		{
			disposed = true;
			Reset();
			session = null;
		}
	}
	internal sealed class ConfigurationMigration
	{
		private readonly Dictionary<string, string> values = new Dictionary<string, string>();

		internal bool SaveLocalCopy => Flag("Discord/SaveLocalCopy", fallback: false);

		internal bool CustomSize
		{
			get
			{
				if (!values.ContainsKey("Capture/Width"))
				{
					return values.ContainsKey("Capture/Height");
				}
				return true;
			}
		}

		internal BossCaptureMode BossMode
		{
			get
			{
				if (!values.ContainsKey("Boss Kill/FirstKillOnly") && !values.ContainsKey("Boss Kill/OnlyCaptureIfLootMeetsRarity"))
				{
					return BossCaptureMode.FirstKillThenRarity;
				}
				bool num = Flag("Boss Kill/FirstKillOnly", fallback: false);
				bool flag = Flag("Boss Kill/OnlyCaptureIfLootMeetsRarity", fallback: false);
				bool flag2 = Flag("Boss Kill/FirstKillBypassesRarity", fallback: true);
				if (num)
				{
					if (!flag || flag2)
					{
						return BossCaptureMode.FirstKillOnly;
					}
					return BossCaptureMode.FirstKillWithRarity;
				}
				if (flag)
				{
					if (!flag2)
					{
						return BossCaptureMode.RarityOnly;
					}
					return BossCaptureMode.FirstKillThenRarity;
				}
				return BossCaptureMode.AllKills;
			}
		}

		internal ConfigurationMigration(string path)
		{
			if (!File.Exists(path))
			{
				return;
			}
			string text = "";
			string[] array = File.ReadAllLines(path);
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.StartsWith("#") || text2.Length == 0)
				{
					continue;
				}
				if (text2.StartsWith("[") && text2.EndsWith("]"))
				{
					text = text2.Substring(1, text2.Length - 2);
					continue;
				}
				int num = text2.IndexOf('=');
				if (num >= 1)
				{
					string text3 = text + "/" + text2.Substring(0, num).Trim();
					switch (text3)
					{
					case "Discord/SaveLocalCopy":
					case "Capture/Width":
					case "Capture/Height":
					case "Boss Kill/FirstKillOnly":
					case "Boss Kill/OnlyCaptureIfLootMeetsRarity":
					case "Boss Kill/FirstKillBypassesRarity":
						values[text3] = text2.Substring(num + 1).Trim();
						break;
					}
				}
			}
		}

		private bool Flag(string key, bool fallback)
		{
			if (!values.TryGetValue(key, out var value) || !bool.TryParse(value, out var result))
			{
				return fallback;
			}
			return result;
		}

		internal static void Retire(ConfigFile file)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			bool saveOnConfigSet = file.SaveOnConfigSet;
			file.SaveOnConfigSet = false;
			try
			{
				string[] array = new string[7] { "Discord/SaveLocalCopy", "Discord/UploadClips", "Discord/EnableClientRelay", "Boss Kill/FirstKillOnly", "Boss Kill/OnlyCaptureIfLootMeetsRarity", "Boss Kill/FirstKillBypassesRarity", "Special Enemies/FirstKillOnly" };
				for (int i = 0; i < array.Length; i++)
				{
					string[] array2 = array[i].Split('/');
					file.Bind<bool>(array2[0], array2[1], false, "Retired setting");
					file.Remove(new ConfigDefinition(array2[0], array2[1]));
				}
				file.Bind<string>("Player Death", "PlayerNameOverride", "", "Retired setting");
				file.Remove(new ConfigDefinition("Player Death", "PlayerNameOverride"));
				file.Save();
			}
			finally
			{
				file.SaveOnConfigSet = saveOnConfigSet;
			}
		}
	}
	internal enum BossCaptureMode
	{
		AllKills,
		FirstKillOnly,
		RarityOnly,
		FirstKillThenRarity,
		FirstKillWithRarity
	}
	internal static class BossCaptureRules
	{
		internal static bool FirstOnly(BossCaptureMode mode)
		{
			if (mode != BossCaptureMode.FirstKillOnly)
			{
				return mode == BossCaptureMode.FirstKillWithRarity;
			}
			return true;
		}

		internal static bool UsesRarity(BossCaptureMode mode)
		{
			if (mode != BossCaptureMode.RarityOnly && mode != BossCaptureMode.FirstKillThenRarity)
			{
				return mode == BossCaptureMode.FirstKillWithRarity;
			}
			return true;
		}

		internal static bool FirstBypasses(BossCaptureMode mode)
		{
			return mode == BossCaptureMode.FirstKillThenRarity;
		}
	}
	internal static class DeathCause
	{
		private static readonly FieldInfo LastHit = typeof(Character).GetField("m_lastHit", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static string Read(Player player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				object? obj = LastHit?.GetValue(player);
				HitData val = (HitData)((obj is HitData) ? obj : null);
				if (val == null)
				{
					return "unknown cause";
				}
				if ((int)val.m_hitType == 1 || (int)val.m_hitType == 2 || (int)val.m_hitType == 0)
				{
					Character attacker = val.GetAttacker();
					if ((Object)(object)attacker != (Object)null)
					{
						string hoverName = attacker.GetHoverName();
						if (!string.IsNullOrWhiteSpace(hoverName))
						{
							return hoverName;
						}
					}
				}
				return Label(val.m_hitType);
			}
			catch
			{
				return "unknown cause";
			}
		}

		internal static string Label(HitType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected I4, but got Unknown
			return (type - 1) switch
			{
				0 => "an enemy (attacker unavailable)", 
				1 => "another player (attacker unavailable)", 
				2 => "fall damage", 
				3 => "drowning", 
				4 => "burning", 
				5 => "freezing", 
				6 => "poison", 
				7 => "water damage", 
				8 => "smoke inhalation", 
				9 => "the edge of the world", 
				10 => "an impact", 
				11 => "a cart", 
				12 => "a falling tree", 
				13 => "self-inflicted damage", 
				14 => "structural damage", 
				15 => "a turret", 
				16 => "a boat", 
				17 => "a falling stalactite", 
				18 => "a catapult", 
				19 => "cinder fire", 
				20 => "the Ashlands ocean", 
				21 => "Ashlands lava", 
				22 => "an incinerator", 
				23 => "a drawbridge", 
				_ => "unknown cause", 
			};
		}
	}
	internal sealed class MomentRateLimit
	{
		private readonly Queue<double> captures = new Queue<double>();

		internal bool TryTake(double now, int maximum, double window)
		{
			if (double.IsNaN(now) || double.IsInfinity(now))
			{
				return false;
			}
			maximum = Math.Max(1, Math.Min(20, maximum));
			window = ((double.IsNaN(window) || double.IsInfinity(window)) ? 60.0 : Math.Max(1.0, Math.Min(3600.0, window)));
			while (captures.Count > 0 && captures.Peek() <= now - window)
			{
				captures.Dequeue();
			}
			if (captures.Count >= maximum)
			{
				return false;
			}
			captures.Enqueue(now);
			return true;
		}

		internal void Clear()
		{
			captures.Clear();
		}
	}
	internal sealed class DeathMoments
	{
		internal sealed class Ticket
		{
			internal long Number;

			internal long Additional;

			internal int Epoch;
		}

		private long observed;

		private long shared;

		private Ticket pending;

		private int epoch;

		private readonly MomentRateLimit quota = new MomentRateLimit();

		internal void Observe()
		{
			if (observed < long.MaxValue)
			{
				observed++;
			}
		}

		internal Ticket Reserve()
		{
			if (pending != null || observed <= shared)
			{
				return null;
			}
			pending = new Ticket
			{
				Number = observed,
				Additional = Math.Max(0L, observed - shared - 1),
				Epoch = epoch
			};
			return pending;
		}

		internal bool TakeSlot(double now, int maximum, double window)
		{
			return quota.TryTake(now, maximum, window);
		}

		internal void Complete(Ticket ticket, bool delivered)
		{
			if (ticket != null && ticket == pending)
			{
				if (delivered)
				{
					shared = Math.Max(shared, ticket.Number);
				}
				pending = null;
			}
		}

		internal bool Reopen(Ticket ticket)
		{
			if (ticket == null || pending != null || ticket.Epoch != epoch || ticket.Number <= shared || ticket.Number > observed)
			{
				return false;
			}
			pending = ticket;
			return true;
		}

		internal void Clear()
		{
			observed = (shared = 0L);
			pending = null;
			quota.Clear();
			epoch++;
		}
	}
	internal sealed class DeathFlavor
	{
		internal static readonly string[] Lines = new string[20]
		{
			"A tactical donation to the local gravestone collection.", "The corpse run has acquired a sequel.", "Confidence: legendary. Survival: common.", "An ambitious approach to becoming a landmark.", "Valhalla put you on hold.", "Your equipment awaits your return. Again.", "The bees are happy. You are not.", "That was almost a plan.", "An unexpected appointment with the respawn screen.", "A bold strategy with a very short conclusion.",
			"Your inventory has become a destination.", "Adventure has requested a brief intermission.", "The saga takes an inconvenient turn.", "Another chapter for the cautionary tale.", "The adventure continues. Slightly less clothed.", "A memorable contribution to local history.", "You found the difficulty setting.", "This shortcut includes a respawn.", "The gravestone business is booming.", "Odin saw that. Unfortunately."
		};

		private int previous = -1;

		internal string Next(Random random)
		{
			int num = random.Next((previous < 0) ? Lines.Length : (Lines.Length - 1));
			if (previous >= 0 && num >= previous)
			{
				num++;
			}
			previous = num;
			return Lines[num];
		}
	}
	internal static class DiscordMentionText
	{
		internal static bool ValidId(string id)
		{
			if (id != null && id.Length >= 17 && id.Length <= 20 && Regex.IsMatch(id, "^[0-9]+$") && ulong.TryParse(id, NumberStyles.None, CultureInfo.InvariantCulture, out var result))
			{
				return result != 0;
			}
			return false;
		}

		internal static string Name(string name)
		{
			string text = (name ?? "").Replace("\r", " ").Replace("\n", " ").Replace("*", "")
				.Replace("`", "")
				.Trim();
			if (text.Length > 80)
			{
				return text.Substring(0, char.IsHighSurrogate(text[79]) ? 79 : 80);
			}
			return text;
		}

		internal static string Format(string message, IDictionary<string, string> identities, out string[] allowed)
		{
			HashSet<string> users = new HashSet<string>(StringComparer.Ordinal);
			string input = Regex.Replace(message ?? "", "<@!?([0-9]+)>", "@$1");
			input = Regex.Replace(input, "(?m)(\\*\\*Recorded by:\\*\\*|\\*\\*Kill credit:\\*\\*|^Kill credit:)[ \\t]*([^\\r\\n]*)", delegate(Match match)
			{
				string[] array = ((match.Groups[1].Value.IndexOf("Kill credit", StringComparison.Ordinal) >= 0) ? match.Groups[2].Value.Split(new string[1] { ", " }, StringSplitOptions.None) : new string[1] { match.Groups[2].Value });
				for (int i = 0; i < array.Length; i++)
				{
					string text = "";
					string text2 = array[i];
					string[] array2 = new string[2] { " (full list unavailable)", " (first kill for this character)" };
					foreach (string text3 in array2)
					{
						if (text2.EndsWith(text3, StringComparison.Ordinal))
						{
							text = text3;
							text2 = text2.Substring(0, text2.Length - text3.Length);
							break;
						}
					}
					if (identities.TryGetValue(text2, out var value) && ValidId(value))
					{
						array[i] = text2 + " (<@" + value + ">)" + text;
						users.Add(value);
					}
				}
				return match.Groups[1].Value + " " + string.Join(", ", array);
			});
			if (input.Length > 2000)
			{
				input = input.Substring(0, char.IsHighSurrogate(input[1999]) ? 1999 : 2000);
			}
			List<string> list = new List<string>();
			foreach (string item in users)
			{
				if (input.Contains("<@" + item + ">"))
				{
					list.Add(item);
				}
			}
			allowed = list.ToArray();
			return input;
		}
	}
	internal sealed class DiscordIdentity
	{
		private const string Rpc = "ValheimMoments_DiscordIdentity_v1";

		private readonly HashSet<ZRpc> registered = new HashSet<ZRpc>();

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

		private ZNet session;

		private double nextSend;

		private string localId;

		private string localName;

		internal void Tick(double now, string id, string name)
		{
			if (session != ZNet.instance)
			{
				session = ZNet.instance;
				registered.Clear();
				identities.Clear();
				nextSend = 0.0;
			}
			localId = (DiscordMentionText.ValidId(id) ? id : "");
			localName = name;
			if ((Object)(object)session == (Object)null)
			{
				return;
			}
			HashSet<ZRpc> live = new HashSet<ZRpc>();
			foreach (ZNetPeer peer in session.GetPeers())
			{
				if (peer.IsReady() && peer.m_rpc.IsConnected())
				{
					live.Add(peer.m_rpc);
					if (registered.Add(peer.m_rpc))
					{
						peer.m_rpc.Register<string>("ValheimMoments_DiscordIdentity_v1", (Action<ZRpc, string>)Receive);
					}
				}
			}
			registered.RemoveWhere((ZRpc peer) => !live.Contains(peer));
			List<ZRpc> list = new List<ZRpc>();
			foreach (ZRpc key in identities.Keys)
			{
				if (!live.Contains(key))
				{
					list.Add(key);
				}
			}
			foreach (ZRpc item in list)
			{
				identities.Remove(item);
			}
			if (!session.IsServer() && now >= nextSend)
			{
				ZNetPeer serverPeer = session.GetServerPeer();
				if (serverPeer != null && live.Contains(serverPeer.m_rpc))
				{
					serverPeer.m_rpc.Invoke("ValheimMoments_DiscordIdentity_v1", new object[1] { localId });
					nextSend = now + 2.0;
				}
			}
		}

		private void Receive(ZRpc rpc, string id)
		{
			if (!((Object)(object)session == (Object)null) && session == ZNet.instance && session.IsServer() && registered.Contains(rpc) && rpc.IsConnected())
			{
				if (string.IsNullOrEmpty(id))
				{
					identities.Remove(rpc);
				}
				else if (DiscordMentionText.ValidId(id))
				{
					identities[rpc] = id;
				}
			}
		}

		internal void Apply(DiscordOptions options)
		{
			Dictionary<string, string> map = new Dictionary<string, string>(StringComparer.Ordinal);
			HashSet<string> duplicates = new HashSet<string>(StringComparer.Ordinal);
			Action<string, string> action = delegate(string name, string id)
			{
				name = DiscordMentionText.Name(name);
				if (name.Length != 0 && !name.Contains(",") && !name.Contains("<") && !name.Contains(">"))
				{
					if (map.ContainsKey(name))
					{
						duplicates.Add(name);
					}
					else
					{
						map.Add(name, id ?? "");
					}
				}
			};
			action(localName, localId);
			if ((Object)(object)session != (Object)null && session == ZNet.instance && session.IsServer())
			{
				foreach (ZNetPeer peer in session.GetPeers())
				{
					if (peer.IsReady() && peer.m_rpc.IsConnected())
					{
						identities.TryGetValue(peer.m_rpc, out var value);
						action(peer.m_playerName, value);
					}
				}
			}
			foreach (string item in duplicates)
			{
				map.Remove(item);
			}
			options.Message = DiscordMentionText.Format(options.Message, map, out options.MentionUsers);
		}
	}
	internal static class DiscordRouting
	{
		internal static bool CanSubmit(object capturedSession, bool capturedAsHost, object currentSession, bool currentlyHost)
		{
			if (capturedSession != null && capturedAsHost && currentlyHost)
			{
				return capturedSession == currentSession;
			}
			return false;
		}

		internal static string Destination(string kind, string fallback, bool bossOverride, string boss, bool lootOverride, string loot, bool deathOverride, string death, string discovery = null)
		{
			if (kind == "discovery" && !string.IsNullOrWhiteSpace(discovery))
			{
				return discovery;
			}
			if (kind == "boss" && bossOverride)
			{
				return boss;
			}
			if (kind == "loot" && lootOverride)
			{
				return loot;
			}
			if (kind == "death" && deathOverride)
			{
				return death;
			}
			return fallback;
		}
	}
	internal sealed class DiscordClip
	{
		internal readonly string File;

		internal readonly string Recorder;

		internal readonly bool Keep;

		internal DiscordClip(string file, string recorder, bool keep)
		{
			File = file;
			Recorder = recorder;
			Keep = keep;
		}
	}
	internal sealed class DiscordOptions
	{
		internal string WebhookUrl;

		internal string Username;

		internal string[] MentionUsers = new string[0];

		internal string Message = "Valheim moment";

		internal bool SaveLocalCopy;

		internal long MaxUploadBytes = 10485760L;
	}
	internal sealed class UploadResult
	{
		internal bool Success;

		internal string Message;

		internal string MessageId;

		internal string ChannelId;

		internal string GuildId