using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.RegularExpressions;
using Agents;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using ExtraObjectiveSetup;
using ExtraObjectiveSetup.BaseClasses;
using ExtraObjectiveSetup.ExtendedWardenEvents;
using ExtraObjectiveSetup.JSON;
using FloLib.Networks.Replications;
using GTFO.API;
using GTFO.API.Utilities;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppSystem.Collections.Generic;
using MTFO.API;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("AddEvents")]
[assembly: AssemblyProduct("AddEvents")]
[assembly: AssemblyFileVersion("1.1.3.0")]
[assembly: AssemblyInformationalVersion("1.1.3")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.3.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace AddEvents
{
	internal static class LaserRoomConfigResolver
	{
		internal static bool TryResolveMainLevelLayoutForExternalConfig(JsonElement element, out uint mainLevelLayout, out string resolvedBy)
		{
			mainLevelLayout = 0u;
			resolvedBy = string.Empty;
			try
			{
				if (element.ValueKind == JsonValueKind.Number && element.TryGetUInt32(out var value))
				{
					mainLevelLayout = value;
					resolvedBy = "numeric";
					return value != 0;
				}
				if (element.ValueKind != JsonValueKind.String)
				{
					return false;
				}
				string text = element.GetString()?.Trim() ?? string.Empty;
				if (string.IsNullOrWhiteSpace(text))
				{
					return false;
				}
				if (uint.TryParse(text, out var result))
				{
					mainLevelLayout = result;
					resolvedBy = "numeric string";
					return result != 0;
				}
				if (MTFOPartialDataIdResolver.TryResolve(text, out var id) && id != 0)
				{
					mainLevelLayout = id;
					resolvedBy = "MTFO PartialData:" + text;
					return true;
				}
				if (GameDataBlockBase<LevelLayoutDataBlock>.HasBlock(text))
				{
					uint blockID = GameDataBlockBase<LevelLayoutDataBlock>.GetBlockID(text);
					if (blockID != 0)
					{
						mainLevelLayout = blockID;
						resolvedBy = "LevelLayoutDataBlock:" + text;
						return true;
					}
				}
			}
			catch (Exception ex)
			{
				AddEventsRuntime.LogThrottled("LaserRoom MainLevelLayout resolver failed: " + ex.Message);
			}
			return false;
		}
	}
	internal static class MTFOPartialDataIdResolver
	{
		private const string PartialDataPluginGuid = "MTFO.Extension.PartialBlocks";

		private const string IdFileName = "_persistentID.json";

		private static readonly object Sync = new object();

		private static Dictionary<string, uint>? _guidToId;

		private static bool _loadAttempted;

		internal static bool TryResolve(string guid, out uint id)
		{
			id = 0u;
			if (string.IsNullOrWhiteSpace(guid))
			{
				return false;
			}
			EnsureLoaded();
			lock (Sync)
			{
				return _guidToId != null && _guidToId.TryGetValue(guid.Trim(), out id);
			}
		}

		private static void EnsureLoaded()
		{
			lock (Sync)
			{
				if (_loadAttempted)
				{
					return;
				}
				_loadAttempted = true;
				try
				{
					string text = TryGetPartialDataPathFromPlugin();
					if (string.IsNullOrWhiteSpace(text))
					{
						return;
					}
					string text2 = Path.Combine(text, "_persistentID.json");
					if (File.Exists(text2))
					{
						Dictionary<string, uint> dictionary = ReadPersistentIdFile(text2);
						if (dictionary.Count > 0)
						{
							_guidToId = dictionary;
						}
					}
				}
				catch (Exception ex)
				{
					AddEventsRuntime.LogThrottled("MTFO PartialData persistentID resolver failed: " + ex.Message);
				}
			}
		}

		private static string TryGetPartialDataPathFromPlugin()
		{
			try
			{
				if (((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.TryGetValue("MTFO.Extension.PartialBlocks", out var value))
				{
					Assembly assembly = ((value == null) ? null : value.Instance?.GetType()?.Assembly);
					if (assembly != null && (assembly.GetTypes().FirstOrDefault((Type t) => string.Equals(t.Name, "PartialDataManager", StringComparison.Ordinal))?.GetProperty("PartialDataPath", BindingFlags.Static | BindingFlags.Public))?.GetValue(null) is string text && !string.IsNullOrWhiteSpace(text))
					{
						return text;
					}
				}
			}
			catch
			{
			}
			return DiscoverPartialDataPathFromFileSystem();
		}

		private static string DiscoverPartialDataPathFromFileSystem()
		{
			try
			{
				foreach (string item in Directory.EnumerateFiles(Paths.PluginPath, "_persistentID.json", SearchOption.AllDirectories))
				{
					string directoryName = Path.GetDirectoryName(item);
					if (!string.IsNullOrWhiteSpace(directoryName))
					{
						return directoryName;
					}
				}
			}
			catch
			{
			}
			return string.Empty;
		}

		private static Dictionary<string, uint> ReadPersistentIdFile(string idFilePath)
		{
			Dictionary<string, uint> dictionary = new Dictionary<string, uint>(StringComparer.OrdinalIgnoreCase);
			string text = File.ReadAllText(idFilePath);
			try
			{
				using JsonDocument jsonDocument = JsonDocument.Parse(text, new JsonDocumentOptions
				{
					CommentHandling = JsonCommentHandling.Skip,
					AllowTrailingCommas = true
				});
				if (jsonDocument.RootElement.ValueKind == JsonValueKind.Array)
				{
					foreach (JsonElement item in jsonDocument.RootElement.EnumerateArray())
					{
						if (TryReadGuidEntry(item, out string guid, out uint id))
						{
							dictionary[guid] = id;
						}
					}
				}
				else if (jsonDocument.RootElement.ValueKind == JsonValueKind.Object)
				{
					foreach (JsonProperty item2 in jsonDocument.RootElement.EnumerateObject())
					{
						if (TryReadUIntElement(item2.Value, out var id2) && !string.IsNullOrWhiteSpace(item2.Name))
						{
							dictionary[item2.Name.Trim()] = id2;
						}
					}
				}
			}
			catch
			{
				foreach (Match item3 in Regex.Matches(text, "\\{[^{}]*\\\"GUID\\\"\\s*:\\s*\\\"(?<guid>(?:\\\\.|[^\\\"])*)\\\"[^{}]*\\\"ID\\\"\\s*:\\s*(?<id>\\d+)[^{}]*\\}", RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.CultureInvariant))
				{
					string text2 = Regex.Unescape(item3.Groups["guid"].Value).Trim();
					if (!string.IsNullOrWhiteSpace(text2) && uint.TryParse(item3.Groups["id"].Value, out var result))
					{
						dictionary[text2] = result;
					}
				}
			}
			return dictionary;
		}

		private static bool TryReadGuidEntry(JsonElement entry, out string guid, out uint id)
		{
			guid = string.Empty;
			id = 0u;
			if (entry.ValueKind != JsonValueKind.Object)
			{
				return false;
			}
			foreach (JsonProperty item in entry.EnumerateObject())
			{
				if (string.Equals(item.Name, "GUID", StringComparison.OrdinalIgnoreCase) || string.Equals(item.Name, "Guid", StringComparison.OrdinalIgnoreCase) || string.Equals(item.Name, "persistentID", StringComparison.OrdinalIgnoreCase))
				{
					guid = ((item.Value.ValueKind == JsonValueKind.String) ? (item.Value.GetString() ?? string.Empty).Trim() : item.Value.ToString().Trim());
				}
				else if (string.Equals(item.Name, "ID", StringComparison.OrdinalIgnoreCase) || string.Equals(item.Name, "Id", StringComparison.OrdinalIgnoreCase))
				{
					TryReadUIntElement(item.Value, out id);
				}
			}
			if (!string.IsNullOrWhiteSpace(guid))
			{
				return id != 0;
			}
			return false;
		}

		private static bool TryReadUIntElement(JsonElement element, out uint id)
		{
			id = 0u;
			if (element.ValueKind == JsonValueKind.Number && element.TryGetUInt32(out var value))
			{
				id = value;
				return true;
			}
			if (element.ValueKind == JsonValueKind.String && uint.TryParse(element.GetString(), out var result))
			{
				id = result;
				return true;
			}
			return false;
		}
	}
	internal sealed class AddEventsType2004EventData
	{
		internal int Count { get; set; }

		internal bool Enabled { get; set; } = true;

		internal bool HasEnabled { get; set; }

		internal Vector3 Position { get; set; }

		internal bool HasPosition { get; set; }

		internal float FogTransitionDuration { get; set; }

		internal bool HasFogTransitionDuration { get; set; }

		internal List<WardenObjectiveEventData> Events { get; set; } = new List<WardenObjectiveEventData>();
	}
	internal readonly struct AddEventsType2004Signature : IEquatable<AddEventsType2004Signature>
	{
		private readonly int _count;

		private readonly bool _enabled;

		private readonly int _radius1000;

		private readonly int _x1000;

		private readonly int _y1000;

		private readonly int _z1000;

		internal AddEventsType2004Signature(int count, bool enabled, float radius, Vector3 position)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			_count = count;
			_enabled = enabled;
			_radius1000 = Quantize(radius);
			_x1000 = Quantize(position.x);
			_y1000 = Quantize(position.y);
			_z1000 = Quantize(position.z);
		}

		internal static AddEventsType2004Signature FromEvent(WardenObjectiveEventData e)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return new AddEventsType2004Signature(e.Count, e.Enabled, e.FogTransitionDuration, e.Position);
		}

		public bool Equals(AddEventsType2004Signature other)
		{
			if (_count == other._count && _enabled == other._enabled && _radius1000 == other._radius1000 && _x1000 == other._x1000 && _y1000 == other._y1000)
			{
				return _z1000 == other._z1000;
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			if (obj is AddEventsType2004Signature other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(_count, _enabled, _radius1000, _x1000, _y1000, _z1000);
		}

		private static int Quantize(float value)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return 0;
			}
			return (int)Math.Round(value * 1000f);
		}
	}
	internal static class AddEventsType2004SidecarStore
	{
		private static readonly Dictionary<IntPtr, AddEventsType2004EventData> ByEventPointer = new Dictionary<IntPtr, AddEventsType2004EventData>();

		private static readonly Dictionary<AddEventsType2004Signature, List<AddEventsType2004EventData>> ByLooseSignature = new Dictionary<AddEventsType2004Signature, List<AddEventsType2004EventData>>();

		private static readonly List<AddEventsType2004EventData> LooseFallback = new List<AddEventsType2004EventData>();

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

		private static readonly HashSet<AddEventsType2004Signature> AmbiguousWarningPrinted = new HashSet<AddEventsType2004Signature>();

		private static bool _isDeserializingSidecarEvents;

		private static bool _diskScanned;

		internal static bool TryGet(WardenObjectiveEventData eventData, out AddEventsType2004EventData data)
		{
			if (eventData != null && ByEventPointer.TryGetValue(((Il2CppObjectBase)eventData).Pointer, out data))
			{
				return true;
			}
			if (eventData != null)
			{
				AddEventsType2004Signature addEventsType2004Signature = AddEventsType2004Signature.FromEvent(eventData);
				if (ByLooseSignature.TryGetValue(addEventsType2004Signature, out List<AddEventsType2004EventData> value) && value.Count > 0)
				{
					data = value[0];
					if (value.Count > 1 && AmbiguousWarningPrinted.Add(addEventsType2004Signature))
					{
						ManualLogSource? log = AddEventsRuntime.Log;
						if (log != null)
						{
							log.LogWarning((object)"AddEvents Type 2004 sidecar fallback matched multiple definitions with the same vanilla signature. Using the first match. Make Count/Position/FogTransitionDuration/Enabled unique if this is not intended.");
						}
					}
					ByEventPointer[((Il2CppObjectBase)eventData).Pointer] = data;
					return true;
				}
			}
			if (LooseFallback.Count == 1)
			{
				data = LooseFallback[0];
				if (eventData != null)
				{
					ByEventPointer[((Il2CppObjectBase)eventData).Pointer] = data;
				}
				return true;
			}
			data = null;
			return false;
		}

		internal static void ScanDiskForDefinitions()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			if (_diskScanned)
			{
				return;
			}
			_diskScanned = true;
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			bool flag = default(bool);
			ManualLogSource log;
			try
			{
				foreach (string item in EnumerateCandidateJsonFiles())
				{
					num++;
					string text;
					try
					{
						text = File.ReadAllText(item);
					}
					catch
					{
						continue;
					}
					if (text.IndexOf("2004", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						List<AddEventsType2004EventData> list = ParseType2004Nodes(text);
						if (list.Count != 0)
						{
							num2++;
							num3 += list.Count;
							RegisterLoose(list);
						}
					}
				}
			}
			catch (Exception ex)
			{
				log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(48, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2004 disk sidecar scan failed: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					log.LogWarning(val);
				}
			}
			if (num3 > 0)
			{
				log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExMessageLogInterpolatedStringHandler val2 = new BepInExMessageLogInterpolatedStringHandler(96, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("AddEvents Type 2004 disk sidecar scan complete. FilesScanned=");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", FilesWithType2004=");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num2);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", Definitions=");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num3);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(".");
					}
					log.LogMessage(val2);
				}
				return;
			}
			log = AddEventsRuntime.Log;
			if (log != null)
			{
				BepInExDebugLogInterpolatedStringHandler val3 = new BepInExDebugLogInterpolatedStringHandler(77, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("AddEvents Type 2004 disk sidecar scan complete. FilesScanned=");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(", Definitions=0.");
				}
				log.LogDebug(val3);
			}
		}

		internal static void Capture(string json, object? result)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Invalid comparison between Unknown and I4
			if (_isDeserializingSidecarEvents || string.IsNullOrWhiteSpace(json) || json.IndexOf("2004", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return;
			}
			List<AddEventsType2004EventData> list = ParseType2004Nodes(json);
			if (list.Count == 0)
			{
				return;
			}
			RegisterLoose(list);
			if (result == null)
			{
				return;
			}
			List<WardenObjectiveEventData> list2 = new List<WardenObjectiveEventData>();
			CollectEvents(result, list2, new HashSet<object>(ReferenceEqualityComparer.Instance), 0);
			if (list2.Count == 0)
			{
				return;
			}
			Dictionary<AddEventsType2004Signature, Queue<AddEventsType2004EventData>> dictionary = new Dictionary<AddEventsType2004Signature, Queue<AddEventsType2004EventData>>();
			foreach (AddEventsType2004EventData item in list)
			{
				AddEventsType2004Signature key = new AddEventsType2004Signature(item.Count, item.Enabled, item.FogTransitionDuration, item.Position);
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = (dictionary[key] = new Queue<AddEventsType2004EventData>());
				}
				value.Enqueue(item);
			}
			Queue<AddEventsType2004EventData> queue2 = new Queue<AddEventsType2004EventData>(list);
			foreach (WardenObjectiveEventData item2 in list2)
			{
				if ((int)item2.Type == 2004)
				{
					AddEventsType2004EventData addEventsType2004EventData = null;
					AddEventsType2004Signature key2 = AddEventsType2004Signature.FromEvent(item2);
					if (dictionary.TryGetValue(key2, out var value2) && value2.Count > 0)
					{
						addEventsType2004EventData = value2.Dequeue();
					}
					else if (queue2.Count > 0)
					{
						addEventsType2004EventData = queue2.Dequeue();
					}
					if (addEventsType2004EventData != null)
					{
						ByEventPointer[((Il2CppObjectBase)item2).Pointer] = addEventsType2004EventData;
					}
				}
			}
		}

		private static void RegisterLoose(IEnumerable<AddEventsType2004EventData> parsed)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			foreach (AddEventsType2004EventData item in parsed)
			{
				string looseFingerprint = GetLooseFingerprint(item);
				if (RegisteredLooseFingerprints.Add(looseFingerprint))
				{
					AddEventsType2004Signature key = new AddEventsType2004Signature(item.Count, item.Enabled, item.FogTransitionDuration, item.Position);
					if (!ByLooseSignature.TryGetValue(key, out List<AddEventsType2004EventData> value))
					{
						value = new List<AddEventsType2004EventData>(1);
						ByLooseSignature[key] = value;
					}
					value.Add(item);
					LooseFallback.Add(item);
				}
			}
		}

		private static string GetLooseFingerprint(AddEventsType2004EventData data)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected I4, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			int num = 17;
			foreach (WardenObjectiveEventData @event in data.Events)
			{
				num = num * 31 + @event.Type;
				num = num * 31 + @event.Count;
				num = num * 31 + ((object)@event.LocalIndex/*cast due to .constrained prefix*/).GetHashCode();
				num = num * 31 + ((object)@event.Layer/*cast due to .constrained prefix*/).GetHashCode();
				num = num * 31 + ((object)@event.DimensionIndex/*cast due to .constrained prefix*/).GetHashCode();
				num = num * 31 + ((object)@event.Position/*cast due to .constrained prefix*/).GetHashCode();
				num = num * 31 + @event.FogTransitionDuration.GetHashCode();
			}
			return string.Join("|", data.Count, data.Enabled, data.FogTransitionDuration, data.Position.x, data.Position.y, data.Position.z, data.Events.Count, num);
		}

		private static IEnumerable<string> EnumerateCandidateJsonFiles()
		{
			HashSet<string> roots = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			AddRoot(Paths.PluginPath);
			AddRoot(Path.Combine(Paths.BepInExRootPath, "GameData"));
			AddRoot(Path.Combine(Paths.BepInExRootPath, "Custom"));
			foreach (string item in roots)
			{
				IEnumerable<string> enumerable;
				try
				{
					enumerable = Directory.EnumerateFiles(item, "*.json", SearchOption.AllDirectories).ToArray();
				}
				catch
				{
					continue;
				}
				foreach (string item2 in enumerable)
				{
					yield return item2;
				}
			}
			void AddRoot(string? root)
			{
				if (!string.IsNullOrWhiteSpace(root) && Directory.Exists(root))
				{
					roots.Add(Path.GetFullPath(root));
				}
			}
		}

		private static List<AddEventsType2004EventData> ParseType2004Nodes(string json)
		{
			List<AddEventsType2004EventData> list = new List<AddEventsType2004EventData>();
			try
			{
				JsonNode jsonNode = JsonNode.Parse(json, new JsonNodeOptions
				{
					PropertyNameCaseInsensitive = true
				}, new JsonDocumentOptions
				{
					AllowTrailingCommas = true,
					CommentHandling = JsonCommentHandling.Skip
				});
				if (jsonNode != null)
				{
					TraverseJson(jsonNode, list);
				}
			}
			catch
			{
			}
			return list;
		}

		private static void TraverseJson(JsonNode node, List<AddEventsType2004EventData> output)
		{
			if (node is JsonObject jsonObject)
			{
				if (IsType2004Object(jsonObject))
				{
					output.Add(ParseEventData(jsonObject));
				}
				{
					foreach (KeyValuePair<string, JsonNode> item in jsonObject)
					{
						if (item.Value != null)
						{
							TraverseJson(item.Value, output);
						}
					}
					return;
				}
			}
			if (!(node is JsonArray jsonArray))
			{
				return;
			}
			foreach (JsonNode item2 in jsonArray)
			{
				if (item2 != null)
				{
					TraverseJson(item2, output);
				}
			}
		}

		private static bool IsType2004Object(JsonObject obj)
		{
			if (!obj.TryGetPropertyValue("Type", out JsonNode jsonNode))
			{
				return false;
			}
			if (jsonNode is JsonValue jsonValue)
			{
				if (jsonValue.TryGetValue<int>(out var value))
				{
					return value == 2004;
				}
				if (jsonValue.TryGetValue<string>(out string value2))
				{
					if (!string.Equals(value2, "2004", StringComparison.OrdinalIgnoreCase))
					{
						return string.Equals(value2, "AddPlayersToDeathEventGroup", StringComparison.OrdinalIgnoreCase);
					}
					return true;
				}
			}
			return false;
		}

		private static AddEventsType2004EventData ParseEventData(JsonObject obj)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			JsonNode jsonNode;
			AddEventsType2004EventData addEventsType2004EventData = new AddEventsType2004EventData
			{
				Count = ReadInt(obj, "Count", 0),
				HasEnabled = obj.ContainsKey("Enabled"),
				Enabled = ReadBool(obj, "Enabled", fallback: true),
				HasPosition = obj.ContainsKey("Position"),
				Position = ReadVector3(obj.TryGetPropertyValue("Position", out jsonNode) ? jsonNode : null),
				HasFogTransitionDuration = obj.ContainsKey("FogTransitionDuration"),
				FogTransitionDuration = ReadFloat(obj, "FogTransitionDuration", 0f)
			};
			if (obj.TryGetPropertyValue("Events", out JsonNode jsonNode2) && jsonNode2 != null)
			{
				addEventsType2004EventData.Events = DeserializeEvents(jsonNode2.ToJsonString());
			}
			return addEventsType2004EventData;
		}

		private static List<WardenObjectiveEventData> DeserializeEvents(string json)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			try
			{
				_isDeserializingSidecarEvents = true;
				return EOSJson.Deserialize<List<WardenObjectiveEventData>>(json) ?? new List<WardenObjectiveEventData>();
			}
			catch (Exception ex)
			{
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(59, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2004 could not deserialize nested Events: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					log.LogWarning(val);
				}
				return new List<WardenObjectiveEventData>();
			}
			finally
			{
				_isDeserializingSidecarEvents = false;
			}
		}

		private static void CollectEvents(object obj, List<WardenObjectiveEventData> output, HashSet<object> visited, int depth)
		{
			if (obj == null || depth > 12 || !visited.Add(obj))
			{
				return;
			}
			WardenObjectiveEventData val = (WardenObjectiveEventData)((obj is WardenObjectiveEventData) ? obj : null);
			if (val != null)
			{
				output.Add(val);
				return;
			}
			if (obj is IEnumerable enumerable && !(obj is string))
			{
				foreach (object item in enumerable)
				{
					if (item != null)
					{
						CollectEvents(item, output, visited, depth + 1);
					}
				}
				return;
			}
			Type type = obj.GetType();
			if (type.IsPrimitive || type.IsEnum || type == typeof(string))
			{
				return;
			}
			PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.GetIndexParameters().Length != 0)
				{
					continue;
				}
				try
				{
					object value = propertyInfo.GetValue(obj);
					if (value != null)
					{
						CollectEvents(value, output, visited, depth + 1);
					}
				}
				catch
				{
				}
			}
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				try
				{
					object value2 = fieldInfo.GetValue(obj);
					if (value2 != null)
					{
						CollectEvents(value2, output, visited, depth + 1);
					}
				}
				catch
				{
				}
			}
		}

		private static int ReadInt(JsonObject node, string name, int fallback)
		{
			try
			{
				if (node.TryGetPropertyValue(name, out JsonNode jsonNode) && jsonNode is JsonValue jsonValue)
				{
					if (jsonValue.TryGetValue<int>(out var value))
					{
						return value;
					}
					if (jsonValue.TryGetValue<string>(out string value2) && int.TryParse(value2, out value))
					{
						return value;
					}
				}
			}
			catch
			{
			}
			return fallback;
		}

		private static float ReadFloat(JsonObject node, string name, float fallback)
		{
			try
			{
				if (node.TryGetPropertyValue(name, out JsonNode jsonNode) && jsonNode is JsonValue jsonValue)
				{
					if (jsonValue.TryGetValue<float>(out var value))
					{
						return value;
					}
					if (jsonValue.TryGetValue<double>(out var value2))
					{
						return (float)value2;
					}
					if (jsonValue.TryGetValue<string>(out string value3) && float.TryParse(value3, NumberStyles.Float, CultureInfo.InvariantCulture, out value))
					{
						return value;
					}
				}
			}
			catch
			{
			}
			return fallback;
		}

		private static bool ReadBool(JsonObject node, string name, bool fallback)
		{
			try
			{
				if (node.TryGetPropertyValue(name, out JsonNode jsonNode) && jsonNode is JsonValue jsonValue)
				{
					if (jsonValue.TryGetValue<bool>(out var value))
					{
						return value;
					}
					if (jsonValue.TryGetValue<string>(out string value2) && bool.TryParse(value2, out value))
					{
						return value;
					}
				}
			}
			catch
			{
			}
			return fallback;
		}

		private static Vector3 ReadVector3(JsonNode? node)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!(node is JsonObject node2))
			{
				return Vector3.zero;
			}
			return new Vector3(ReadFloat(node2, "x", 0f), ReadFloat(node2, "y", 0f), ReadFloat(node2, "z", 0f));
		}
	}
	internal static class AddEventsDeathEventGroupEvents
	{
		internal static void AddPlayersToDeathEventGroup(WardenObjectiveEventData eventData)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			if (!AddEventsNetworkEventProxy.EnsureHostExecution(AddEventsCustomEventType.AddPlayersToDeathEventGroup, eventData))
			{
				return;
			}
			if (!AddEventsType2004SidecarStore.TryGet(eventData, out AddEventsType2004EventData data))
			{
				data = new AddEventsType2004EventData
				{
					Count = eventData.Count,
					Enabled = eventData.Enabled,
					Position = eventData.Position,
					HasPosition = true,
					FogTransitionDuration = eventData.FogTransitionDuration,
					HasFogTransitionDuration = (eventData.FogTransitionDuration > 0f),
					Events = new List<WardenObjectiveEventData>()
				};
			}
			bool flag = default(bool);
			ManualLogSource log;
			if (!data.Enabled)
			{
				AddEventsDeathEventGroupManager.Current.SetGroupEnabled(data.Count, enabled: false);
				log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(60, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2004 death event group ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(data.Count);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" disabled and cleared.");
					}
					log.LogDebug(val);
				}
				return;
			}
			List<PlayerAgent> list = ResolvePlayers(eventData, data);
			int num = AddEventsDeathEventGroupManager.Current.AddPlayersToGroup(data.Count, list, data.Events);
			log = AddEventsRuntime.Log;
			if (log != null)
			{
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(67, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2004 death event group ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(data.Count);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": added ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("/");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(list.Count);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" player(s), Events=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(data.Events.Count);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
				}
				log.LogDebug(val);
			}
		}

		private static List<PlayerAgent> ResolvePlayers(WardenObjectiveEventData eventData, AddEventsType2004EventData data)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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)
			float num = (data.HasFogTransitionDuration ? data.FogTransitionDuration : eventData.FogTransitionDuration);
			Vector3 origin = (data.HasPosition ? data.Position : eventData.Position);
			if (num > 0f)
			{
				return GetPlayersInRadius(origin, num);
			}
			return GetAllPlayers();
		}

		private static List<PlayerAgent> GetPlayersInRadius(Vector3 origin, float radius)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			float num = radius * radius;
			List<PlayerAgent> list = new List<PlayerAgent>();
			Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
			while (enumerator.MoveNext())
			{
				PlayerAgent current = enumerator.Current;
				if (!((Object)(object)current == (Object)null) && ((Agent)current).Alive)
				{
					Vector3 val = ((Agent)current).Position - origin;
					if (((Vector3)(ref val)).sqrMagnitude <= num)
					{
						list.Add(current);
					}
				}
			}
			return list;
		}

		private static List<PlayerAgent> GetAllPlayers()
		{
			List<PlayerAgent> list = new List<PlayerAgent>();
			Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
			while (enumerator.MoveNext())
			{
				PlayerAgent current = enumerator.Current;
				if ((Object)(object)current != (Object)null && ((Agent)current).Alive)
				{
					list.Add(current);
				}
			}
			return list;
		}
	}
	public struct AddEventsDeathEventGroupReplicationState
	{
		public bool enabled;

		public bool checkP1;

		public bool checkP2;

		public bool checkP3;

		public bool checkP4;
	}
	internal sealed class AddEventsDeathEventGroup
	{
		internal const int MaxPlayers = 4;

		private readonly bool[] _slots = new bool[4];

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

		private StateReplicator<AddEventsDeathEventGroupReplicationState>? _stateReplicator;

		internal bool Enabled { get; private set; }

		internal List<WardenObjectiveEventData> Events { get; set; } = new List<WardenObjectiveEventData>();

		internal int Count
		{
			get
			{
				int num = 0;
				for (int i = 0; i < _slots.Length; i++)
				{
					if (_slots[i])
					{
						num++;
					}
				}
				return num;
			}
		}

		internal bool SetPlayerInGroup(int slot, bool inGroup)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (!IsValidPlayerSlot(slot))
			{
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(63, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2004 invalid player slot index ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(slot);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; expected [0, ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(4);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(").");
					}
					log.LogError(val);
				}
				return false;
			}
			if (_slots[slot] == inGroup)
			{
				return false;
			}
			int count = Count;
			_slots[slot] = inGroup;
			if (inGroup)
			{
				_lastDeathFrameBySlot.Remove(slot);
			}
			int count2 = Count;
			if (count == 0 && count2 > 0)
			{
				Enabled = true;
			}
			else if (count > 0 && count2 == 0)
			{
				Enabled = false;
			}
			Sync();
			return true;
		}

		internal void Toggle(bool enabled)
		{
			if (!enabled)
			{
				ClearAndDisable();
			}
			else if (!Enabled)
			{
				Enabled = true;
				Sync();
			}
		}

		internal void ClearAndDisable()
		{
			bool flag = Enabled || Count > 0 || Events.Count > 0 || _lastDeathFrameBySlot.Count > 0;
			Enabled = false;
			for (int i = 0; i < _slots.Length; i++)
			{
				_slots[i] = false;
			}
			_lastDeathFrameBySlot.Clear();
			Events = new List<WardenObjectiveEventData>();
			if (flag)
			{
				Sync();
			}
		}

		internal bool ContainsSlot(int slot)
		{
			if (IsValidPlayerSlot(slot))
			{
				return _slots[slot];
			}
			return false;
		}

		internal bool TryMarkDeathFrame(int slot, int frame)
		{
			if (_lastDeathFrameBySlot.TryGetValue(slot, out var value) && value == frame)
			{
				return false;
			}
			_lastDeathFrameBySlot[slot] = frame;
			return true;
		}

		internal void ResetSynced()
		{
			Reset();
			Sync();
		}

		internal void ResetUnsynced()
		{
			Reset();
			_stateReplicator?.SetStateUnsynced(GetSyncState());
		}

		private void Reset()
		{
			Enabled = false;
			for (int i = 0; i < _slots.Length; i++)
			{
				_slots[i] = false;
			}
			_lastDeathFrameBySlot.Clear();
			Events = new List<WardenObjectiveEventData>();
		}

		private void Sync()
		{
			if (!SNet.IsMaster)
			{
				ManualLogSource? log = AddEventsRuntime.Log;
				if (log != null)
				{
					log.LogWarning((object)"AddEvents Type 2004 death event group sync blocked on client; state changes must be executed by host.");
				}
			}
			else
			{
				_stateReplicator?.SetState(GetSyncState());
			}
		}

		private void OnStateChanged(AddEventsDeathEventGroupReplicationState oldState, AddEventsDeathEventGroupReplicationState newState, bool isRecall)
		{
			if (isRecall)
			{
				Enabled = newState.enabled;
				_slots[0] = newState.checkP1;
				_slots[1] = newState.checkP2;
				_slots[2] = newState.checkP3;
				_slots[3] = newState.checkP4;
			}
		}

		private AddEventsDeathEventGroupReplicationState GetSyncState()
		{
			return new AddEventsDeathEventGroupReplicationState
			{
				enabled = Enabled,
				checkP1 = _slots[0],
				checkP2 = _slots[1],
				checkP3 = _slots[2],
				checkP4 = _slots[3]
			};
		}

		internal static AddEventsDeathEventGroup? Instantiate()
		{
			uint num = EOSNetworking.AllotForeverReplicatorID();
			if (num == 0)
			{
				ManualLogSource? log = AddEventsRuntime.Log;
				if (log != null)
				{
					log.LogError((object)"AddEvents Type 2004 could not allocate a network replicator id.");
				}
				return null;
			}
			AddEventsDeathEventGroup addEventsDeathEventGroup = new AddEventsDeathEventGroup();
			addEventsDeathEventGroup._stateReplicator = AddEventsStateReplicatorCompat.Create(num, default(AddEventsDeathEventGroupReplicationState), (LifeTimeType)0, "AddEvents Type 2004");
			if (addEventsDeathEventGroup._stateReplicator == null)
			{
				return null;
			}
			addEventsDeathEventGroup._stateReplicator.OnStateChanged += addEventsDeathEventGroup.OnStateChanged;
			addEventsDeathEventGroup.ResetUnsynced();
			return addEventsDeathEventGroup;
		}

		private static bool IsValidPlayerSlot(int slot)
		{
			if (slot >= 0)
			{
				return slot < 4;
			}
			return false;
		}

		private AddEventsDeathEventGroup()
		{
		}
	}
	internal sealed class AddEventsDeathEventGroupManager
	{
		internal const int MaxGroups = 4;

		private readonly List<AddEventsDeathEventGroup> _groups = new List<AddEventsDeathEventGroup>();

		private bool _initialized;

		internal static AddEventsDeathEventGroupManager Current { get; } = new AddEventsDeathEventGroupManager();

		internal void Init()
		{
			if (!_initialized)
			{
				_initialized = true;
				EventAPI.OnManagersSetup += SetupGroups;
				LevelAPI.OnBuildStart += ResetUnsynced;
				LevelAPI.OnLevelCleanup += ResetUnsynced;
			}
		}

		internal int AddPlayersToGroup(int groupIndex, IEnumerable<PlayerAgent> players, List<WardenObjectiveEventData> events)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			EnsureGroupsReady();
			if (!TryGetGroup(groupIndex, out AddEventsDeathEventGroup group))
			{
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(61, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2004 group index must be between 0 and ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(_groups.Count - 1);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; got ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(groupIndex);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
					}
					log.LogError(val);
				}
				return 0;
			}
			if (events.Count > 0)
			{
				group.Events = events;
			}
			int num = 0;
			foreach (PlayerAgent player in players)
			{
				try
				{
					if (group.SetPlayerInGroup(player.PlayerSlotIndex, inGroup: true))
					{
						num++;
					}
				}
				catch
				{
				}
			}
			return num;
		}

		internal void SetGroupEnabled(int groupIndex, bool enabled)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			EnsureGroupsReady();
			if (!TryGetGroup(groupIndex, out AddEventsDeathEventGroup group))
			{
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(61, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2004 group index must be between 0 and ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(_groups.Count - 1);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; got ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(groupIndex);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
					}
					log.LogError(val);
				}
			}
			else
			{
				group.Toggle(enabled);
			}
		}

		internal void ResetSynced()
		{
			foreach (AddEventsDeathEventGroup group in _groups)
			{
				group.ResetSynced();
			}
		}

		internal void ResetUnsynced()
		{
			foreach (AddEventsDeathEventGroup group in _groups)
			{
				group.ResetUnsynced();
			}
		}

		internal void OnPlayerDied(PlayerAgent? player)
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			if ((Object)(object)player == (Object)null || !SNet.IsMaster)
			{
				return;
			}
			int playerSlotIndex;
			try
			{
				playerSlotIndex = player.PlayerSlotIndex;
			}
			catch
			{
				return;
			}
			int frameCount = Time.frameCount;
			bool flag = default(bool);
			for (int i = 0; i < _groups.Count; i++)
			{
				AddEventsDeathEventGroup addEventsDeathEventGroup = _groups[i];
				if (!addEventsDeathEventGroup.Enabled || !addEventsDeathEventGroup.ContainsSlot(playerSlotIndex) || !addEventsDeathEventGroup.TryMarkDeathFrame(playerSlotIndex, frameCount))
				{
					continue;
				}
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(79, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2004 death event group ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(i);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": player slot ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(playerSlotIndex);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" died; executing ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(addEventsDeathEventGroup.Events.Count);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" event(s).");
					}
					log.LogDebug(val);
				}
				foreach (WardenObjectiveEventData @event in addEventsDeathEventGroup.Events)
				{
					try
					{
						WardenObjectiveManager.CheckAndExecuteEventsOnTrigger(@event, (eWardenObjectiveEventTrigger)0, true, 0f);
					}
					catch (Exception ex)
					{
						log = AddEventsRuntime.Log;
						if (log != null)
						{
							BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(43, 2, ref flag);
							if (flag)
							{
								((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("AddEvents Type 2004 nested event failed: ");
								((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.GetType().Name);
								((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(": ");
								((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
							}
							log.LogWarning(val2);
						}
					}
				}
			}
		}

		private void SetupGroups()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (_groups.Count > 0)
			{
				return;
			}
			bool flag = default(bool);
			for (int i = 0; i < 4; i++)
			{
				AddEventsDeathEventGroup addEventsDeathEventGroup = AddEventsDeathEventGroup.Instantiate();
				if (addEventsDeathEventGroup == null)
				{
					ManualLogSource log = AddEventsRuntime.Log;
					if (log != null)
					{
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(58, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2004 instantiated death event group count: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(_groups.Count);
						}
						log.LogError(val);
					}
					break;
				}
				_groups.Add(addEventsDeathEventGroup);
			}
		}

		private void EnsureGroupsReady()
		{
			if (_groups.Count == 0)
			{
				SetupGroups();
			}
		}

		private bool TryGetGroup(int groupIndex, out AddEventsDeathEventGroup? group)
		{
			if (groupIndex < 0 || groupIndex >= _groups.Count)
			{
				group = null;
				return false;
			}
			group = _groups[groupIndex];
			return true;
		}

		private AddEventsDeathEventGroupManager()
		{
		}
	}
	[HarmonyPatch(typeof(Dam_PlayerDamageBase), "ReceiveSetDead")]
	internal static class AddEventsDeathEvent_DamPlayerDamageBaseReceiveSetDeadPatch
	{
		private static void Postfix(Dam_PlayerDamageBase __instance)
		{
			AddEventsDeathEventGroupManager.Current.OnPlayerDied(TryGetOwner(__instance));
		}

		internal static PlayerAgent? TryGetOwner(Dam_PlayerDamageBase? damageBase)
		{
			if ((Object)(object)damageBase == (Object)null)
			{
				return null;
			}
			try
			{
				return damageBase.Owner;
			}
			catch
			{
				return null;
			}
		}
	}
	[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveSetDead")]
	internal static class AddEventsDeathEvent_DamPlayerDamageLocalReceiveSetDeadPatch
	{
		private static void Postfix(Dam_PlayerDamageLocal __instance)
		{
			AddEventsDeathEventGroupManager.Current.OnPlayerDied(AddEventsDeathEvent_DamPlayerDamageBaseReceiveSetDeadPatch.TryGetOwner((Dam_PlayerDamageBase?)(object)__instance));
		}
	}
	internal sealed class AddEventsType2005EventData
	{
		internal int Count { get; set; }

		internal bool Enabled { get; set; } = true;

		internal bool HasEnabled { get; set; }

		internal Vector3 Position { get; set; }

		internal bool HasPosition { get; set; }

		internal float FogTransitionDuration { get; set; }

		internal bool HasFogTransitionDuration { get; set; }

		internal List<WardenObjectiveEventData> Events { get; set; } = new List<WardenObjectiveEventData>();
	}
	internal readonly struct AddEventsType2005Signature : IEquatable<AddEventsType2005Signature>
	{
		private readonly int _count;

		private readonly bool _enabled;

		private readonly int _radius1000;

		private readonly int _x1000;

		private readonly int _y1000;

		private readonly int _z1000;

		internal AddEventsType2005Signature(int count, bool enabled, float radius, Vector3 position)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			_count = count;
			_enabled = enabled;
			_radius1000 = Quantize(radius);
			_x1000 = Quantize(position.x);
			_y1000 = Quantize(position.y);
			_z1000 = Quantize(position.z);
		}

		internal static AddEventsType2005Signature FromEvent(WardenObjectiveEventData e)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return new AddEventsType2005Signature(e.Count, e.Enabled, e.FogTransitionDuration, e.Position);
		}

		public bool Equals(AddEventsType2005Signature other)
		{
			if (_count == other._count && _enabled == other._enabled && _radius1000 == other._radius1000 && _x1000 == other._x1000 && _y1000 == other._y1000)
			{
				return _z1000 == other._z1000;
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			if (obj is AddEventsType2005Signature other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(_count, _enabled, _radius1000, _x1000, _y1000, _z1000);
		}

		private static int Quantize(float value)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return 0;
			}
			return (int)Math.Round(value * 1000f);
		}
	}
	internal static class AddEventsType2005SidecarStore
	{
		private static readonly Dictionary<IntPtr, AddEventsType2005EventData> ByEventPointer = new Dictionary<IntPtr, AddEventsType2005EventData>();

		private static readonly Dictionary<AddEventsType2005Signature, List<AddEventsType2005EventData>> ByLooseSignature = new Dictionary<AddEventsType2005Signature, List<AddEventsType2005EventData>>();

		private static readonly List<AddEventsType2005EventData> LooseFallback = new List<AddEventsType2005EventData>();

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

		private static readonly HashSet<AddEventsType2005Signature> AmbiguousWarningPrinted = new HashSet<AddEventsType2005Signature>();

		private static bool _isDeserializingSidecarEvents;

		private static bool _diskScanned;

		internal static bool TryGet(WardenObjectiveEventData eventData, out AddEventsType2005EventData data)
		{
			if (eventData != null && ByEventPointer.TryGetValue(((Il2CppObjectBase)eventData).Pointer, out data))
			{
				return true;
			}
			if (eventData != null)
			{
				AddEventsType2005Signature addEventsType2005Signature = AddEventsType2005Signature.FromEvent(eventData);
				if (ByLooseSignature.TryGetValue(addEventsType2005Signature, out List<AddEventsType2005EventData> value) && value.Count > 0)
				{
					data = value[0];
					if (value.Count > 1 && AmbiguousWarningPrinted.Add(addEventsType2005Signature))
					{
						ManualLogSource? log = AddEventsRuntime.Log;
						if (log != null)
						{
							log.LogWarning((object)"AddEvents Type 2005 sidecar fallback matched multiple definitions with the same vanilla signature. Using the first match. Make Count/Position/FogTransitionDuration/Enabled unique if this is not intended.");
						}
					}
					ByEventPointer[((Il2CppObjectBase)eventData).Pointer] = data;
					return true;
				}
			}
			if (LooseFallback.Count == 1)
			{
				data = LooseFallback[0];
				if (eventData != null)
				{
					ByEventPointer[((Il2CppObjectBase)eventData).Pointer] = data;
				}
				return true;
			}
			data = null;
			return false;
		}

		internal static void ScanDiskForDefinitions()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			if (_diskScanned)
			{
				return;
			}
			_diskScanned = true;
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			bool flag = default(bool);
			ManualLogSource log;
			try
			{
				foreach (string item in EnumerateCandidateJsonFiles())
				{
					num++;
					string text;
					try
					{
						text = File.ReadAllText(item);
					}
					catch
					{
						continue;
					}
					if (text.IndexOf("2005", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						List<AddEventsType2005EventData> list = ParseType2005Nodes(text);
						if (list.Count != 0)
						{
							num2++;
							num3 += list.Count;
							RegisterLoose(list);
						}
					}
				}
			}
			catch (Exception ex)
			{
				log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(48, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2005 disk sidecar scan failed: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					log.LogWarning(val);
				}
			}
			if (num3 > 0)
			{
				log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExMessageLogInterpolatedStringHandler val2 = new BepInExMessageLogInterpolatedStringHandler(96, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("AddEvents Type 2005 disk sidecar scan complete. FilesScanned=");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", FilesWithType2005=");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num2);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", Definitions=");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num3);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(".");
					}
					log.LogMessage(val2);
				}
				return;
			}
			log = AddEventsRuntime.Log;
			if (log != null)
			{
				BepInExDebugLogInterpolatedStringHandler val3 = new BepInExDebugLogInterpolatedStringHandler(77, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("AddEvents Type 2005 disk sidecar scan complete. FilesScanned=");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(", Definitions=0.");
				}
				log.LogDebug(val3);
			}
		}

		internal static void Capture(string json, object? result)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Invalid comparison between Unknown and I4
			if (_isDeserializingSidecarEvents || string.IsNullOrWhiteSpace(json) || json.IndexOf("2005", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return;
			}
			List<AddEventsType2005EventData> list = ParseType2005Nodes(json);
			if (list.Count == 0)
			{
				return;
			}
			RegisterLoose(list);
			if (result == null)
			{
				return;
			}
			List<WardenObjectiveEventData> list2 = new List<WardenObjectiveEventData>();
			CollectEvents(result, list2, new HashSet<object>(ReferenceEqualityComparer.Instance), 0);
			if (list2.Count == 0)
			{
				return;
			}
			Dictionary<AddEventsType2005Signature, Queue<AddEventsType2005EventData>> dictionary = new Dictionary<AddEventsType2005Signature, Queue<AddEventsType2005EventData>>();
			foreach (AddEventsType2005EventData item in list)
			{
				AddEventsType2005Signature key = new AddEventsType2005Signature(item.Count, item.Enabled, item.FogTransitionDuration, item.Position);
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = (dictionary[key] = new Queue<AddEventsType2005EventData>());
				}
				value.Enqueue(item);
			}
			Queue<AddEventsType2005EventData> queue2 = new Queue<AddEventsType2005EventData>(list);
			foreach (WardenObjectiveEventData item2 in list2)
			{
				if ((int)item2.Type == 2005)
				{
					AddEventsType2005EventData addEventsType2005EventData = null;
					AddEventsType2005Signature key2 = AddEventsType2005Signature.FromEvent(item2);
					if (dictionary.TryGetValue(key2, out var value2) && value2.Count > 0)
					{
						addEventsType2005EventData = value2.Dequeue();
					}
					else if (queue2.Count > 0)
					{
						addEventsType2005EventData = queue2.Dequeue();
					}
					if (addEventsType2005EventData != null)
					{
						ByEventPointer[((Il2CppObjectBase)item2).Pointer] = addEventsType2005EventData;
					}
				}
			}
		}

		private static void RegisterLoose(IEnumerable<AddEventsType2005EventData> parsed)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			foreach (AddEventsType2005EventData item in parsed)
			{
				string looseFingerprint = GetLooseFingerprint(item);
				if (RegisteredLooseFingerprints.Add(looseFingerprint))
				{
					AddEventsType2005Signature key = new AddEventsType2005Signature(item.Count, item.Enabled, item.FogTransitionDuration, item.Position);
					if (!ByLooseSignature.TryGetValue(key, out List<AddEventsType2005EventData> value))
					{
						value = new List<AddEventsType2005EventData>(1);
						ByLooseSignature[key] = value;
					}
					value.Add(item);
					LooseFallback.Add(item);
				}
			}
		}

		private static string GetLooseFingerprint(AddEventsType2005EventData data)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected I4, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			int num = 17;
			foreach (WardenObjectiveEventData @event in data.Events)
			{
				num = num * 31 + @event.Type;
				num = num * 31 + @event.Count;
				num = num * 31 + ((object)@event.LocalIndex/*cast due to .constrained prefix*/).GetHashCode();
				num = num * 31 + ((object)@event.Layer/*cast due to .constrained prefix*/).GetHashCode();
				num = num * 31 + ((object)@event.DimensionIndex/*cast due to .constrained prefix*/).GetHashCode();
				num = num * 31 + ((object)@event.Position/*cast due to .constrained prefix*/).GetHashCode();
				num = num * 31 + @event.FogTransitionDuration.GetHashCode();
			}
			return string.Join("|", data.Count, data.Enabled, data.FogTransitionDuration, data.Position.x, data.Position.y, data.Position.z, data.Events.Count, num);
		}

		private static IEnumerable<string> EnumerateCandidateJsonFiles()
		{
			HashSet<string> roots = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			AddRoot(Paths.PluginPath);
			AddRoot(Path.Combine(Paths.BepInExRootPath, "GameData"));
			AddRoot(Path.Combine(Paths.BepInExRootPath, "Custom"));
			foreach (string item in roots)
			{
				IEnumerable<string> enumerable;
				try
				{
					enumerable = Directory.EnumerateFiles(item, "*.json", SearchOption.AllDirectories).ToArray();
				}
				catch
				{
					continue;
				}
				foreach (string item2 in enumerable)
				{
					yield return item2;
				}
			}
			void AddRoot(string? root)
			{
				if (!string.IsNullOrWhiteSpace(root) && Directory.Exists(root))
				{
					roots.Add(Path.GetFullPath(root));
				}
			}
		}

		private static List<AddEventsType2005EventData> ParseType2005Nodes(string json)
		{
			List<AddEventsType2005EventData> list = new List<AddEventsType2005EventData>();
			try
			{
				JsonNode jsonNode = JsonNode.Parse(json, new JsonNodeOptions
				{
					PropertyNameCaseInsensitive = true
				}, new JsonDocumentOptions
				{
					AllowTrailingCommas = true,
					CommentHandling = JsonCommentHandling.Skip
				});
				if (jsonNode != null)
				{
					TraverseJson(jsonNode, list);
				}
			}
			catch
			{
			}
			return list;
		}

		private static void TraverseJson(JsonNode node, List<AddEventsType2005EventData> output)
		{
			if (node is JsonObject jsonObject)
			{
				if (IsType2005Object(jsonObject))
				{
					output.Add(ParseEventData(jsonObject));
				}
				{
					foreach (KeyValuePair<string, JsonNode> item in jsonObject)
					{
						if (item.Value != null)
						{
							TraverseJson(item.Value, output);
						}
					}
					return;
				}
			}
			if (!(node is JsonArray jsonArray))
			{
				return;
			}
			foreach (JsonNode item2 in jsonArray)
			{
				if (item2 != null)
				{
					TraverseJson(item2, output);
				}
			}
		}

		private static bool IsType2005Object(JsonObject obj)
		{
			if (!obj.TryGetPropertyValue("Type", out JsonNode jsonNode))
			{
				return false;
			}
			if (jsonNode is JsonValue jsonValue)
			{
				if (jsonValue.TryGetValue<int>(out var value))
				{
					return value == 2005;
				}
				if (jsonValue.TryGetValue<string>(out string value2))
				{
					if (!string.Equals(value2, "2005", StringComparison.OrdinalIgnoreCase))
					{
						return string.Equals(value2, "AddPlayersToAllDownEventGroup", StringComparison.OrdinalIgnoreCase);
					}
					return true;
				}
			}
			return false;
		}

		private static AddEventsType2005EventData ParseEventData(JsonObject obj)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			JsonNode jsonNode;
			AddEventsType2005EventData addEventsType2005EventData = new AddEventsType2005EventData
			{
				Count = ReadInt(obj, "Count", 0),
				HasEnabled = obj.ContainsKey("Enabled"),
				Enabled = ReadBool(obj, "Enabled", fallback: true),
				HasPosition = obj.ContainsKey("Position"),
				Position = ReadVector3(obj.TryGetPropertyValue("Position", out jsonNode) ? jsonNode : null),
				HasFogTransitionDuration = obj.ContainsKey("FogTransitionDuration"),
				FogTransitionDuration = ReadFloat(obj, "FogTransitionDuration", 0f)
			};
			if (obj.TryGetPropertyValue("Events", out JsonNode jsonNode2) && jsonNode2 != null)
			{
				addEventsType2005EventData.Events = DeserializeEvents(jsonNode2.ToJsonString());
			}
			return addEventsType2005EventData;
		}

		private static List<WardenObjectiveEventData> DeserializeEvents(string json)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			try
			{
				_isDeserializingSidecarEvents = true;
				return EOSJson.Deserialize<List<WardenObjectiveEventData>>(json) ?? new List<WardenObjectiveEventData>();
			}
			catch (Exception ex)
			{
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(59, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2005 could not deserialize nested Events: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					log.LogWarning(val);
				}
				return new List<WardenObjectiveEventData>();
			}
			finally
			{
				_isDeserializingSidecarEvents = false;
			}
		}

		private static void CollectEvents(object obj, List<WardenObjectiveEventData> output, HashSet<object> visited, int depth)
		{
			if (obj == null || depth > 12 || !visited.Add(obj))
			{
				return;
			}
			WardenObjectiveEventData val = (WardenObjectiveEventData)((obj is WardenObjectiveEventData) ? obj : null);
			if (val != null)
			{
				output.Add(val);
				return;
			}
			if (obj is IEnumerable enumerable && !(obj is string))
			{
				foreach (object item in enumerable)
				{
					if (item != null)
					{
						CollectEvents(item, output, visited, depth + 1);
					}
				}
				return;
			}
			Type type = obj.GetType();
			if (type.IsPrimitive || type.IsEnum || type == typeof(string))
			{
				return;
			}
			PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.GetIndexParameters().Length != 0)
				{
					continue;
				}
				try
				{
					object value = propertyInfo.GetValue(obj);
					if (value != null)
					{
						CollectEvents(value, output, visited, depth + 1);
					}
				}
				catch
				{
				}
			}
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				try
				{
					object value2 = fieldInfo.GetValue(obj);
					if (value2 != null)
					{
						CollectEvents(value2, output, visited, depth + 1);
					}
				}
				catch
				{
				}
			}
		}

		private static int ReadInt(JsonObject node, string name, int fallback)
		{
			try
			{
				if (node.TryGetPropertyValue(name, out JsonNode jsonNode) && jsonNode is JsonValue jsonValue)
				{
					if (jsonValue.TryGetValue<int>(out var value))
					{
						return value;
					}
					if (jsonValue.TryGetValue<string>(out string value2) && int.TryParse(value2, out value))
					{
						return value;
					}
				}
			}
			catch
			{
			}
			return fallback;
		}

		private static float ReadFloat(JsonObject node, string name, float fallback)
		{
			try
			{
				if (node.TryGetPropertyValue(name, out JsonNode jsonNode) && jsonNode is JsonValue jsonValue)
				{
					if (jsonValue.TryGetValue<float>(out var value))
					{
						return value;
					}
					if (jsonValue.TryGetValue<double>(out var value2))
					{
						return (float)value2;
					}
					if (jsonValue.TryGetValue<string>(out string value3) && float.TryParse(value3, NumberStyles.Float, CultureInfo.InvariantCulture, out value))
					{
						return value;
					}
				}
			}
			catch
			{
			}
			return fallback;
		}

		private static bool ReadBool(JsonObject node, string name, bool fallback)
		{
			try
			{
				if (node.TryGetPropertyValue(name, out JsonNode jsonNode) && jsonNode is JsonValue jsonValue)
				{
					if (jsonValue.TryGetValue<bool>(out var value))
					{
						return value;
					}
					if (jsonValue.TryGetValue<string>(out string value2) && bool.TryParse(value2, out value))
					{
						return value;
					}
				}
			}
			catch
			{
			}
			return fallback;
		}

		private static Vector3 ReadVector3(JsonNode? node)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!(node is JsonObject node2))
			{
				return Vector3.zero;
			}
			return new Vector3(ReadFloat(node2, "x", 0f), ReadFloat(node2, "y", 0f), ReadFloat(node2, "z", 0f));
		}
	}
	internal static class AddEventsAllDownEventGroupEvents
	{
		internal static void AddPlayersToAllDownEventGroup(WardenObjectiveEventData eventData)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			if (!AddEventsNetworkEventProxy.EnsureHostExecution(AddEventsCustomEventType.AddPlayersToAllDownEventGroup, eventData))
			{
				return;
			}
			if (!AddEventsType2005SidecarStore.TryGet(eventData, out AddEventsType2005EventData data))
			{
				data = new AddEventsType2005EventData
				{
					Count = eventData.Count,
					Enabled = eventData.Enabled,
					Position = eventData.Position,
					HasPosition = true,
					FogTransitionDuration = eventData.FogTransitionDuration,
					HasFogTransitionDuration = (eventData.FogTransitionDuration > 0f),
					Events = new List<WardenObjectiveEventData>()
				};
			}
			bool flag = default(bool);
			ManualLogSource log;
			if (!data.Enabled)
			{
				AddEventsAllDownEventGroupManager.Current.SetGroupEnabled(data.Count, enabled: false);
				log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(63, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2005 all-down event group ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(data.Count);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" disabled and cleared.");
					}
					log.LogDebug(val);
				}
				return;
			}
			List<PlayerAgent> list = ResolvePlayers(eventData, data);
			int num = AddEventsAllDownEventGroupManager.Current.AddPlayersToGroup(data.Count, list, data.Events);
			log = AddEventsRuntime.Log;
			if (log != null)
			{
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(70, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2005 all-down event group ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(data.Count);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": added ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("/");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(list.Count);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" player(s), Events=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(data.Events.Count);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
				}
				log.LogDebug(val);
			}
		}

		private static List<PlayerAgent> ResolvePlayers(WardenObjectiveEventData eventData, AddEventsType2005EventData data)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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)
			float num = (data.HasFogTransitionDuration ? data.FogTransitionDuration : eventData.FogTransitionDuration);
			Vector3 origin = (data.HasPosition ? data.Position : eventData.Position);
			if (num > 0f)
			{
				return GetPlayersInRadius(origin, num);
			}
			return GetAllPlayers();
		}

		private static List<PlayerAgent> GetPlayersInRadius(Vector3 origin, float radius)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			float num = radius * radius;
			List<PlayerAgent> list = new List<PlayerAgent>();
			Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
			while (enumerator.MoveNext())
			{
				PlayerAgent current = enumerator.Current;
				if (!((Object)(object)current == (Object)null) && ((Agent)current).Alive)
				{
					Vector3 val = ((Agent)current).Position - origin;
					if (((Vector3)(ref val)).sqrMagnitude <= num)
					{
						list.Add(current);
					}
				}
			}
			return list;
		}

		private static List<PlayerAgent> GetAllPlayers()
		{
			List<PlayerAgent> list = new List<PlayerAgent>();
			Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
			while (enumerator.MoveNext())
			{
				PlayerAgent current = enumerator.Current;
				if ((Object)(object)current != (Object)null && ((Agent)current).Alive)
				{
					list.Add(current);
				}
			}
			return list;
		}
	}
	public struct AddEventsAllDownEventGroupReplicationState
	{
		public bool enabled;

		public bool checkP1;

		public bool checkP2;

		public bool checkP3;

		public bool checkP4;
	}
	internal sealed class AddEventsAllDownEventGroup
	{
		internal const int MaxPlayers = 4;

		private readonly bool[] _slots = new bool[4];

		private readonly bool[] _downSlots = new bool[4];

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

		private bool _hasTriggered;

		private StateReplicator<AddEventsAllDownEventGroupReplicationState>? _stateReplicator;

		internal bool Enabled { get; private set; }

		internal List<WardenObjectiveEventData> Events { get; set; } = new List<WardenObjectiveEventData>();

		internal int Count
		{
			get
			{
				int num = 0;
				for (int i = 0; i < _slots.Length; i++)
				{
					if (_slots[i])
					{
						num++;
					}
				}
				return num;
			}
		}

		internal bool SetPlayerInGroup(int slot, bool inGroup)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (!IsValidPlayerSlot(slot))
			{
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(63, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2005 invalid player slot index ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(slot);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; expected [0, ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(4);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(").");
					}
					log.LogError(val);
				}
				return false;
			}
			if (_slots[slot] == inGroup)
			{
				return false;
			}
			int count = Count;
			_slots[slot] = inGroup;
			_downSlots[slot] = false;
			_lastDeathFrameBySlot.Remove(slot);
			if (inGroup)
			{
				_hasTriggered = false;
			}
			int count2 = Count;
			if (count == 0 && count2 > 0)
			{
				Enabled = true;
			}
			else if (count > 0 && count2 == 0)
			{
				Enabled = false;
			}
			Sync();
			return true;
		}

		internal void Toggle(bool enabled)
		{
			if (!enabled)
			{
				ClearAndDisable();
			}
			else if (!Enabled)
			{
				Enabled = true;
				Sync();
			}
		}

		internal void ClearAndDisable()
		{
			bool flag = Enabled || Count > 0 || Events.Count > 0 || _lastDeathFrameBySlot.Count > 0 || _hasTriggered;
			Enabled = false;
			for (int i = 0; i < _slots.Length; i++)
			{
				_slots[i] = false;
				_downSlots[i] = false;
			}
			_lastDeathFrameBySlot.Clear();
			_hasTriggered = false;
			Events = new List<WardenObjectiveEventData>();
			if (flag)
			{
				Sync();
			}
		}

		internal bool ContainsSlot(int slot)
		{
			if (IsValidPlayerSlot(slot))
			{
				return _slots[slot];
			}
			return false;
		}

		internal bool TryMarkPlayerDownAndCheckAll(int slot, int frame, out int markedCount, out int downCount)
		{
			markedCount = Count;
			downCount = GetDownCount();
			if (!IsValidPlayerSlot(slot) || !_slots[slot] || _hasTriggered)
			{
				return false;
			}
			if (_lastDeathFrameBySlot.TryGetValue(slot, out var value) && value == frame)
			{
				return false;
			}
			_lastDeathFrameBySlot[slot] = frame;
			_downSlots[slot] = true;
			downCount = GetDownCount();
			markedCount = Count;
			if (markedCount <= 0 || downCount < markedCount)
			{
				return false;
			}
			_hasTriggered = true;
			return true;
		}

		internal void Rearm(List<WardenObjectiveEventData> events)
		{
			_hasTriggered = false;
			_lastDeathFrameBySlot.Clear();
			for (int i = 0; i < _downSlots.Length; i++)
			{
				_downSlots[i] = false;
			}
			if (events.Count > 0)
			{
				Events = events;
			}
		}

		private int GetDownCount()
		{
			int num = 0;
			for (int i = 0; i < _slots.Length; i++)
			{
				if (_slots[i] && _downSlots[i])
				{
					num++;
				}
			}
			return num;
		}

		internal void ResetSynced()
		{
			Reset();
			Sync();
		}

		internal void ResetUnsynced()
		{
			Reset();
			_stateReplicator?.SetStateUnsynced(GetSyncState());
		}

		private void Reset()
		{
			Enabled = false;
			for (int i = 0; i < _slots.Length; i++)
			{
				_slots[i] = false;
				_downSlots[i] = false;
			}
			_lastDeathFrameBySlot.Clear();
			_hasTriggered = false;
			Events = new List<WardenObjectiveEventData>();
		}

		private void Sync()
		{
			if (!SNet.IsMaster)
			{
				ManualLogSource? log = AddEventsRuntime.Log;
				if (log != null)
				{
					log.LogWarning((object)"AddEvents Type 2005 all-down event group sync blocked on client; state changes must be executed by host.");
				}
			}
			else
			{
				_stateReplicator?.SetState(GetSyncState());
			}
		}

		private void OnStateChanged(AddEventsAllDownEventGroupReplicationState oldState, AddEventsAllDownEventGroupReplicationState newState, bool isRecall)
		{
			if (isRecall)
			{
				Enabled = newState.enabled;
				_slots[0] = newState.checkP1;
				_slots[1] = newState.checkP2;
				_slots[2] = newState.checkP3;
				_slots[3] = newState.checkP4;
			}
		}

		private AddEventsAllDownEventGroupReplicationState GetSyncState()
		{
			return new AddEventsAllDownEventGroupReplicationState
			{
				enabled = Enabled,
				checkP1 = _slots[0],
				checkP2 = _slots[1],
				checkP3 = _slots[2],
				checkP4 = _slots[3]
			};
		}

		internal static AddEventsAllDownEventGroup? Instantiate()
		{
			uint num = EOSNetworking.AllotForeverReplicatorID();
			if (num == 0)
			{
				ManualLogSource? log = AddEventsRuntime.Log;
				if (log != null)
				{
					log.LogError((object)"AddEvents Type 2005 could not allocate a network replicator id.");
				}
				return null;
			}
			AddEventsAllDownEventGroup addEventsAllDownEventGroup = new AddEventsAllDownEventGroup();
			addEventsAllDownEventGroup._stateReplicator = AddEventsStateReplicatorCompat.Create(num, default(AddEventsAllDownEventGroupReplicationState), (LifeTimeType)0, "AddEvents Type 2005");
			if (addEventsAllDownEventGroup._stateReplicator == null)
			{
				return null;
			}
			addEventsAllDownEventGroup._stateReplicator.OnStateChanged += addEventsAllDownEventGroup.OnStateChanged;
			addEventsAllDownEventGroup.ResetUnsynced();
			return addEventsAllDownEventGroup;
		}

		private static bool IsValidPlayerSlot(int slot)
		{
			if (slot >= 0)
			{
				return slot < 4;
			}
			return false;
		}

		private AddEventsAllDownEventGroup()
		{
		}
	}
	internal sealed class AddEventsAllDownEventGroupManager
	{
		internal const int MaxGroups = 4;

		private readonly List<AddEventsAllDownEventGroup> _groups = new List<AddEventsAllDownEventGroup>();

		private bool _initialized;

		internal static AddEventsAllDownEventGroupManager Current { get; } = new AddEventsAllDownEventGroupManager();

		internal void Init()
		{
			if (!_initialized)
			{
				_initialized = true;
				EventAPI.OnManagersSetup += SetupGroups;
				LevelAPI.OnBuildStart += ResetUnsynced;
				LevelAPI.OnLevelCleanup += ResetUnsynced;
			}
		}

		internal int AddPlayersToGroup(int groupIndex, IEnumerable<PlayerAgent> players, List<WardenObjectiveEventData> events)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			EnsureGroupsReady();
			if (!TryGetGroup(groupIndex, out AddEventsAllDownEventGroup group))
			{
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(61, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2005 group index must be between 0 and ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(_groups.Count - 1);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; got ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(groupIndex);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
					}
					log.LogError(val);
				}
				return 0;
			}
			group.Rearm(events);
			int num = 0;
			foreach (PlayerAgent player in players)
			{
				try
				{
					if (group.SetPlayerInGroup(player.PlayerSlotIndex, inGroup: true))
					{
						num++;
					}
				}
				catch
				{
				}
			}
			return num;
		}

		internal void SetGroupEnabled(int groupIndex, bool enabled)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			EnsureGroupsReady();
			if (!TryGetGroup(groupIndex, out AddEventsAllDownEventGroup group))
			{
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(61, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2005 group index must be between 0 and ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(_groups.Count - 1);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; got ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(groupIndex);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
					}
					log.LogError(val);
				}
			}
			else
			{
				group.Toggle(enabled);
			}
		}

		internal void ResetSynced()
		{
			foreach (AddEventsAllDownEventGroup group in _groups)
			{
				group.ResetSynced();
			}
		}

		internal void ResetUnsynced()
		{
			foreach (AddEventsAllDownEventGroup group in _groups)
			{
				group.ResetUnsynced();
			}
		}

		internal void OnPlayerDied(PlayerAgent? player)
		{
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			if ((Object)(object)player == (Object)null || !SNet.IsMaster)
			{
				return;
			}
			int playerSlotIndex;
			try
			{
				playerSlotIndex = player.PlayerSlotIndex;
			}
			catch
			{
				return;
			}
			int frameCount = Time.frameCount;
			bool flag = default(bool);
			for (int i = 0; i < _groups.Count; i++)
			{
				AddEventsAllDownEventGroup addEventsAllDownEventGroup = _groups[i];
				if (!addEventsAllDownEventGroup.Enabled || !addEventsAllDownEventGroup.ContainsSlot(playerSlotIndex))
				{
					continue;
				}
				ManualLogSource log;
				if (!addEventsAllDownEventGroup.TryMarkPlayerDownAndCheckAll(playerSlotIndex, frameCount, out var markedCount, out var downCount))
				{
					log = AddEventsRuntime.Log;
					if (log != null)
					{
						BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(99, 4, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2005 all-down event group ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(i);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": player slot ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(playerSlotIndex);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" downed (");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(downCount);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("/");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(markedCount);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("); waiting for all marked players.");
						}
						log.LogDebug(val);
					}
					continue;
				}
				log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(94, 4, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2005 all-down event group ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(i);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": all marked players downed (");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(downCount);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("/");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(markedCount);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("); executing ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(addEventsAllDownEventGroup.Events.Count);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" event(s).");
					}
					log.LogDebug(val);
				}
				foreach (WardenObjectiveEventData @event in addEventsAllDownEventGroup.Events)
				{
					try
					{
						WardenObjectiveManager.CheckAndExecuteEventsOnTrigger(@event, (eWardenObjectiveEventTrigger)0, true, 0f);
					}
					catch (Exception ex)
					{
						log = AddEventsRuntime.Log;
						if (log != null)
						{
							BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(43, 2, ref flag);
							if (flag)
							{
								((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("AddEvents Type 2005 nested event failed: ");
								((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.GetType().Name);
								((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(": ");
								((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
							}
							log.LogWarning(val2);
						}
					}
				}
			}
		}

		private void SetupGroups()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (_groups.Count > 0)
			{
				return;
			}
			bool flag = default(bool);
			for (int i = 0; i < 4; i++)
			{
				AddEventsAllDownEventGroup addEventsAllDownEventGroup = AddEventsAllDownEventGroup.Instantiate();
				if (addEventsAllDownEventGroup == null)
				{
					ManualLogSource log = AddEventsRuntime.Log;
					if (log != null)
					{
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(61, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents Type 2005 instantiated all-down event group count: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(_groups.Count);
						}
						log.LogError(val);
					}
					break;
				}
				_groups.Add(addEventsAllDownEventGroup);
			}
		}

		private void EnsureGroupsReady()
		{
			if (_groups.Count == 0)
			{
				SetupGroups();
			}
		}

		private bool TryGetGroup(int groupIndex, out AddEventsAllDownEventGroup? group)
		{
			if (groupIndex < 0 || groupIndex >= _groups.Count)
			{
				group = null;
				return false;
			}
			group = _groups[groupIndex];
			return true;
		}

		private AddEventsAllDownEventGroupManager()
		{
		}
	}
	[HarmonyPatch(typeof(Dam_PlayerDamageBase), "ReceiveSetDead")]
	internal static class AddEventsAllDownEvent_DamPlayerDamageBaseReceiveSetDeadPatch
	{
		private static void Postfix(Dam_PlayerDamageBase __instance)
		{
			AddEventsAllDownEventGroupManager.Current.OnPlayerDied(TryGetOwner(__instance));
		}

		internal static PlayerAgent? TryGetOwner(Dam_PlayerDamageBase? damageBase)
		{
			if ((Object)(object)damageBase == (Object)null)
			{
				return null;
			}
			try
			{
				return damageBase.Owner;
			}
			catch
			{
				return null;
			}
		}
	}
	[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveSetDead")]
	internal static class AddEventsAllDownEvent_DamPlayerDamageLocalReceiveSetDeadPatch
	{
		private static void Postfix(Dam_PlayerDamageLocal __instance)
		{
			AddEventsAllDownEventGroupManager.Current.OnPlayerDied(AddEventsAllDownEvent_DamPlayerDamageBaseReceiveSetDeadPatch.TryGetOwner((Dam_PlayerDamageBase?)(object)__instance));
		}
	}
	internal delegate void AddEventsCustomEventHandler(WardenObjectiveEventData eventData);
	internal enum AddEventsCustomEventType
	{
		AddPlayersToDeathEventGroup = 2004,
		AddPlayersToAllDownEventGroup = 2005,
		ToggleLaserRoom = 2010
	}
	internal static class AddEventsCustomEventRegistry
	{
		private static bool _registered;

		private static readonly Dictionary<AddEventsCustomEventType, AddEventsCustomEventHandler> Handlers = new Dictionary<AddEventsCustomEventType, AddEventsCustomEventHandler>();

		internal static void RegisterDefaults()
		{
			if (!_registered)
			{
				Register(AddEventsCustomEventType.AddPlayersToDeathEventGroup, AddEventsDeathEventGroupEvents.AddPlayersToDeathEventGroup);
				Register(AddEventsCustomEventType.AddPlayersToAllDownEventGroup, AddEventsAllDownEventGroupEvents.AddPlayersToAllDownEventGroup);
				Register(AddEventsCustomEventType.ToggleLaserRoom, LaserRoomEvents.ToggleLaserRoom);
				_registered = true;
				ManualLogSource? log = AddEventsRuntime.Log;
				if (log != null)
				{
					log.LogMessage((object)"AddEvents custom event registry initialized with numeric Type 2004, 2005 and 2010.");
				}
			}
		}

		private static void Register(AddEventsCustomEventType eventType, AddEventsCustomEventHandler handler)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			Handlers[eventType] = handler;
			string text = eventType.ToString();
			uint num = (uint)eventType;
			if (EOSWardenEventManager.Current.AddEventDefinition(text, num, (Action<WardenObjectiveEventData>)delegate(WardenObjectiveEventData e)
			{
				handler(e);
			}))
			{
				return;
			}
			ManualLogSource log = AddEventsRuntime.Log;
			if (log != null)
			{
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(113, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents custom event Type=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<uint>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" Name=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" could not be registered. Another plugin may already own this event name or id.");
				}
				log.LogWarning(val);
			}
		}

		internal static void Execute(AddEventsCustomEventType eventType, WardenObjectiveEventData eventData)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			if (Handlers.TryGetValue(eventType, out AddEventsCustomEventHandler value))
			{
				value(eventData);
				return;
			}
			ManualLogSource log = AddEventsRuntime.Log;
			if (log != null)
			{
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(52, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents custom event '");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AddEventsCustomEventType>(eventType);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' has no registered handler.");
				}
				log.LogWarning(val);
			}
		}

		internal static bool IsAddEventsEvent(eWardenObjectiveEventType type, out AddEventsCustomEventType eventType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Expected I4, but got Unknown
			int num = (int)type;
			if (Enum.IsDefined(typeof(AddEventsCustomEventType), num))
			{
				eventType = (AddEventsCustomEventType)num;
				return true;
			}
			eventType = (AddEventsCustomEventType)0;
			return false;
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	internal struct AddEventsEventRequestPacket
	{
		public int EventType;

		public byte Enabled;

		public int Count;

		public float PosX;

		public float PosY;

		public float PosZ;
	}
	internal static class AddEventsNetworkEventProxy
	{
		private const string EventName = "AddEvents.EventRequest.v1";

		private static bool _registered;

		private static bool _executingHostRequest;

		private static bool _registrationFailed;

		internal static void Init()
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			if (_registered)
			{
				return;
			}
			bool flag = default(bool);
			try
			{
				if (!NetworkAPI.IsEventRegistered("AddEvents.EventRequest.v1"))
				{
					NetworkAPI.RegisterEvent<AddEventsEventRequestPacket>("AddEvents.EventRequest.v1", (Action<ulong, AddEventsEventRequestPacket>)OnReceiveEventRequest);
					ManualLogSource? log = AddEventsRuntime.Log;
					if (log != null)
					{
						log.LogMessage((object)"AddEvents network event proxy registered.");
					}
				}
				else
				{
					ManualLogSource log2 = AddEventsRuntime.Log;
					if (log2 != null)
					{
						BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(61, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents network event proxy event '");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("AddEvents.EventRequest.v1");
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' is already registered.");
						}
						log2.LogWarning(val);
					}
				}
				_registered = true;
				_registrationFailed = false;
			}
			catch (Exception ex)
			{
				_registered = false;
				_registrationFailed = true;
				ManualLogSource log2 = AddEventsRuntime.Log;
				if (log2 != null)
				{
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(98, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents network event proxy disabled because GTFO-API NetworkAPI is not ready or unavailable: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					log2.LogWarning(val);
				}
			}
		}

		internal static bool EnsureHostExecution(AddEventsCustomEventType eventType, WardenObjectiveEventData eventData)
		{
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			if (_executingHostRequest || SNet.IsMaster)
			{
				return true;
			}
			bool flag = default(bool);
			if (!SNet.HasMaster || (Object)(object)SNet.Master == (Object)null)
			{
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(73, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents event '");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AddEventsCustomEventType>(eventType);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' ignored on client because no SNet master is available.");
					}
					log.LogWarning(val);
				}
				return false;
			}
			if (!_registered)
			{
				Init();
				if (!_registered)
				{
					string text = (_registrationFailed ? "network proxy registration is unavailable" : "network proxy is not registered");
					ManualLogSource log = AddEventsRuntime.Log;
					if (log != null)
					{
						BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(54, 2, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AddEvents event '");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AddEventsCustomEventType>(eventType);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' was not forwarded to host because ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
						}
						log.LogWarning(val);
					}
					return false;
				}
			}
			try
			{
				AddEventsEventRequestPacket addEventsEventRequestPacket = BuildPacket(eventType, eventData);
				NetworkAPI.InvokeEvent<AddEventsEventRequestPacket>("AddEvents.EventRequest.v1", addEventsEventRequestPacket, SNet.Master, (SNet_ChannelType)4);
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExMessageLogInterpolatedStringHandler val2 = new BepInExMessageLogInterpolatedStringHandler(65, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("AddEvents event '");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<AddEventsCustomEventType>(eventType);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("' forwarded to host for authoritative execution.");
					}
					log.LogMessage(val2);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = AddEventsRuntime.Log;
				if (log != null)
				{
					BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(42, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("AddEvents event '");
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<AddEventsCustomEventType>(eventType);
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("' host-forward failed: ");
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(": ");
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
					}
					log.LogError(val3);
				}
			}
			return false;
		}

		private static AddEventsEventRequestPacket BuildPacket(AddEventsCustomEventType eventType, WardenObjectiveEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = eventData.Position;
			return new AddEventsEventRequestPacket
			{
				EventType = (int)eventType,
				Enabled = (byte)(eventData.Enabled ? 1 : 0),
				Count = eventData.Count,
				PosX = position.x,
				PosY = position.y,
				PosZ = position.z
			};
		}

		private static void OnReceiveEventRequest(ulong sender, AddEventsEventRequestPacket packet)
		{
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected O, but got Unknown
			//IL_0084: Unknown result