using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using AIGraph;
using AK;
using AWO.CustomFields;
using AWO.Jsons;
using AWO.Modules.TerminalSerialLookup;
using AWO.Modules.WEE;
using AWO.Modules.WEE.Detours;
using AWO.Modules.WEE.Events;
using AWO.Modules.WEE.JsonInjects;
using AWO.Modules.WEE.Replicators;
using AWO.Modules.WOE;
using AWO.Networking;
using AWO.Networking.Patch;
using AWO.Sessions;
using AWO.Utils;
using Agents;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Hook;
using BepInEx.Unity.IL2CPP.Utils;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using CellMenu;
using ChainedPuzzles;
using Enemies;
using Expedition;
using GTFO.API;
using GTFO.API.Extensions;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppInterop.Runtime.InteropTypes.Fields;
using Il2CppInterop.Runtime.Runtime;
using Il2CppJsonNet;
using Il2CppJsonNet.Linq;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using InjectLib.FieldInjection;
using InjectLib.JsonNETInjection;
using InjectLib.JsonNETInjection.Converter;
using InjectLib.JsonNETInjection.Handler;
using InjectLib.JsonNETInjection.Supports;
using LevelGeneration;
using Localization;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("AdvancedWardenObjective")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("2.0.3")]
[assembly: AssemblyInformationalVersion("2.0.3+git7d2d90c-master.7d2d90cc2386556993e0c3cf79f19ddd9e796db0")]
[assembly: AssemblyProduct("AdvancedWardenObjective")]
[assembly: AssemblyTitle("AdvancedWardenObjective")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.3.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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 AWO
{
	[BepInPlugin("GTFO.AWO", "AWO", "2.0.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class EntryPoint : BasePlugin
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct Coroutines
		{
			public static float CountdownStarted { get; set; }

			public static float TPFStarted { get; set; }
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct TimerMods
		{
			public static float TimeModifier { get; set; }

			public static Color TimerColor { get; set; }

			public static float SpeedModifier { get; set; }

			public static LocaleText CountupText { get; set; }
		}

		public static Random SessionRand { get; private set; } = new Random();


		public override void Load()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			WardenEventExt.Initialize();
			new Harmony("AWO.Harmony").PatchAll();
			AssetAPI.OnStartupAssetsLoaded += OnStartupAssetsLoaded;
			LevelAPI.OnBuildDone += OnBuildDone;
			WOEventDataFields.Init();
			SerialLookupManager.Init();
			Logger.Info("AWO is done loading! --Amorously");
		}

		private void OnStartupAssetsLoaded()
		{
			BlackoutState.AssetLoaded();
			LevelFailUpdateState.AssetLoaded();
		}

		private void OnBuildDone()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			int sessionSeed = RundownManager.GetActiveExpeditionData().sessionSeed;
			SessionRand = new Random(sessionSeed);
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(12, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("SessionSeed ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(sessionSeed);
			}
			Logger.Info(val);
		}
	}
	internal static class Logger
	{
		private static readonly ManualLogSource _Logger;

		static Logger()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_Logger = new ManualLogSource("AWO");
			Logger.Sources.Add((ILogSource)(object)_Logger);
		}

		private static string Format(object msg)
		{
			return msg.ToString();
		}

		public static void Info(BepInExInfoLogInterpolatedStringHandler handler)
		{
			_Logger.LogInfo(handler);
		}

		public static void Info(string str)
		{
			_Logger.LogMessage((object)str);
		}

		public static void Info(object data)
		{
			_Logger.LogMessage((object)Format(data));
		}

		public static void Debug(BepInExDebugLogInterpolatedStringHandler handler)
		{
			_Logger.LogDebug(handler);
		}

		public static void Debug(string str)
		{
			_Logger.LogDebug((object)str);
		}

		public static void Debug(object data)
		{
			_Logger.LogDebug((object)Format(data));
		}

		public static void Error(BepInExErrorLogInterpolatedStringHandler handler)
		{
			_Logger.LogError(handler);
		}

		public static void Error(string str)
		{
			_Logger.LogError((object)str);
		}

		public static void Error(object data)
		{
			_Logger.LogError((object)Format(data));
		}

		public static void Fatal(BepInExFatalLogInterpolatedStringHandler handler)
		{
			_Logger.LogFatal(handler);
		}

		public static void Fatal(string str)
		{
			_Logger.LogFatal((object)str);
		}

		public static void Fatal(object data)
		{
			_Logger.LogFatal((object)Format(data));
		}

		public static void Warn(BepInExWarningLogInterpolatedStringHandler handler)
		{
			_Logger.LogWarning(handler);
		}

		public static void Warn(string str)
		{
			_Logger.LogWarning((object)str);
		}

		public static void Warn(object data)
		{
			_Logger.LogWarning((object)Format(data));
		}

		[Conditional("DEBUG")]
		public static void DebugOnly(object data)
		{
			_Logger.LogDebug((object)Format(data));
		}
	}
	[GeneratedCode("VersionInfoGenerator", "2.0.0+git50a4b1a-master")]
	[CompilerGenerated]
	internal static class VersionInfo
	{
		public const string RootNamespace = "AWO";

		public const string Version = "2.0.3";

		public const string VersionPrerelease = null;

		public const string VersionMetadata = "git7d2d90c-master";

		public const string SemVer = "2.0.3+git7d2d90c-master";

		public const string GitRevShort = "7d2d90c";

		public const string GitRevLong = "7d2d90cc2386556993e0c3cf79f19ddd9e796db0";

		public const string GitBranch = "master";

		public const string GitTag = null;

		public const bool GitIsDirty = false;
	}
}
namespace AWO.Utils
{
	public static class DictionaryExtensions
	{
		public static TValue GetOrAddNew<TKey, TValue>(this IDictionary<TKey, TValue> dict, TKey key) where TValue : new()
		{
			if (!dict.TryGetValue(key, out TValue value))
			{
				value = (dict[key] = new TValue());
			}
			return value;
		}

		public static void ForEachValue<TKey, TValue>(this Dictionary<TKey, TValue> dict, Action<TValue> action) where TKey : notnull
		{
			foreach (TValue value in dict.Values)
			{
				action(value);
			}
		}

		public static void ForEachValue<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> dict, Action<TValue> action) where TKey : notnull
		{
			foreach (TValue value in dict.Values)
			{
				action(value);
			}
		}
	}
	public static class GameObjectExtensions
	{
		public static bool TryAndGetComponent<T>(this GameObject go, out T component)
		{
			component = go.GetComponent<T>();
			return component != null;
		}

		public static T AddOrGetComponent<T>(this GameObject go) where T : Component
		{
			if (!go.TryAndGetComponent<T>(out var component))
			{
				return go.AddComponent<T>();
			}
			return component;
		}
	}
	public static class LocalizedTextExtensions
	{
		public static string ToText(this LocalizedText text)
		{
			return text.HasTranslation ? Text.Get(text.Id) : text.UntranslatedText;
		}
	}
	public static class RandomExtensions
	{
		public static bool MeetProbability(this Random rand, float prob)
		{
			if (prob >= 1f)
			{
				return true;
			}
			if (prob <= 0f)
			{
				return false;
			}
			return prob >= rand.NextFloat();
		}

		public static float NextRange(this Random rand, float min, float max)
		{
			return rand.NextFloat() * (max - min) + min;
		}

		public static float NextFloat(this Random rand)
		{
			return (float)rand.NextDouble();
		}
	}
}
namespace AWO.Sessions
{
	internal struct BlackoutStatus
	{
		public bool blackoutEnabled;
	}
	internal static class BlackoutState
	{
		private static StateReplicator<BlackoutStatus>? _Replicator;

		public static bool BlackoutEnabled { get; private set; }

		internal static void AssetLoaded()
		{
			if (_Replicator == null)
			{
				_Replicator = StateReplicator<BlackoutStatus>.Create(1u, new BlackoutStatus
				{
					blackoutEnabled = false
				}, LifeTimeType.Permanent);
				_Replicator.OnStateChanged += OnStateChanged;
				LevelAPI.OnLevelCleanup += LevelCleanup;
			}
		}

		private static void LevelCleanup()
		{
			SetEnabled(enabled: false);
		}

		public static void SetEnabled(bool enabled)
		{
			_Replicator?.SetState(new BlackoutStatus
			{
				blackoutEnabled = enabled
			});
		}

		private static void OnStateChanged(BlackoutStatus _, BlackoutStatus state, bool isRecall)
		{
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Invalid comparison between Unknown and I4
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Invalid comparison between Unknown and I4
			bool flag = !state.blackoutEnabled;
			foreach (LG_LabDisplay item in LG_Objects.TrackedList<LG_LabDisplay>())
			{
				if ((Object)(object)((item != null) ? item.m_Text : null) != (Object)null)
				{
					((Behaviour)item.m_Text).enabled = flag;
				}
			}
			foreach (LG_ComputerTerminal item2 in LG_Objects.TrackedList<LG_ComputerTerminal>())
			{
				if ((Object)(object)item2 == (Object)null)
				{
					continue;
				}
				item2.OnProximityExit();
				Interact_ComputerTerminal componentInChildren = ((Component)item2).GetComponentInChildren<Interact_ComputerTerminal>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Behaviour)componentInChildren).enabled = flag;
					((Interact_Base)componentInChildren).SetActive(flag);
				}
				if (((Component)item2).gameObject.TryAndGetComponent<GUIX_VirtualSceneLink>(out var component) && (Object)(object)component.m_virtualScene != (Object)null)
				{
					GUIX_VirtualCamera virtualCamera = component.m_virtualScene.virtualCamera;
					float num = (flag ? 0.3f : 0f);
					float num2 = (flag ? 1000f : 0f);
					virtualCamera.SetFovAndClip(virtualCamera.paramCamera.fieldOfView, num, num2);
				}
				if ((Object)(object)item2.m_text != (Object)null)
				{
					((Behaviour)item2.m_text).enabled = flag;
				}
				if (!flag)
				{
					PlayerAgent localInteractionSource = item2.m_localInteractionSource;
					if ((Object)(object)localInteractionSource != (Object)null && localInteractionSource.FPItemHolder.InTerminalTrigger)
					{
						item2.ExitFPSView();
					}
				}
			}
			foreach (LG_DoorButton item3 in LG_Objects.TrackedList<LG_DoorButton>())
			{
				if ((Object)(object)item3 == (Object)null)
				{
					continue;
				}
				((Component)item3.m_anim).gameObject.SetActive(flag);
				item3.m_enabled = flag;
				if (flag)
				{
					LG_WeakLock componentInChildren2 = ((Component)item3).GetComponentInChildren<LG_WeakLock>();
					if ((Object)(object)componentInChildren2 == (Object)null || (int)componentInChildren2.Status == 3)
					{
						item3.m_enabled = true;
					}
				}
			}
			foreach (LG_WeakLock item4 in LG_Objects.TrackedList<LG_WeakLock>())
			{
				if (!((Object)(object)item4 == (Object)null))
				{
					((Interact_Base)item4.m_intHack).m_isActive = flag;
					Transform val = ((Component)item4).transform.FindChild("HackableLock/SecurityLock/g_WeakLock/Security_Display_Locked") ?? ((Component)item4).transform.FindChild("HackableLock/Security_Display_Locked");
					if ((Object)(object)val != (Object)null)
					{
						((Component)val).gameObject.active = flag;
					}
				}
			}
			foreach (LG_HSUActivator_Core item5 in LG_Objects.TrackedList<LG_HSUActivator_Core>())
			{
				if ((Object)(object)item5 == (Object)null || !item5.m_isWardenObjective || (int)item5.m_stateReplicator.State.status != 0)
				{
					continue;
				}
				item5.m_insertHSUInteraction.SetActive(flag);
				foreach (GameObject item6 in (Il2CppArrayBase<GameObject>)(object)item5.m_activateWhenActive)
				{
					item6.SetActive(flag);
				}
			}
			BlackoutEnabled = state.blackoutEnabled;
		}
	}
	internal enum LevelFailMode
	{
		Default,
		Never,
		AnyPlayerDown
	}
	internal struct LevelFailCheck
	{
		public LevelFailMode mode;
	}
	internal sealed class LevelFailUpdateState
	{
		private static StateReplicator<LevelFailCheck>? _Replicator;

		public static bool LevelFailAllowed { get; private set; } = true;


		public static bool LevelFailWhenAnyPlayerDown { get; private set; } = false;


		internal static void AssetLoaded()
		{
			if (_Replicator == null)
			{
				_Replicator = StateReplicator<LevelFailCheck>.Create(1u, new LevelFailCheck
				{
					mode = LevelFailMode.Default
				}, LifeTimeType.Permanent);
				LG_Factory.OnFactoryBuildStart += Action.op_Implicit((Action)delegate
				{
					_Replicator.ClearAllRecallSnapshot();
					_Replicator.SetState(new LevelFailCheck
					{
						mode = LevelFailMode.Default
					});
				});
				_Replicator.OnStateChanged += OnStateChanged;
				LevelAPI.OnLevelCleanup += LevelCleanup;
			}
		}

		private static void LevelCleanup()
		{
			SetFailAllowed(allowed: true);
		}

		public static void SetFailAllowed(bool allowed)
		{
			_Replicator?.SetState(new LevelFailCheck
			{
				mode = ((!allowed) ? LevelFailMode.Never : LevelFailMode.Default)
			});
		}

		public static void SetFailWhenAnyPlayerDown(bool enabled)
		{
			_Replicator?.SetState(new LevelFailCheck
			{
				mode = (enabled ? LevelFailMode.AnyPlayerDown : LevelFailMode.Default)
			});
		}

		private static void OnStateChanged(LevelFailCheck _, LevelFailCheck state, bool __)
		{
			switch (state.mode)
			{
			case LevelFailMode.Default:
				LevelFailAllowed = true;
				LevelFailWhenAnyPlayerDown = false;
				break;
			case LevelFailMode.Never:
				LevelFailAllowed = false;
				LevelFailWhenAnyPlayerDown = false;
				break;
			case LevelFailMode.AnyPlayerDown:
				LevelFailAllowed = true;
				LevelFailWhenAnyPlayerDown = true;
				break;
			}
		}
	}
	public static class LG_Objects
	{
		public static Dictionary<Type, HashSet<Component>> TrackedTypes { get; private set; }

		static LG_Objects()
		{
			TrackedTypes = new Dictionary<Type, HashSet<Component>>
			{
				{
					typeof(LG_ComputerTerminal),
					new HashSet<Component>()
				},
				{
					typeof(LG_DoorButton),
					new HashSet<Component>()
				},
				{
					typeof(LG_HSUActivator_Core),
					new HashSet<Component>()
				},
				{
					typeof(LG_LabDisplay),
					new HashSet<Component>()
				},
				{
					typeof(LG_WeakLock),
					new HashSet<Component>()
				}
			};
			LevelAPI.OnLevelCleanup += Clear;
		}

		private static void Clear()
		{
			TrackedTypes.ForEachValue<Type, HashSet<Component>>(delegate(HashSet<Component> list)
			{
				list.Clear();
			});
		}

		public static IEnumerable<T> TrackedList<T>() where T : Component
		{
			if (TrackedTypes.TryGetValue(typeof(T), out HashSet<Component> value))
			{
				return value.Cast<T>();
			}
			return Enumerable.Empty<T>();
		}

		public static void AddToTrackedList(Component itemToAdd)
		{
			if (TrackedTypes.TryGetValue(((object)itemToAdd).GetType(), out HashSet<Component> value))
			{
				value.Add(itemToAdd);
			}
		}

		public static void RemoveFromTrackedList(Component itemToRemove)
		{
			if (TrackedTypes.TryGetValue(((object)itemToRemove).GetType(), out HashSet<Component> value))
			{
				value.Remove(itemToRemove);
			}
		}
	}
}
namespace AWO.Sessions.Patches
{
	[HarmonyPatch]
	internal static class Patch_InteractionOnBlackout
	{
		[HarmonyPatch(typeof(LG_ComputerTerminal), "OnProximityEnter")]
		[HarmonyPatch(typeof(LG_ComputerTerminal), "OnProximityExit")]
		[HarmonyPatch(typeof(LG_DoorButton), "OnWeakLockUnlocked")]
		[HarmonyPrefix]
		private static bool Pre_ToggleInteraction()
		{
			return !BlackoutState.BlackoutEnabled;
		}
	}
	[HarmonyPatch]
	internal static class Patch_LevelFailCheck
	{
		[HarmonyPatch(typeof(WardenObjectiveManager), "CheckExpeditionFailed")]
		[HarmonyPostfix]
		[HarmonyAfter(new string[] { })]
		private static void Post_CheckLevelFail(ref bool __result)
		{
			if (!LevelFailUpdateState.LevelFailAllowed)
			{
				__result = false;
			}
			else if (LevelFailUpdateState.LevelFailWhenAnyPlayerDown && HasAnyDownedPlayer())
			{
				__result = true;
			}
		}

		private static bool HasAnyDownedPlayer()
		{
			Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
			while (enumerator.MoveNext())
			{
				PlayerAgent current = enumerator.Current;
				if (!((Agent)current).Alive)
				{
					return true;
				}
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class Patch_LG_ObjectsTrack
	{
		[HarmonyTargetMethods]
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(LG_ComputerTerminal), "Setup", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(LG_DoorButton), "Setup", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(LG_HSUActivator_Core), "Start", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(LG_LabDisplay), "GenerateText", new Type[2]
			{
				typeof(int),
				typeof(SubComplex)
			}, (Type[])null);
			yield return AccessTools.Method(typeof(LG_WeakLock), "Setup", (Type[])null, (Type[])null);
		}

		[HarmonyPostfix]
		private static void Post_TrackObject(Component __instance)
		{
			LG_Objects.AddToTrackedList(__instance);
		}
	}
}
namespace AWO.Networking
{
	public interface IStateReplicatorHolder<S> where S : struct
	{
		StateReplicator<S> Replicator { get; }

		void OnStateChange(S oldState, S state, bool isRecall);
	}
	public sealed class ReplicatorHandshake
	{
		public delegate void ClientRequestedSyncDel(SNet_Player requestedPlayer);

		public struct Packet
		{
			public uint replicatorID;

			public PacketAction action;
		}

		public enum PacketAction : byte
		{
			Created,
			Destroyed,
			SyncRequest
		}

		public sealed class Data
		{
			public bool SetupOnHost = false;

			public bool SetupOnClient = false;
		}

		private readonly Dictionary<uint, Data> _Lookup = new Dictionary<uint, Data>();

		public string EventName { get; private set; }

		public bool IsReadyToSync { get; private set; }

		public event ClientRequestedSyncDel OnClientSyncRequested;

		public static ReplicatorHandshake Create(string guid)
		{
			if (string.IsNullOrWhiteSpace(guid))
			{
				return null;
			}
			string text = "RHs" + guid;
			return NetworkAPI.IsEventRegistered(text) ? null : new ReplicatorHandshake(text);
		}

		private ReplicatorHandshake(string eventName)
		{
			EventName = eventName;
			NetworkAPI.RegisterEvent<Packet>(eventName, (Action<ulong, Packet>)OnSyncAction);
		}

		public void Reset()
		{
			_Lookup.Clear();
		}

		private void OnSyncAction(ulong sender, Packet packet)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			if (!SNet.IsMaster && sender == SNet.Master.Lookup)
			{
				if (packet.action == PacketAction.Created)
				{
					SetHostState(packet.replicatorID, isSetup: true);
				}
				else if (packet.action == PacketAction.Destroyed)
				{
					SetHostState(packet.replicatorID, isSetup: false);
				}
			}
			else
			{
				if (!SNet.IsMaster)
				{
					return;
				}
				if (packet.action == PacketAction.Created)
				{
					SetClientState(packet.replicatorID, isSetup: true);
				}
				else if (packet.action == PacketAction.Destroyed)
				{
					SetClientState(packet.replicatorID, isSetup: false);
				}
				else
				{
					if (packet.action != PacketAction.SyncRequest)
					{
						return;
					}
					SNet_Player requestedPlayer = default(SNet_Player);
					if (!SNet.TryGetPlayer(sender, ref requestedPlayer))
					{
						bool flag = default(bool);
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(32, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Cannot find player from sender: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ulong>(sender);
						}
						Logger.Error(val);
					}
					else
					{
						this.OnClientSyncRequested?.Invoke(requestedPlayer);
					}
				}
			}
		}

		public void UpdateCreated(uint id)
		{
			if (SNet.IsInLobby)
			{
				if (SNet.IsMaster)
				{
					SetHostState(id, isSetup: true);
					NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
					{
						replicatorID = id,
						action = PacketAction.Created
					}, (SNet_ChannelType)2);
				}
				else if (SNet.HasMaster)
				{
					SetClientState(id, isSetup: true);
					NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
					{
						replicatorID = id,
						action = PacketAction.Created
					}, SNet.Master, (SNet_ChannelType)2);
				}
				else
				{
					Logger.Error("Handshake::MASTER is NULL in lobby; This should NOT happen!!!!!!!!!!!!");
				}
			}
			else
			{
				Logger.Error("Handshake::Session Type StateReplicator cannot be created without lobby!");
			}
		}

		public void UpdateDestroyed(uint id)
		{
			if (SNet.IsInLobby)
			{
				if (SNet.IsMaster)
				{
					SetHostState(id, isSetup: true);
					NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
					{
						replicatorID = id,
						action = PacketAction.Destroyed
					}, (SNet_ChannelType)2);
				}
				else if (SNet.HasMaster)
				{
					SetClientState(id, isSetup: true);
					NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
					{
						replicatorID = id,
						action = PacketAction.Destroyed
					}, SNet.Master, (SNet_ChannelType)2);
				}
				else
				{
					Logger.Error("Handshake::MASTER is NULL in lobby; This should NOT happen!!!!!!!!!!!!");
				}
			}
			else
			{
				Logger.Error("Handshake::Session Type StateReplicator cannot be created without lobby!");
			}
		}

		private void SetHostState(uint id, bool isSetup)
		{
			if (_Lookup.TryGetValue(id, out Data value))
			{
				value.SetupOnHost = isSetup;
			}
			else
			{
				_Lookup[id] = new Data
				{
					SetupOnHost = isSetup
				};
			}
			UpdateSyncState(id);
		}

		private void SetClientState(uint id, bool isSetup)
		{
			if (_Lookup.TryGetValue(id, out Data value))
			{
				value.SetupOnClient = isSetup;
			}
			else
			{
				_Lookup[id] = new Data
				{
					SetupOnClient = isSetup
				};
			}
			UpdateSyncState(id);
		}

		private void UpdateSyncState(uint id)
		{
			bool isReadyToSync = IsReadyToSync;
			if (_Lookup.TryGetValue(id, out Data value))
			{
				IsReadyToSync = value.SetupOnHost && value.SetupOnClient;
			}
			else
			{
				IsReadyToSync = false;
			}
			if (IsReadyToSync && isReadyToSync != IsReadyToSync && SNet.HasMaster && !SNet.IsMaster)
			{
				NetworkAPI.InvokeEvent<Packet>(EventName, new Packet
				{
					replicatorID = id,
					action = PacketAction.SyncRequest
				}, SNet.Master, (SNet_ChannelType)2);
			}
		}
	}
	public delegate void OnReceiveDel<S>(ulong sender, uint replicatorID, S newState) where S : struct;
	public static class StatePayloads
	{
		public enum Size
		{
			State4Byte = 4,
			State8Byte = 8,
			State16Byte = 16,
			State32Byte = 32,
			State48Byte = 48,
			State64Byte = 64,
			State80Byte = 80,
			State96Byte = 96,
			State128Byte = 128,
			State196Byte = 196,
			State256Byte = 256
		}

		public static Size GetSizeType(int size)
		{
			Size size2 = Size.State8Byte;
			foreach (object value in Enum.GetValues(typeof(Size)))
			{
				if (size <= (int)value && (int)size2 < (int)value)
				{
					size2 = (Size)value;
					break;
				}
			}
			return size2;
		}

		public static IReplicatorEvent<S> CreateEvent<S>(Size size, string eventName, OnReceiveDel<S> onReceiveCallback) where S : struct
		{
			return size switch
			{
				Size.State4Byte => ReplicatorPayloadWrapper<S, StatePayload4Byte>.Create(eventName, onReceiveCallback), 
				Size.State8Byte => ReplicatorPayloadWrapper<S, StatePayload8Byte>.Create(eventName, onReceiveCallback), 
				Size.State16Byte => ReplicatorPayloadWrapper<S, StatePayload16Byte>.Create(eventName, onReceiveCallback), 
				Size.State32Byte => ReplicatorPayloadWrapper<S, StatePayload32Byte>.Create(eventName, onReceiveCallback), 
				Size.State48Byte => ReplicatorPayloadWrapper<S, StatePayload48Byte>.Create(eventName, onReceiveCallback), 
				Size.State64Byte => ReplicatorPayloadWrapper<S, StatePayload64Byte>.Create(eventName, onReceiveCallback), 
				Size.State80Byte => ReplicatorPayloadWrapper<S, StatePayload80Byte>.Create(eventName, onReceiveCallback), 
				Size.State96Byte => ReplicatorPayloadWrapper<S, StatePayload96Byte>.Create(eventName, onReceiveCallback), 
				Size.State128Byte => ReplicatorPayloadWrapper<S, StatePayload128Byte>.Create(eventName, onReceiveCallback), 
				Size.State196Byte => ReplicatorPayloadWrapper<S, StatePayload196Byte>.Create(eventName, onReceiveCallback), 
				Size.State256Byte => ReplicatorPayloadWrapper<S, StatePayload256Byte>.Create(eventName, onReceiveCallback), 
				_ => null, 
			};
		}

		public static S Get<S>(byte[] bytes, int bytesLength) where S : struct
		{
			int num = Marshal.SizeOf(typeof(S));
			if (num > bytesLength)
			{
				throw new ArgumentException($"StateData Exceed size of {bytesLength} : Unable to Deserialize", "S");
			}
			IntPtr intPtr = Marshal.AllocHGlobal(num);
			Marshal.Copy(bytes, 0, intPtr, num);
			S result = (S)Marshal.PtrToStructure(intPtr, typeof(S));
			Marshal.FreeHGlobal(intPtr);
			return result;
		}

		public static void Set<S>(S stateData, int size, ref byte[] payloadBytes) where S : struct
		{
			int num = Marshal.SizeOf(stateData);
			if (num > size)
			{
				throw new ArgumentException($"StateData Exceed size of {size} : Unable to Serialize", "S");
			}
			byte[] array = new byte[size];
			IntPtr intPtr = Marshal.AllocHGlobal(size);
			Marshal.StructureToPtr(stateData, intPtr, fDeleteOld: false);
			Marshal.Copy(intPtr, array, 0, size);
			Marshal.FreeHGlobal(intPtr);
			payloadBytes = array;
		}
	}
	public interface IReplicatorEvent<S> where S : struct
	{
		string Name { get; }

		bool IsRegistered { get; }

		void Invoke(uint replicatorID, S data);

		void Invoke(uint replicatorID, S data, SNet_ChannelType channelType);

		void Invoke(uint replicatorID, S data, SNet_Player target);

		void Invoke(uint replicatorID, S data, SNet_Player target, SNet_ChannelType channelType);
	}
	public class ReplicatorPayloadWrapper<S, P> : IReplicatorEvent<S> where S : struct where P : struct, IStatePayload
	{
		public string Name { get; private set; }

		public bool IsRegistered { get; private set; } = false;


		public static IReplicatorEvent<S> Create(string eventName, OnReceiveDel<S> onReceiveCallback)
		{
			ReplicatorPayloadWrapper<S, P> replicatorPayloadWrapper = new ReplicatorPayloadWrapper<S, P>();
			replicatorPayloadWrapper.Register(eventName, onReceiveCallback);
			object result;
			if (!replicatorPayloadWrapper.IsRegistered)
			{
				result = null;
			}
			else
			{
				IReplicatorEvent<S> replicatorEvent = replicatorPayloadWrapper;
				result = replicatorEvent;
			}
			return (IReplicatorEvent<S>)result;
		}

		public void Register(string eventName, OnReceiveDel<S> onReceiveCallback)
		{
			OnReceiveDel<S> onReceiveCallback2 = onReceiveCallback;
			if (!IsRegistered && !NetworkAPI.IsEventRegistered(eventName))
			{
				NetworkAPI.RegisterEvent<P>(eventName, (Action<ulong, P>)delegate(ulong sender, P payload)
				{
					onReceiveCallback2?.Invoke(sender, payload.ID, payload.Get<S>());
				});
				IsRegistered = true;
				Name = eventName;
			}
		}

		public void Invoke(uint replicatorID, S data)
		{
			P val = new P
			{
				ID = replicatorID
			};
			val.Set(data);
			NetworkAPI.InvokeEvent<P>(Name, val, (SNet_ChannelType)2);
		}

		public void Invoke(uint replicatorID, S data, SNet_ChannelType channelType)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			P val = new P
			{
				ID = replicatorID
			};
			val.Set(data);
			NetworkAPI.InvokeEvent<P>(Name, val, channelType);
		}

		public void Invoke(uint replicatorID, S data, SNet_Player target)
		{
			P val = new P
			{
				ID = replicatorID
			};
			val.Set(data);
			NetworkAPI.InvokeEvent<P>(Name, val, target, (SNet_ChannelType)2);
		}

		public void Invoke(uint replicatorID, S data, SNet_Player target, SNet_ChannelType channelType)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			P val = new P
			{
				ID = replicatorID
			};
			val.Set(data);
			NetworkAPI.InvokeEvent<P>(Name, val, target, channelType);
		}
	}
	public interface IStatePayload
	{
		uint ID { get; set; }

		S Get<S>() where S : struct;

		void Set<S>(S stateData) where S : struct;
	}
	public struct StatePayload4Byte : IStatePayload
	{
		public const int Size = 4;

		private uint id;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
		public byte[] PayloadBytes;

		public uint ID
		{
			get
			{
				return id;
			}
			set
			{
				id = value;
			}
		}

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 4);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 4, ref PayloadBytes);
		}
	}
	public struct StatePayload8Byte : IStatePayload
	{
		public const int Size = 8;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
		public byte[] PayloadBytes;

		[field: MarshalAs(UnmanagedType.U4)]
		public uint ID { get; set; }

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 8);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 8, ref PayloadBytes);
		}
	}
	public struct StatePayload16Byte : IStatePayload
	{
		public const int Size = 16;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
		public byte[] PayloadBytes;

		[field: MarshalAs(UnmanagedType.U4)]
		public uint ID { get; set; }

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 16);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 16, ref PayloadBytes);
		}
	}
	public struct StatePayload32Byte : IStatePayload
	{
		public const int Size = 32;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
		public byte[] PayloadBytes;

		[field: MarshalAs(UnmanagedType.U4)]
		public uint ID { get; set; }

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 32);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 32, ref PayloadBytes);
		}
	}
	public struct StatePayload48Byte : IStatePayload
	{
		public const int Size = 48;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 48)]
		public byte[] PayloadBytes;

		[field: MarshalAs(UnmanagedType.U4)]
		public uint ID { get; set; }

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 48);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 48, ref PayloadBytes);
		}
	}
	public struct StatePayload64Byte : IStatePayload
	{
		public const int Size = 64;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
		public byte[] PayloadBytes;

		[field: MarshalAs(UnmanagedType.U4)]
		public uint ID { get; set; }

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 64);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 64, ref PayloadBytes);
		}
	}
	public struct StatePayload80Byte : IStatePayload
	{
		public const int Size = 80;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 80)]
		public byte[] PayloadBytes;

		[field: MarshalAs(UnmanagedType.U4)]
		public uint ID { get; set; }

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 80);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 80, ref PayloadBytes);
		}
	}
	public struct StatePayload96Byte : IStatePayload
	{
		public const int Size = 96;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 96)]
		public byte[] PayloadBytes;

		[field: MarshalAs(UnmanagedType.U4)]
		public uint ID { get; set; }

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 96);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 96, ref PayloadBytes);
		}
	}
	public struct StatePayload128Byte : IStatePayload
	{
		public const int Size = 128;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
		public byte[] PayloadBytes;

		[field: MarshalAs(UnmanagedType.U4)]
		public uint ID { get; set; }

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 128);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 128, ref PayloadBytes);
		}
	}
	public struct StatePayload196Byte : IStatePayload
	{
		public const int Size = 196;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 196)]
		public byte[] PayloadBytes;

		[field: MarshalAs(UnmanagedType.U4)]
		public uint ID { get; set; }

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 196);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 196, ref PayloadBytes);
		}
	}
	public struct StatePayload256Byte : IStatePayload
	{
		public const int Size = 256;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
		public byte[] PayloadBytes;

		[field: MarshalAs(UnmanagedType.U4)]
		public uint ID { get; set; }

		public S Get<S>() where S : struct
		{
			return StatePayloads.Get<S>(PayloadBytes, 256);
		}

		public void Set<S>(S stateData) where S : struct
		{
			StatePayloads.Set(stateData, 256, ref PayloadBytes);
		}
	}
	public enum LifeTimeType
	{
		Permanent,
		Session
	}
	public sealed class StateReplicator<S> where S : struct
	{
		private readonly Dictionary<eBufferType, S> _RecallStateSnapshots = new Dictionary<eBufferType, S>();

		public static readonly string Name;

		public static readonly string HashName;

		public static readonly string ClientRequestEventName;

		public static readonly string HostSetStateEventName;

		public static readonly string HostSetRecallStateEventName;

		public static readonly int StateSize;

		public static readonly StatePayloads.Size StateSizeType;

		private static readonly IReplicatorEvent<S> _C_RequestEvent;

		private static readonly IReplicatorEvent<S> _H_SetStateEvent;

		private static readonly IReplicatorEvent<S> _H_SetRecallStateEvent;

		private static readonly ReplicatorHandshake _Handshake;

		private static readonly Dictionary<uint, StateReplicator<S>> _Replicators;

		public bool IsValid => ID != 0;

		public bool IsInvalid => ID == 0;

		public uint ID { get; private set; }

		public LifeTimeType LifeTime { get; private set; }

		public IStateReplicatorHolder<S> Holder { get; private set; }

		public S State { get; private set; }

		public bool ClientSendStateAllowed { get; set; } = true;


		public bool CanSendToClient => SNet.IsInLobby && SNet.IsMaster;

		public bool CanSendToHost => SNet.IsInLobby && !SNet.IsMaster && SNet.HasMaster && ClientSendStateAllowed;

		public event Action<S, S, bool> OnStateChanged;

		public void SetState(S state)
		{
			if (!IsInvalid)
			{
				DoSync(state);
			}
		}

		public void SetStateUnsynced(S state)
		{
			if (!IsInvalid)
			{
				State = state;
			}
		}

		public void Unload()
		{
			if (IsValid)
			{
				_Replicators.Remove(ID);
				_RecallStateSnapshots.Clear();
				_Handshake.UpdateDestroyed(ID);
				ID = 0u;
			}
		}

		private void DoSync(S newState)
		{
			if (!IsInvalid)
			{
				if (CanSendToClient)
				{
					_H_SetStateEvent.Invoke(ID, newState);
					Internal_ChangeState(newState, isRecall: false);
				}
				else if (CanSendToHost)
				{
					_C_RequestEvent.Invoke(ID, newState, SNet.Master);
				}
			}
		}

		private void Internal_ChangeState(S state, bool isRecall)
		{
			if (!IsInvalid)
			{
				S state2 = State;
				State = state;
				this.OnStateChanged?.Invoke(state2, state, isRecall);
				Holder?.OnStateChange(state2, state, isRecall);
			}
		}

		private void SendDropInState(SNet_Player target)
		{
			if (!IsInvalid)
			{
				if ((Object)(object)target == (Object)null)
				{
					Logger.Error("SendDropInState::Target was null??");
				}
				else
				{
					_H_SetRecallStateEvent.Invoke(ID, State, target);
				}
			}
		}

		public void ClearAllRecallSnapshot()
		{
			if (!IsInvalid)
			{
				_RecallStateSnapshots.Clear();
			}
		}

		private void SaveSnapshot(eBufferType type)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!IsInvalid)
			{
				_RecallStateSnapshots[type] = State;
			}
		}

		private void RestoreSnapshot(eBufferType type)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (IsInvalid || !CanSendToClient)
			{
				return;
			}
			if (_RecallStateSnapshots.TryGetValue(type, out var value))
			{
				_H_SetRecallStateEvent.Invoke(ID, value);
				Internal_ChangeState(value, isRecall: true);
				return;
			}
			bool flag = default(bool);
			BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(29, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("RestoreSnapshot");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("::There was no snapshot for ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<eBufferType>(type);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("?");
			}
			Logger.Error(val);
		}

		static StateReplicator()
		{
			_Replicators = new Dictionary<uint, StateReplicator<S>>();
			Name = typeof(S).Name;
			StateSize = Marshal.SizeOf(typeof(S));
			StateSizeType = StatePayloads.GetSizeType(StateSize);
			using MD5 mD = MD5.Create();
			byte[] inArray = mD.ComputeHash(Encoding.UTF8.GetBytes(typeof(S).FullName));
			HashName = Convert.ToBase64String(inArray);
			ClientRequestEventName = "SRs" + Name + "-" + HashName;
			HostSetStateEventName = "SRr" + Name + "-" + HashName;
			HostSetRecallStateEventName = "SRre" + Name + "-" + HashName;
			_C_RequestEvent = StatePayloads.CreateEvent<S>(StateSizeType, ClientRequestEventName, ClientRequestEventCallback);
			_H_SetStateEvent = StatePayloads.CreateEvent<S>(StateSizeType, HostSetStateEventName, HostSetStateEventCallback);
			_H_SetRecallStateEvent = StatePayloads.CreateEvent<S>(StateSizeType, HostSetRecallStateEventName, HostSetRecallStateEventCallback);
			_Handshake = ReplicatorHandshake.Create(Name + "-" + HashName);
			_Handshake.OnClientSyncRequested += ClientSyncRequested;
			Patch_SNet_Capture.OnBufferCapture += BufferStored;
			Patch_SNet_Capture.OnBufferRecalled += BufferRecalled;
			LevelAPI.OnLevelCleanup += LevelCleanedUp;
		}

		private static void ClientSyncRequested(SNet_Player requestedPlayer)
		{
			foreach (StateReplicator<S> value in _Replicators.Values)
			{
				if (value.IsValid)
				{
					value.SendDropInState(requestedPlayer);
				}
			}
		}

		private static void BufferStored(eBufferType type)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			foreach (StateReplicator<S> value in _Replicators.Values)
			{
				if (value.IsValid)
				{
					value.SaveSnapshot(type);
				}
			}
		}

		private static void BufferRecalled(eBufferType type)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			foreach (StateReplicator<S> value in _Replicators.Values)
			{
				if (value.IsValid)
				{
					value.RestoreSnapshot(type);
				}
			}
		}

		private static void LevelCleanedUp()
		{
			UnloadSessionReplicator();
		}

		private StateReplicator()
		{
		}

		public static StateReplicator<S> Create(uint replicatorID, S startState, LifeTimeType lifeTime, IStateReplicatorHolder<S> holder = null)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			if (replicatorID == 0)
			{
				Logger.Error("Replicator ID 0 is reserved for empty!");
				return null;
			}
			if (_Replicators.ContainsKey(replicatorID))
			{
				Logger.Error("Replicator ID has already assigned!");
				return null;
			}
			StateReplicator<S> stateReplicator = new StateReplicator<S>
			{
				ID = replicatorID,
				LifeTime = lifeTime,
				Holder = holder,
				State = startState
			};
			switch (lifeTime)
			{
			case LifeTimeType.Permanent:
				Logger.Debug("LifeTime is Permanent :: Handshaking is disabled!");
				break;
			case LifeTimeType.Session:
				_Handshake.UpdateCreated(replicatorID);
				break;
			default:
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(22, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("LifeTime is invalid!: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<LifeTimeType>(lifeTime);
				}
				Logger.Error(val);
				return null;
			}
			}
			_Replicators[replicatorID] = stateReplicator;
			return stateReplicator;
		}

		public static void UnloadSessionReplicator()
		{
			List<uint> list = new List<uint>();
			foreach (StateReplicator<S> value in _Replicators.Values)
			{
				if (value.LifeTime == LifeTimeType.Session)
				{
					list.Add(value.ID);
					value.Unload();
				}
			}
			foreach (uint item in list)
			{
				_Replicators.Remove(item);
			}
			_Handshake.Reset();
		}

		private static void ClientRequestEventCallback(ulong sender, uint replicatorID, S newState)
		{
			if (SNet.IsMaster && _Replicators.TryGetValue(replicatorID, out StateReplicator<S> value))
			{
				value.SetState(newState);
			}
		}

		private static void HostSetStateEventCallback(ulong sender, uint replicatorID, S newState)
		{
			if (SNet.HasMaster && SNet.Master.Lookup == sender && _Replicators.TryGetValue(replicatorID, out StateReplicator<S> value))
			{
				value.Internal_ChangeState(newState, isRecall: false);
			}
		}

		private static void HostSetRecallStateEventCallback(ulong sender, uint replicatorID, S newState)
		{
			if (SNet.HasMaster && SNet.Master.Lookup == sender && _Replicators.TryGetValue(replicatorID, out StateReplicator<S> value))
			{
				value.Internal_ChangeState(newState, isRecall: true);
			}
		}
	}
}
namespace AWO.Networking.Patch
{
	[HarmonyPatch(typeof(SNet_Capture))]
	internal static class Patch_SNet_Capture
	{
		public static event Action<eBufferType>? OnBufferCapture;

		public static event Action<eBufferType>? OnBufferRecalled;

		[HarmonyPatch("TriggerCapture")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void Pre_TriggerCapture(SNet_Capture __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			eBufferType primedBufferType = __instance.PrimedBufferType;
			Patch_SNet_Capture.OnBufferCapture?.Invoke(primedBufferType);
		}

		[HarmonyPatch("RecallBuffer")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Post_RecallBuffer(SNet_Capture __instance, eBufferType bufferType)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.IsRecalling)
			{
				Patch_SNet_Capture.OnBufferRecalled?.Invoke(bufferType);
			}
		}
	}
}
namespace AWO.Modules.WOE
{
	[Obsolete]
	public static class WardenObjectiveExt
	{
		private static readonly Dictionary<eWardenObjectiveType, Type> _DTOTypes;

		private static readonly List<WOE_ContextBase> _ActiveContexts;

		static WardenObjectiveExt()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			_DTOTypes = new Dictionary<eWardenObjectiveType, Type>();
			_ActiveContexts = new List<WOE_ContextBase>();
			IEnumerable<Type> enumerable = from x in typeof(WOE_ContextBase).Assembly.GetTypes()
				where !x.IsAbstract
				where x.IsAssignableTo(typeof(WOE_ContextBase))
				select x;
			bool flag = default(bool);
			foreach (Type item in enumerable)
			{
				WOE_ContextBase wOE_ContextBase = (WOE_ContextBase)Activator.CreateInstance(item);
				if (_DTOTypes.TryGetValue(wOE_ContextBase.TargetType, out Type _))
				{
					Logger.Error("Duplicate TargetType Detected!");
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(14, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("With '");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' and '");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(wOE_ContextBase.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'");
					}
					Logger.Error(val);
				}
				else if (!wOE_ContextBase.DataType.IsAssignableTo(typeof(WOE_DataBase)))
				{
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(41, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" does not have valid ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("DataType");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (not derived from ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("WOE_DataBase");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
					}
					Logger.Error(val);
				}
				else
				{
					_DTOTypes[wOE_ContextBase.TargetType] = item;
				}
			}
			WOEvents.OnSetup += ObjectiveSetup;
			LevelAPI.OnLevelCleanup += LevelCleanup;
		}

		internal static void Initialize()
		{
		}

		private static void ObjectiveSetup(LG_LayerType layer, int chainIndex)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			WardenObjectiveDataBlock val = default(WardenObjectiveDataBlock);
			Type value;
			if (!WardenObjectiveManager.TryGetWardenObjectiveDataForLayer(layer, chainIndex, ref val))
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(44, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<LG_LayerType>(layer);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" Layer (CI: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(chainIndex);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(") does not have ObjectiveData!!!");
				}
				Logger.Error(val2);
			}
			else if (_DTOTypes.TryGetValue(val.Type, out value))
			{
				WOE_ContextBase wOE_ContextBase = (WOE_ContextBase)Activator.CreateInstance(value);
				wOE_ContextBase.Setup(layer, chainIndex);
				_ActiveContexts.Add(wOE_ContextBase);
			}
		}

		private static void LevelCleanup()
		{
			foreach (WOE_ContextBase activeContext in _ActiveContexts)
			{
				activeContext.OnLevelCleanup();
			}
			_ActiveContexts.Clear();
		}
	}
	public delegate void SetupObjectiveDel(LG_LayerType layer, int chainIndex);
	[Obsolete]
	internal static class WOEvents
	{
		public static event SetupObjectiveDel? OnSetup;

		internal static void Invoke_OnSetup(LG_LayerType layer, int chainIndex)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			WOEvents.OnSetup?.Invoke(layer, chainIndex);
		}
	}
	[Obsolete]
	internal abstract class WOE_ContextBase
	{
		public abstract eWardenObjectiveType TargetType { get; }

		public abstract Type DataType { get; }

		protected WOE_DataBase? Data { get; private set; }

		protected LG_LayerType Layer { get; private set; }

		protected int ChainIndex { get; private set; }

		public void Setup(LG_LayerType layer, int chainIndex)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Layer = layer;
			ChainIndex = chainIndex;
		}

		public virtual void OnSetup()
		{
		}

		public virtual void OnBuildDone()
		{
		}

		public virtual void OnBuildDoneLate()
		{
		}

		public virtual void OnLevelCleanup()
		{
		}
	}
	[Obsolete]
	internal abstract class WOE_DataBase
	{
		public uint ObjectiveID { get; set; }

		public WardenObjectiveDataBlock? GameData { get; set; }
	}
}
namespace AWO.Modules.WOE.Objectives.Uplinks
{
	[Obsolete]
	internal sealed class WOE_UplinkContext : WOE_ContextBase
	{
		public override eWardenObjectiveType TargetType => (eWardenObjectiveType)8;

		public override Type DataType => typeof(WOE_UplinkData);
	}
	[Obsolete]
	internal sealed class WOE_UplinkData : WOE_DataBase
	{
		public UplinkCodeBehaviour[] CodeBehaviours { get; set; } = Array.Empty<UplinkCodeBehaviour>();

	}
	internal sealed class UplinkCodeBehaviour
	{
		public bool ShowCodesOnTerminal { get; set; } = false;


		public bool ShowCodesOnHUD { get; set; } = true;


		public bool ShowCodeToOtherTerminal { get; set; } = true;


		public TerminalZoneSelectionData TerminalZone { get; set; } = new TerminalZoneSelectionData();


		public TerminalOutput[] StartOutputs { get; set; } = Array.Empty<TerminalOutput>();


		public TerminalOutput[] EndOutputs { get; set; } = Array.Empty<TerminalOutput>();


		public WardenObjectiveEventData[] EventsOnStart { get; set; } = Array.Empty<WardenObjectiveEventData>();


		public WardenObjectiveEventData[] EventsOnEnd { get; set; } = Array.Empty<WardenObjectiveEventData>();

	}
}
namespace AWO.Modules.WOE.Objectives.ReactorStartups
{
	[Obsolete]
	internal sealed class WOE_ReactorStartupContext : WOE_ContextBase
	{
		public override eWardenObjectiveType TargetType => (eWardenObjectiveType)1;

		public override Type DataType => typeof(WOE_ReactorStartupData);
	}
	internal enum ReactorWavePuzzleType
	{
		Default,
		CustomLock,
		UseCommand_OnMainTerminal,
		UseCommand_InZone,
		PowerGenerator_InZone
	}
	[Obsolete]
	internal sealed class WOE_ReactorStartupData : WOE_DataBase
	{
		public bool RemoveMainStartupCommand { get; set; } = false;


		public bool RemoveMainVerifyCommand { get; set; } = false;


		public ScriptedWaveData[] WaveDatas { get; set; } = Array.Empty<ScriptedWaveData>();


		public ReactorWavePuzzleData[] WavePuzzles { get; set; } = Array.Empty<ReactorWavePuzzleData>();

	}
	internal enum SettingWarpMode
	{
		Clamped,
		Repeat,
		PingPong
	}
	internal sealed class ScriptedWaveData
	{
		public float[] IntroDuration { get; set; } = Array.Empty<float>();


		public SettingWarpMode IntroDurationWarpMode { get; set; } = SettingWarpMode.Clamped;


		public float[] WaveDuration { get; set; } = Array.Empty<float>();


		public SettingWarpMode WaveDurationWarpMode { get; set; } = SettingWarpMode.Clamped;


		public string[][] WaveInstructions { get; set; } = Array.Empty<string[]>();


		public SettingWarpMode WaveInstructionsWarpMode { get; set; } = SettingWarpMode.Clamped;

	}
	internal sealed class ReactorWavePuzzleData
	{
		public ReactorWavePuzzleType Type { get; set; } = ReactorWavePuzzleType.Default;


		public bool ShowBeacon { get; set; } = false;


		public string BeaconText { get; set; } = "Auxiliary Terminal";


		public Color BeaconColor { get; set; } = Color.magenta;


		public string Command { get; set; } = "REACTOR_CONTINUE";


		public string CommandDescription { get; set; } = "CONTINUE REACTOR STARTUP PROCESS";


		public bool ForceJumpWaveWhenSolved { get; set; } = true;

	}
}
namespace AWO.Modules.WOE.Objectives.GenClusters
{
	[Obsolete]
	internal sealed class WOE_GenClusterContext : WOE_ContextBase
	{
		public override eWardenObjectiveType TargetType => (eWardenObjectiveType)9;

		public override Type DataType => typeof(int);
	}
}
namespace AWO.Modules.WOE.JsonInjects
{
	[Obsolete]
	internal class ObjectiveDataHandler : Il2CppJsonReferenceTypeHandler<WardenObjectiveDataBlock>
	{
		public override void OnRead(in Object result, in JToken jToken)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			if ((int)jToken.Type == 1)
			{
				JObject val = (JObject)jToken;
				JToken val2 = default(JToken);
				if (val.TryGetValue("woeEnabled", ref val2) && (int)val2.Type == 9 && (bool)val2)
				{
					WardenObjectiveDataBlock val3 = ((Il2CppObjectBase)result).Cast<WardenObjectiveDataBlock>();
				}
			}
		}
	}
}
namespace AWO.Modules.WEE
{
	public static class VanillaEventOvr
	{
		internal static bool HasOverride(eWardenObjectiveEventType type, WardenObjectiveEventData e)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			bool flag = e.Position != Vector3.zero;
			if ((int)type != 5)
			{
				if ((int)type == 16)
				{
					return flag || e.Count > 0;
				}
				return false;
			}
			return flag;
		}

		internal static void HandleEvent(eWardenObjectiveEventType type, WardenObjectiveEventData e, float currentDuration)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(Handle(type, e, currentDuration)), (Action)null);
		}

		private static IEnumerator Handle(eWardenObjectiveEventType type, WardenObjectiveEventData e, float currentDuration)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			float delay = Mathf.Max(e.Delay - currentDuration, 0f);
			if (delay > 0f)
			{
				yield return (object)new WaitForSeconds(delay);
			}
			if (WorldEventManager.GetCondition(e.Condition.ConditionIndex) != e.Condition.IsTrue)
			{
				yield break;
			}
			WardenObjectiveManager.DisplayWardenIntel(e.Layer, e.WardenIntel);
			if (e.DialogueID != 0)
			{
				PlayerDialogManager.WantToStartDialog(e.DialogueID, -1, false, false);
			}
			if ((int)type != 5)
			{
				if ((int)type == 16)
				{
					CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(SpawnEnemyOnPoint(e)), (Action)null);
				}
			}
			else
			{
				PlaySound(e);
			}
		}

		private static void PlaySound(WardenObjectiveEventData e)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (e.SoundID != 0)
			{
				CellSoundPlayer val = new CellSoundPlayer();
				val.Post(e.SoundID, e.Position, 1u, EventCallback.op_Implicit((Action<Object, AkCallbackType, AkCallbackInfo>)SoundDoneCallback), (Object)(object)val);
				string text = ((Object)e.SoundSubtitle).ToString();
				if (!string.IsNullOrWhiteSpace(text))
				{
					GuiManager.PlayerLayer.ShowMultiLineSubtitle(text);
				}
			}
		}

		private static void SoundDoneCallback(Object in_cookie, AkCallbackType in_type, AkCallbackInfo callbackInfo)
		{
			CellSoundPlayer val = ((Il2CppObjectBase)in_cookie).Cast<CellSoundPlayer>();
			if (val != null)
			{
				val.Recycle();
			}
		}

		private static IEnumerator SpawnEnemyOnPoint(WardenObjectiveEventData e)
		{
			if (e.SoundID != 0)
			{
				WardenObjectiveManager.Current.m_sound.Post(e.SoundID, true);
				string line = ((Object)e.SoundSubtitle).ToString();
				if (!string.IsNullOrWhiteSpace(line))
				{
					GuiManager.PlayerLayer.ShowMultiLineSubtitle(line);
				}
			}
			if (!SNet.IsMaster)
			{
				yield break;
			}
			int count = ((e.Count < 2) ? 1 : e.Count);
			LG_WorldEventObject weObject = default(LG_WorldEventObject);
			Vector3 pos = (WorldEventUtils.TryGetRandomWorldEventObjectFromFilter(e.WorldEventObjectFilter, (uint)Builder.SessionSeedRandom.Seed, ref weObject) ? ((Component)weObject).gameObject.transform.position : e.Position);
			AIG_CourseNode courseNode = default(AIG_CourseNode);
			if (!Dimension.TryGetCourseNodeFromPos(pos, ref courseNode))
			{
				Logger.Error("[SpawnEnemyOnPoint] Failed to find valid CourseNode from Position!");
				yield break;
			}
			AgentMode val = ((!e.Enabled) ? ((e.EnemyID != 20) ? ((AgentMode)4) : ((AgentMode)3)) : ((AgentMode)1));
			AgentMode mode = val;
			WaitForSeconds spawnInterval = new WaitForSeconds(2f / (float)count);
			for (int i = 0; i < count; i++)
			{
				EnemyAgent.SpawnEnemy(e.EnemyID, pos, courseNode, mode);
				yield return spawnInterval;
			}
		}
	}
	public static class WardenEventExt
	{
		internal static readonly Dictionary<WEE_Type, BaseEvent> _EventsToTrigger;

		static WardenEventExt()
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			_EventsToTrigger = new Dictionary<WEE_Type, BaseEvent>();
			IEnumerable<Type> enumerable = from x in typeof(BaseEvent).Assembly.GetTypes()
				where !x.IsAbstract
				where x.IsAssignableTo(typeof(BaseEvent))
				select x;
			bool flag = default(bool);
			foreach (Type item in enumerable)
			{
				BaseEvent baseEvent = (BaseEvent)Activator.CreateInstance(item);
				if (_EventsToTrigger.TryGetValue(baseEvent.EventType, out BaseEvent value))
				{
					Logger.Error("Duplicate EventType detected!");
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(14, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("With '");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(value.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' and '");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(baseEvent.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'");
					}
					Logger.Error(val);
				}
				else
				{
					baseEvent.Setup();
					_EventsToTrigger[baseEvent.EventType] = baseEvent;
				}
			}
		}

		internal static void Initialize()
		{
			ClassInjector.RegisterTypeInIl2Cpp<ScanPositionReplicator>();
			ClassInjector.RegisterTypeInIl2Cpp<ZoneLightReplicator>();
			JsonInjector.SetConverter<eWardenObjectiveEventType>((Il2CppJsonUnmanagedTypeConverter<eWardenObjectiveEventType>)new EventTypeConverter());
			JsonInjector.AddHandler<WardenObjectiveEventData>((Il2CppJsonReferenceTypeHandler<WardenObjectiveEventData>)(object)new EventDataHandler());
			JsonInjector.AddHandler<WorldEventFromSourceData>((Il2CppJsonReferenceTypeHandler<WorldEventFromSourceData>)(object)new TriggerDataHandler());
			WEE_EnumInjector.Inject();
			Detour_ExecuteEvent.Patch();
		}

		internal static void HandleEvent(WEE_Type type, WardenObjectiveEventData e, float currentDuration)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			WEE_EventData wEEData = e.GetWEEData();
			if (wEEData != null)
			{
				CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(Handle(type, wEEData, currentDuration)), (Action)null);
				return;
			}
			bool flag = default(bool);
			BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(72, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("WardenEvent Type is Extension (");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<WEE_Type>(type);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("), but it's not registered to dataholder!");
			}
			Logger.Error(val);
		}

		private static IEnumerator Handle(WEE_Type type, WEE_EventData e, float currentDuration)
		{
			float delay = Mathf.Max(e.Delay - currentDuration, 0f);
			if (delay > 0f)
			{
				yield return (object)new WaitForSeconds(delay);
			}
			if (WorldEventManager.GetCondition(e.Condition.ConditionIndex) != e.Condition.IsTrue)
			{
				yield break;
			}
			WardenObjectiveManager.DisplayWardenIntel(e.Layer, e.WardenIntel.ToLocalizedText());
			if (e.Type != WEE_Type.ForcePlayPlayerDialogue)
			{
				if (e.DialogueID != 0)
				{
					PlayerDialogManager.WantToStartDialog(e.DialogueID, -1, false, false);
				}
				if (e.SoundID != 0)
				{
					WardenObjectiveManager.Current.m_sound.Post(e.SoundID, true);
					string line = e.SoundSubtitle;
					if (!string.IsNullOrWhiteSpace(line) && e.Type != WEE_Type.PlaySubtitles)
					{
						GuiManager.PlayerLayer.ShowMultiLineSubtitle(line);
					}
				}
			}
			if (e.SubObjective.DoUpdate && e.Type != WEE_Type.MultiProgression)
			{
				WardenObjectiveManager.UpdateSyncCustomSubObjective(e.SubObjective.CustomSubObjectiveHeader.ToLocalizedText(), e.SubObjective.CustomSubObjective.ToLocalizedText());
			}
			if (e.Fog.DoUpdate)
			{
				EnvironmentStateManager.AttemptStartFogTransition(e.Fog.FogSetting, e.Fog.FogTransitionDuration, e.DimensionIndex);
			}
			if (_EventsToTrigger.TryGetValue(type, out BaseEvent eventInstance))
			{
				eventInstance.Trigger(e);
				yield break;
			}
			bool flag = default(bool);
			BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(26, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<WEE_Type>(type);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" does not exist in lookup!");
			}
			Logger.Error(val);
		}
	}
	internal static class WEE_EnumInjector
	{
		public const int ExtendedIndex = 10000;

		private static readonly Dictionary<string, object> _EventTypes;

		private static int _CurrentIndex;

		static WEE_EnumInjector()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			_EventTypes = new Dictionary<string, object>();
			_CurrentIndex = 0;
			WEE_Type[] values = Enum.GetValues<WEE_Type>();
			bool flag = default(bool);
			for (int i = 0; i < values.Length; i++)
			{
				WEE_Type wEE_Type = values[i];
				string text = wEE_Type.ToString();
				AddEvent(text);
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(22, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Injecting EWOEvent: '");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'");
				}
				Logger.Debug(val);
			}
		}

		private static void AddEvent(string name)
		{
			_EventTypes[name] = _CurrentIndex + 10000;
			_CurrentIndex++;
		}

		internal static void Inject()
		{
			EnumInjector.InjectEnumValues<eWardenObjectiveEventType>(_EventTypes);
		}
	}
	public sealed class WEE_EventData
	{
		public WEE_Type Type { get; set; }

		public WorldEventConditionPair Condition { get; set; } = new WorldEventConditionPair
		{
			ConditionIndex = -1,
			IsTrue = false
		};


		public eWardenObjectiveEventTrigger Trigger { get; set; } = (eWardenObjectiveEventTrigger)0;


		public uint ChainPuzzle { get; set; } = 0u;


		public bool UseStaticBioscanPoints { get; set; } = false;


		public LG_LayerType Layer { get; set; } = (LG_LayerType)0;


		public eDimensionIndex DimensionIndex { get; set; } = (eDimensionIndex)0;


		public eLocalZoneIndex LocalIndex { get; set; } = (eLocalZoneIndex)0;


		public Vector3 Position { get; set; } = Vector3.zero;


		public float Delay { get; set; } = 0f;


		public float Duration { get; set; } = 0f;


		public LocaleText WardenIntel { get; set; } = LocaleText.Empty;


		public uint SoundID { get; set; } = 0u;


		public LocaleText SoundSubtitle { get; set; } = LocaleText.Empty;


		public uint DialogueID { get; set; } = 0u;


		public int Count { get; set; } = 0;


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


		public bool SpecialBool { get; set; } = false;


		public int SpecialNumber { get; set; } = -1;


		public LocaleText SpecialText { get; set; } = LocaleText.Empty;


		public string WorldEventObjectFilter
		{
			get
			{
				return SpecialText;
			}
			set
			{
				SpecialText = (LocaleText)value;
			}
		}

		public WEE_SubObjectiveData SubObjective { get; set; } = new WEE_SubObjectiveData();


		public WEE_UpdateFogData Fog { get; set; } = new WEE_UpdateFogData();


		public bool CleanUpEnemiesBehind { get; set; } = true;


		public WEE_ReactorEventData Reactor { get; set; } = new WEE_ReactorEventData();


		public WEE_CountdownData Countdown { get; set; } = new WEE_CountdownData();


		public WEE_ZoneLightData SetZoneLight { get; set; } = new WEE_ZoneLightData();


		public WEE_CleanupEnemiesData CleanupEnemies { get; set; } = new WEE_CleanupEnemiesData();


		public WEE_SpawnHibernateData SpawnHibernates { get; set; } = new WEE_SpawnHibernateData();


		public WEE_SpawnScoutData SpawnScouts { get; set; } = new WEE_SpawnScoutData();


		public WEE_AddTerminalCommand AddTerminalCommand { get; set; } = new WEE_AddTerminalCommand();


		public WEE_HideTerminalCommand HideTerminalCommand { get; set; } = new WEE_HideTerminalCommand();


		public WEE_UnhideTerminalCommand UnhideTerminalCommand { get; set; } = new WEE_UnhideTerminalCommand();


		public WEE_NestedEvent NestedEvent { get; set; } = new WEE_NestedEvent();


		public WEE_StartEventLoop StartEventLoop { get; set; } = new WEE_StartEventLoop();


		public WEE_StartEventLoop EventLoop
		{
			get
			{
				return StartEventLoop;
			}
			set
			{
				StartEventLoop = value;
			}
		}

		public WEE_TeleportPlayer TeleportPlayer { get; set; } = new WEE_TeleportPlayer();


		public WEE_InfectPlayer InfectPlayer { get; set; } = new WEE_InfectPlayer();


		public WEE_DamagePlayer DamagePlayer { get; set; } = new WEE_DamagePlayer();


		public WEE_RevivePlayer RevivePlayer { get; set; } = new WEE_RevivePlayer();


		public WEE_AdjustTimer AdjustTimer { get; set; } = new WEE_AdjustTimer();


		public WEE_CountupData Countup { get; set; } = new WEE_CountupData();


		public WEE_NavMarkerData NavMarker { get; set; } = new WEE_NavMarkerData();


		public WEE_ShakeScreen CameraShake { get; set; } = new WEE_ShakeScreen();


		public WEE_StartPortalMachine Portal { get; set; } = new WEE_StartPortalMachine();


		public WEE_SetSuccessScreen SuccessScreen { get; set; } = new WEE_SetSuccessScreen();


		public List<WEE_SubObjectiveData> MultiProgression { get; set; } = new List<WEE_SubObjectiveData>();


		public WEE_PlayWaveDistantRoar WaveRoarSound { get; set; } = new WEE_PlayWaveDistantRoar();


		public WEE_CustomHudText CustomHudText { get; set; } = new WEE_CustomHudText();


		public WEE_SpecialHudTimer SpecialHudTimer { get; set; } = new WEE_SpecialHudTimer();


		public WEE_ForcePlayerDialogue PlayerDialogue { get; set; } = new WEE_ForcePlayerDialogue();


		public WEE_SetTerminalLog SetTerminalLog { get; set; } = new WEE_SetTerminalLog();


		public List<WEE_SetPocketItem> ObjectiveItems { get; set; } = new List<WEE_SetPocketItem>();

	}
	public sealed class WEE_SubObjectiveData
	{
		public bool DoUpdate { get; set; } = false;


		public LocaleText CustomSubObjectiveHeader { get; set; } = LocaleText.Empty;


		public LocaleText CustomSubObjective { get; set; } = LocaleText.Empty;


		public uint Index { get; set; } = 0u;


		public int Priority { get; set; } = 1;


		public LG_LayerType Layer { get; set; } = (LG_LayerType)0;


		public bool IsLayerIndependent { get; set; } = true;


		public LocaleText OverrideTag { get; set; } = LocaleText.Empty;

	}
	public sealed class WEE_UpdateFogData
	{
		public bool DoUpdate { get; set; } = false;


		public uint FogSetting { get; set; } = 0u;


		public float FogTransitionDuration { get; set; } = 0f;

	}
	public sealed class WEE_ReactorEventData
	{
		public enum WaveState
		{
			Intro,
			Wave,
			Verify
		}

		public WaveState State { get; set; } = WaveState.Intro;


		public int Wave { get; set; } = 1;


		public float Progress { get; set; } = 0f;

	}
	public sealed class WEE_CountdownData
	{
		public float Duration { get; set; } = 0f;


		public LocaleText TimerText { get; set; } = LocaleText.Empty;


		public Color TimerColor { get; set; } = Color.red;


		public List<EventsOnTimerProgress> EventsOnProgress { get; set; } = new List<EventsOnTimerProgress>();


		public List<WardenObjectiveEventData> EventsOnDone { get; set; } = new List<WardenObjectiveEventData>();

	}
	public sealed class WEE_CleanupEnemiesData
	{
		public enum CleanUpType
		{
			Kill,
			Despawn
		}

		public CleanUpType Type { get; set; } = CleanUpType.Despawn;


		public int AreaIndex { get; set; } = -1;


		public bool IncludeHibernate { get; set; } = true;


		public bool IncludeAggressive { get; set; } = true;


		public bool IncludeScout { get; set; } = true;


		public uint[] ExcludeEnemyID { get; set; } = Array.Empty<uint>();


		public uint[] IncludeOnlyID { get; set; } = Array.Empty<uint>();


		public void DoClear(AIG_CourseNode node)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected I4, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			if (!SNet.IsMaster || node == null || node.m_enemiesInNode == null)
			{
				return;
			}
			foreach (EnemyAgent item in node.m_enemiesInNode.ToArray())
			{
				AgentMode mode = ((AgentAI)item.AI).Mode;
				if ((mode - 1) switch
				{
					0 => IncludeAggressive, 
					2 => IncludeScout, 
					3 => IncludeHibernate, 
					_ => true, 
				} && !ExcludeEnemyID.Contains(item.EnemyDataID) && (IncludeOnlyID.Length == 0 || IncludeOnlyID.Contains(item.EnemyDataID)))
				{
					switch (Type)
					{
					case CleanUpType.Despawn:
						((Agent)item).m_replicator.Despawn();
						break;
					case CleanUpType.Kill:
						item.Damage.IsImortal = false;
						item.Damage.BulletDamage(((Dam_SyncedDamageBase)item.Damage).DamageMax, (Agent)null, default(Vector3), default(Vector3), default(Vector3), false, 0, 1f, 1f, 0u);
						break;
					}
				}
			}
		}
	}
	public sealed class WEE_ZoneLightData
	{
		public enum ModifierType : byte
		{
			RevertToOriginal,
			SetZoneLightData
		}

		public ModifierType Type { get; set; } = ModifierType.RevertToOriginal;


		public uint LightDataID { get; set; } = 0u;


		public float TransitionDuration { get; set; } = 0.5f;


		public int Seed { get; set; } = 0;


		public bool DisregardFlicker { get; set; } = false;

	}
	public sealed class WEE_SpawnHibernateData
	{
		public int AreaIndex { get; set; } = -1;


		public uint EnemyID { get; set; } = 0u;


		public int Count { get; set; } = 1;


		public Vector3 Position { get; set; } = Vector3.zero;


		public Vector3 Rotation { get; set; } = Vector3.zero;

	}
	public sealed class WEE_SpawnScoutData
	{
		public int AreaIndex { get; set; } = -1;


		public eEnemyGroupType GroupType { get; set; }

		public eEnemyRoleDifficulty Difficulty { get; set; }

		public int Count { get; set; } = 1;

	}
	public sealed class WEE_AddTerminalCommand
	{
		public int TerminalIndex { get; set; } = 0;


		public int CommandNumber { get; set; } = 6;


		public string Command { get; set; } = string.Empty;


		public LocaleText CommandDesc { get; set; } = LocaleText.Empty;


		public bool AutoIndentCommandDesc { get; set; } = false;


		public List<TerminalOutput> PostCommandOutputs { get; set; } = new List<TerminalOutput>();


		public List<WardenObjectiveEventData> CommandEvents { get; set; } = new List<WardenObjectiveEventData>();


		public TERM_CommandRule SpecialCommandRule { get; set; } = (TERM_CommandRule)0;

	}
	public sealed class WEE_HideTerminalCommand
	{
		public int TerminalIndex { get; set; } = 0;


		public TERM_Command CommandEnum { get; set; } = (TERM_Command)0;


		public int CommandNumber { get; set; } = 0;


		public bool DeleteCommand { get; set; } = false;

	}
	public sealed class WEE_UnhideTerminalCommand
	{
		public int TerminalIndex { get; set; } = 0;


		public TERM_Command CommandEnum { get; set; } = (TERM_Command)0;


		public int CommandNumber { get; set; } = 0;

	}
	public sealed class WEE_NestedEvent
	{
		public enum NestedMode : byte
		{
			ActivateAll,
			RandomAny
		}

		public NestedMode Type { get; set; } = NestedMode.ActivateAll;


		public int MaxRandomEvents { get; set; } = -1;


		public bool AllowRepeatsInRandom { get; set; } = false;


		public List<WardenObjectiveEventData> EventsToActivate { get; set; } = new List<WardenObjectiveEventData>();

	}
	public sealed class WEE_StartEventLoop
	{
		public int LoopIndex { get; set; } = 0;


		public float LoopDelay { get; set; } = 1f;


		public int LoopCount { get; set; } = -1;


		public List<WardenObjectiveEventData> EventsToActivate { get; set; } = new List<WardenObjectiveEventData>();

	}
	public enum PlayerIndex : byte
	{
		P0,
		P1,
		P2,
		P3
	}
	public sealed class WEE_TeleportPlayer
	{
		public HashSet<PlayerIndex> PlayerFilter { get; set; } = new HashSet<PlayerIndex>();


		public bool PlayWarpAnimation { get; set; } = true;


		public bool FlashTeleport { get; set; } = false;


		public bool WarpSentries { get; set; } = true;


		public bool WarpBigPickups { get; set; } = true;


		public bool SendBPUsToHost { get; set; } = false;


		public Vector3 Player0Position { get; set; } = Vector3.zero;


		public int P0LookDir { get; set; } = 0;


		public Vector3 Player1Position { get; set; } = Vector3.zero;


		public int P1LookDir { get; set; } = 0;


		public Vector3 Player2Position { get; set; } = Vector3.zero;


		public int P2LookDir { get; set; } = 0;


		public Vector3 Player3Position { get; set; } = Vector3.zero;


		public int P3LookDir { get; set; } = 0;

	}
	public sealed class WEE_InfectPlayer
	{
		public HashSet<PlayerIndex> PlayerFilter { get; set; } = new HashSet<PlayerIndex>
		{
			PlayerIndex.P0,
			PlayerIndex.P1,
			PlayerIndex.P2,
			PlayerIndex.P3
		};


		public float InfectionAmount { get; set; } = 0f;


		public bool InfectOverTime { get; set; } = false;


		public float Interval { get; set; } = 1f;


		public bool UseZone { get; set; } = false;

	}
	public sealed class WEE_DamagePlayer
	{
		public HashSet<PlayerIndex> PlayerFilter { get; set; } = new HashSet<PlayerIndex>
		{
			PlayerIndex.P0,
			PlayerIndex.P1,
			PlayerIndex.P2,
			PlayerIndex.P3
		};


		public float DamageAmount { get; set; } = 0f;


		public bool DamageOverTime { get; set; } = false;


		public float Interval { get; set; } = 1f;


		public bool UseZone { get; set; } = false;

	}
	public sealed class WEE_RevivePlayer
	{
		public HashSet<PlayerIndex> PlayerFilter { get; set; } = new HashSet<PlayerIndex>
		{
			PlayerIndex.P0,
			PlayerIndex.P1,
			PlayerIndex.P2,
			PlayerIndex.P3
		};

	}
	public sealed class WEE_AdjustTimer
	{
		public float Duration { get; set; } = 0f;


		public float Speed { get; set; } = 0f;


		public bool UpdateText { get; set; } = false;


		public LocaleText CustomText { get; set; } = LocaleText.Empty;


		public Color TimerColor { get; set; } = Color.red;

	}
	public sealed class WEE_CountupData
	{
		public float Duration { get; set; } = 0f;


		public float StartValue { get; set; } = 0f;


		public float Speed { get; set; } = 1f;


		public LocaleText TimerText { get; set; } = LocaleText.Empty;


		public LocaleText CustomText { get; set; } = LocaleText.Empty;


		public Color TimerColor { get; set; } = Color.red;


		public int DecimalPoints { get; set; } = 0;


		public List<EventsOnTimerProgress> EventsOnProgress { get; set; } = new List<EventsOnTimerProgress>();


		public List<WardenObjectiveEventData> EventsOnDone { get; set; } = new List<WardenObjectiveEventData>();

	}
	public struct EventsOnTimerProgress
	{
		public float Progress { get; set; }

		public List<WardenObjectiveEventData> Events { get; set; }
	}
	public sealed class WEE_NavMarkerData
	{
		public NavMarkerOption Style { get; set; } = (NavMarkerOption)10;


		public LocaleText Title { get; set; } = LocaleText.Empty;


		public Color Color { get; set; } = new Color(0.701f, 0.435f, 0.964f, 1f);


		public bool UsePin { get; set; } = true;

	}
	public sealed class WEE_ShakeScreen
	{
		public float Radius { get; set; } = 0f;


		public float Duration { get; set; } = 0f;


		public float Amplitude { get; set; } = 0f;


		public float Frequency { get; set; } = 0f;


		public bool Directional { get; set; } = true;

	}
	public sealed class WEE_StartPortalMachine
	{
		public eDimensionIndex TargetDimension { get; set; } = (eDimensionIndex)1;


		public eLocalZoneIndex TargetZone { get; set; } = (eLocalZoneIndex)0;

	}
	public sealed class WEE_SetSuccessScreen
	{
		public enum ScreenType : byte
		{
			SetSuccessScreen,
			FlashFakeScreen
		}

		public ScreenType Type { get; set; } = ScreenType.SetSuccessScreen;


		public WinScreen CustomSuccessScreen { get; set; } = WinScreen.Empty;


		public eCM_MenuPage FakeEndScreen { get; set; } = (eCM_MenuPage)17;

	}
	public sealed class WEE_PlayWaveDistantRoar
	{
		public enum WaveRoarSound : byte
		{
			Striker,
			Shooter,
			Birther,
			Shadow,
			Tank,
			Flyer,
			Immortal,
			Bullrush,
			Pouncer,
			Striker_Berserk,
			Shooter_Spread
		}

		public enum WaveRoarSize : byte
		{
			Small,
			Medium,
			Big
		}

		public WaveRoarSound RoarSound { get; set; } = WaveRoarSound.Striker;


		public WaveRoarSize RoarSize { get; set; } = WaveRoarSize.Small;


		public bool IsOutside { get; set; } = false;

	}
	public sealed class WEE_CustomHudText
	{
		public LocaleText Title { get; set; } = LocaleText.Empty;


		public LocaleText Body { get; set; } = LocaleText.Empty;

	}
	public sealed class WEE_SpecialHudTimer
	{
		public LocaleText Message { get; set; } = LocaleText.Empty;


		public ePUIMessageStyle Style { get; set; } = (ePUIMessageStyle)0;


		public int Priority { get; set; } = -2;


		public bool ShowTimeInProgressBar { get; set; } = true;


		public float Duration { get; set; } = 0f;


		public List<EventsOnTimerProgress> EventsOnProgress { get; set; } = new List<EventsOnTimerProgress>();


		public List<WardenObjectiveEventData> EventsOnDone { get; set; } = new List<WardenObjectiveEventData>();

	}
	public sealed class WEE_ForcePlayerDialogue
	{
		public enum DialogueType : byte
		{
			Closest,
			Specific,
			Random
		}

		public enum PlayerIntensityState : byte
		{
			Exploration,
			Stealth,
			Encounter,
			Combat
		}

		public DialogueType Type { get; set; } = DialogueType.Closest;


		public PlayerIndex CharacterID { get; set; } = PlayerIndex.P0;


		public PlayerIntensityState IntensityState { get; set; } = PlayerIntensityState.Exploration;

	}
	public sealed class WEE_SetTerminalLog
	{
		public enum LogEventType : byte
		{
			Add,
			Remove
		}

		public int TerminalIndex { get; set; } = 0;


		public LogEventType Type { get; set; } = LogEventType.Add;


		public string FileName { get; set; } = string.Empty;


		public LocaleText FileContent { get; set; } = LocaleText.Empty;


		public Language FileContentOriginalLanguage { get; set; } = (Language)1;


		public uint AttachedAudioFile { get; set; } = 0u;


		public int AttachedAudioByteSize { get; set; } = 0;


		public uint PlayerDialogToTriggerAfterAudio { get; set; } = 0u;


		public List<WardenObjectiveEventData> EventsOnFileRead { get; set; } = new List<WardenObjectiveEventData>();

	}
	public sealed class WEE_SetPocketItem
	{
		public enum PlayerTagType : byte
		{
			Custom,
			Specific,
			Random,
			Closest
		}

		public int Index { get; set; } = 0;


		public int Count { get; set; } = 1;


		public bool IsOnTop { get; set; } = false;


		public LocaleText ItemName { get; set; } = LocaleText.Empty;


		public PlayerTagType TagType { get; set; } = PlayerTagType.Custom;


		public PlayerIndex PlayerIndex { get; set; } = PlayerIndex.P0;


		public string CustomTag { get; set; } = string.Empty;


		[JsonIgnore]
		public string? Tag { get; set; } = string.Empty;


		public bool ShouldRemove => Count < 1;

		private string LiveCount => (Count > 1) ? $"{Count} " : string.Empty;

		public string FormatString()
		{
			return $"{LiveCount}{ItemName} <uppercase><color=#ffffff{MathUtil.ZeroOneRangeToHex(0.2f)}>[{Tag}]</color></uppercase>";
		}
	}
	public enum WEE_Type
	{
		CloseSecurityDoor = 10000,
		LockSecurityDoor = 10001,
		SetDoorInteraction = 10002,
		TriggerSecurityDoorAlarm = 10003,
		SolveSecurityDoorAlarm = 10004,
		StartReactor = 10005,
		ModifyReactorWaveState = 10006,
		ForceCompleteReactor = 10007,
		ForceCompleteLevel = 10008,
		ForceFailLevel = 10009,
		Countdown = 10010,
		SetLevelFailCheckEnabled = 10011,
		SetLevelFailWhenAnyPlayerDowned = 10012,
		KillAllPlayers = 10013,
		KillPlayersInZone = 10014,
		SolveSingleObjectiveItem = 10015,
		SetLightDataInZone = 10016,
		AlertEnemiesInZone = 10017,
		CleanupEnemiesInZone = 10018,
		SpawnHibernateInZone = 10019,
		SpawnScoutInZone = 10020,
		SaveCheckpoint = 10021,
		MoveExtractionWorldPosition = 10022,
		SetBlackoutEnabled = 10023,
		AddTerminalCommand = 10024,
		HideTerminalCommand = 10025,
		UnhideTerminalCommand = 10026,
		AddChainPuzzleToSecurityDoor = 10027,
		NestedEvent = 20000,
		StartEventLoop = 20001,
		StopEventLoop = 20002,
		TeleportPlayer = 20003,
		InfectPlayer = 20004,
		DamagePlayer = 20005,
		RevivePlayer = 20006,
		AdjustAWOTimer = 20007,
		Countup = 20008,
		ForceCompleteChainPuzzle = 20009,
		SpawnNavMarker = 20010,
		ShakeScreen = 20011,
		StartPortalMachine = 20012,
		SetSuccessScreen = 20013,
		PlaySubtitles = 20014,
		MultiProgression = 20015,
		PlayWaveRoarSound = 20016,
		CustomHudText = 20017,
		SpecialHudTimer = 20018,
		ForcePlayPlayerDialogue = 20019,
		SetTerminalLog = 20020,
		SetPocketItem = 20021,
		DoInteractWeakDoorsInZone = 20022,
		ToggleInteractWeakDoorsInZone = 20023
	}
}
namespace AWO.Modules.WEE.Replicators
{
	internal struct ScanPositionState
	{
		public Vector3 position;

		public int nodeID;
	}
	internal sealed class ScanPositionReplicator : MonoBehaviour, IStateReplicatorHolder<ScanPositionState>
	{
		public Il2CppReferenceField<NavMarker> Marker;

		public Il2CppReferenceField<CP_Bioscan_Core> TrackingScan;

		public Il2CppValueField<bool> IsExitScan;

		[HideFromIl2Cpp]
		public StateReplicator<ScanPositionState> Replicator { get; private set; }

		public void Setup(uint id)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			CP_Bioscan_Core value = TrackingScan.Value;
			ScanPositionState scanPositionState = default(ScanPositionState);
			scanPositionState.position = ((Component)value).transform.position;
			scanPositionState.nodeID = value.CourseNode.NodeID;
			ScanPositionState startState = scanPositionState;
			Replicator = StateReplicator<ScanPositionState>.Create(id, startState, LifeTimeType.Session, this);
		}

		public void TryUpdatePosition(Vector3 position)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			AIG_CourseNode val = default(AIG_CourseNode);
			if (Replicator != null && !Replicator.IsInvalid && AIG_CourseNode.TryGetCourseNode(GameObjectDimensionExtensions.GetDimension(position).DimensionIndex, position, 6f, ref val))
			{
				Replicator.SetState(new ScanPositionState
				{
					position = position,
					nodeID = val.NodeID
				});
			}
		}

		[HideFromIl2Cpp]
		void IStateReplicatorHolder<ScanPositionState>.OnStateChange(ScanPositionState oldState, ScanPositionState state, bool isRecall)
		{
			//IL_0014: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			CP_Bioscan_Core value = TrackingScan.Value;
			((Component)value).transform.position = state.position;
			if ((int)value.State.status > 0)
			{
				value.PlayerScanner.StopScan();
				value.PlayerScanner.StartScan();
			}
			NavMarker value2 = Marker.Value;
			value2.SetTrackingObject(((Component)value).gameObject);
			AIG_CourseNode val = default(AIG_CourseNode);
			if (AIG_CourseNode.GetCourseNode(state.nodeID, ref val))
			{
				value.CourseNode.UnregisterBioscan(value);
				value.m_courseNode = val;
				val.RegisterBioscan(value);
			}
			if (IsExitScan.Value)
			{
				LG_Zone zone = value.m_courseNode.m_zone;
				string formattedText = zone.NavInfo.GetFormattedText((LG_NavInfoFormat)6);
				WardenObjectiveManager.SetObjectiveTextFragment((LG_LayerType)0, 0, (eWardenTextFragment)6, formattedText);
				WardenObjectiveManager.SetObjectiveTextFragment((LG_LayerType)1, 0, (eWardenTextFragment)6, formattedText);
				WardenObjectiveManager.SetObjectiveTextFragment((LG_LayerType)2, 0, (eWardenTextFragment)6, formattedText);
				WardenObjectiveManager.UpdateObjectiveGUIWithCurrentState((LG_LayerType)0, false, false, false);
				WardenObjectiveManager.UpdateObjectiveGUIWithCurrentState((LG_LayerType)1, false, false, false);
				WardenObjectiveManager.UpdateObjectiveGUIWithCurrentState((LG_LayerType)2, false, false, false);
			}
		}
	}
	public struct ZoneLightState
	{
		public uint lightData;

		public int lightSeed;

		public float duration;
	}
	public struct LightTransitionData
	{
		public enum Mode
		{
			Enabled,
			Disabled,
			Flickering
		}

		public float startIntensity;

		public float endIntensity;

		public Color startColor;

		public Color endColor;

		public Mode endMode;

		public int endModeSeed;
	}
	public class LightWorker
	{
		public LG_Zone OwnerZone;

		public LG_Light Light;

		public int InstanceID;

		public Color OrigColor;

		public bool OrigEnabled;

		public float PrefabIntensity;

		public float OrigIntensity;

		public Coroutine LightAnimationRoutine;

		public Coroutine LightTransitionRoutine;

		public void ApplyLightSetting(LightSettingsDataBlock lightDB, float duration, int seed, int subseed)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			Random random = new Random(seed);
			for (int i = 0; i < Mathf.Abs(subseed); i++)
			{
				random.Next();
			}
			LightSettingSelector val = new LightSettingSelector();
			val.Setup(Light.m_category, lightDB);
			LightCategorySetting val2 = default(LightCategorySetting);
			if (val.TryGetRandomSetting((uint)subseed, ref val2))
			{
				if (!random.MeetProbability(val2.Chance))
				{
					LightTransitionRoutine = MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)OwnerZone, LightTransition(new LightTransitionData
					{
						startColor = Light.m_color,
						endColor = Color.black,
						startIntensity = Light.m_intensity,
						endIntensity = 0f,
						endMode = LightTransitionData.Mode.Disabled
					}, duration));
				}
				else
				{
					LightTransitionData.Mode endMode = (random.MeetProbability(val2.ChanceBroken) ? LightTransitionData.Mode.Flickering : LightTransitionData.Mode.Enabled);
					LightTransitionRoutine = MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)OwnerZone, LightTransition(new LightTransitionData
					{
						startColor = Light.m_color,
						endColor = val2.Color,
						startIntensity = Light.m_intensity,
						endIntensity = PrefabIntensity * val2.IntensityMul,
						endMode = endMode,
						endModeSeed = random.Next()
					}, duration));
				}
			}
		}

		private IEnumerator LightTransition(LightTransitionData data, float duration)
		{
			float time = 0f;
			WaitForFixedUpdate yielder = new WaitForFixedUpdate();
			while (time <= duration)
			{
				time += Time.fixedDeltaTime;
				float progress = time / duration;
				Light.ChangeColor(Color.Lerp(data.startColor, data.endColor, progress));
				Light.ChangeIntensity(Mathf.Lerp(data.startIntensity, data.endIntensity, progress));
				yield return yielder;
			}
			StopAnimation();
			switch (data.endMode)
			{
			case LightTransitionData.Mode.Enabled:
				Light.SetEnabled(true);
				break;
			case LightTransitionData.Mode.Disabled:
				Light.SetEnabled(false);
				break;
			case LightTransitionData.Mode.Flickering:
				Light.SetEnabled(true);
				LightAnimationRoutine = MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)OwnerZone, LightAnimation(data.endModeSeed));
				break;
			}
		}

		private IEnumerator LightAnimation(int seed)
		{
			Random rand = new Random(seed);
			WaitForFixedUpdate yielder = new WaitForFixedUpdate();
			while (true)
			{
				float time2 = 0f;
				float duration = rand.NextRange(1f, 3.5f);
				float speed = rand.NextRange(1.5f, 4f);
				int num = rand.Next(0, 2);
				int num2 = num;
				int num3 = num2;
				if (num3 != 0)
				{
					if (num3 == 1)
					{
						while (time2 <= duration)
						{
							float offDuration = rand.NextFloat() * 0.5f;
							float onDuration = rand.NextFloat() * 0.5f;
							Light.SetEnabled(false);
							yield return (object)new WaitForSeconds(offDuration);
							time2 += offDuration;
							Light.SetEnabled(true);
							yield return (object)new WaitForSeconds(onDuration);
							time2 += onDuration;
						}
					}
				}
				else
				{
					while (time2 <= duration)
					{
						time2 += Time.fixedDeltaTime;
						float intensity = Mathf.PerlinNoise(Time.time * speed, 0f);
						Light.ChangeIntensity(OrigIntensity * intensity);
						yield return yielder;
					}
				}
			}
		}

		private void StopAnimation()
		{
			if (LightAnimationRoutine != null)
			{
				((MonoBehaviour)OwnerZone).StopCoroutine(LightAnimationRoutine);
			}
		}

		public void Revert()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Light.ChangeColor(OrigColor);
			Light.ChangeIntensity(OrigIntensity);
			Light.SetEnabled(OrigEnabled);
		}
	}
	public sealed class ZoneLightReplicator : MonoBehaviour, IStateReplicatorHolder<ZoneLightState>
	{
		public LightWorker[] LightsInZone;

		[HideFromIl2Cpp]
		public StateReplicator<ZoneLightState> Replicator { get; private set; }

		public bool IsSetup { get; private set; } = false;


		public void Setup(LG_Zone zone)
		{
			Replicator = StateReplicator<ZoneLightState>.Create((uint)(zone.ID + 1), new ZoneLightState
			{
				lightData = 0u
			}, LifeTimeType.Session, this);
			List<LightWorker> list = new List<LightWorker>();
			Enumerator<AIG_CourseNode> enumerator = zone.m_courseNodes.GetEnumerator();
			while (enumerator.MoveNext())
			{
				AIG_CourseNode current = enumerator.Current;
				foreach (LG_Light componentsInChild in ((Component)current.m_area).GetComponentsInChildren<LG_Light>(false))
				{
					list.Add(new LightWorker
					{
						OwnerZone = zone,
						Light = componentsInChild,
						InstanceID = ((Object)componentsInChild).GetInstanceID(),
						PrefabIntensity = componentsInChild.m_intensity
					});
				}
			}
			LightsInZone = list.ToArray();
			IsSetup = true;
		}

		public void Setup_UpdateLightSetting()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			LightWorker[] lightsInZone = LightsInZone;
			foreach (LightWorker lightWorker in lightsInZone)
			{
				lightWorker.OrigColor = lightWorker.Light.m_color;
				lightWorker.OrigIntensity = lightWorker.Light.m_intensity;
				lightWorker.OrigEnabled = ((Component)lightWorker.Light).gameObject.active;
			}
		}

		private void OnDestroy()
		{
			Replicator?.Unload();
		}

		[HideFromIl2Cpp]
		public void SetLightSetting(WEE_ZoneLightData data)
		{
			if (Replicator != null && !Replicator.IsInvalid)
			{
				int num = data.Seed;
				if (num == 0)
				{
					num = EntryPoint.SessionRand.Next(int.MinValue, int.MaxValue);
				}
				Replicator.SetState(new ZoneLightState
				{
					lightData = data.LightDataID,
					lightSeed = num,
					duration = data.TransitionDuration
				});
			}
		}

		public void RevertLightData()
		{
			if (Replicator != null && !Replicator.IsInvalid)
			{
				Replicator.SetState(new ZoneLightState
				{
					lightData = 0u
				});
			}
		}

		public void OnStateChange(ZoneLightState oldState, ZoneLightState state, bool isRecall)
		{
			if (state.lightData == 0)
			{
				for (int i = 0; i < LightsInZone.Length; i++)
				{
					LightsInZone[i].Revert();
				}
				return;
			}
			LightSettingsDataBlock block = GameDataBlockBase<LightSettingsDataBlock>.GetBlock(state.lightData);
			if (block == null || !((GameDataBlockBase<LightSettingsDataBlock>)(object)block).internalEnabled)
			{
				Logger.Error("Failed to find enabled LightSettingsDataBlock!");
				return;
			}
			for (int j = 0; j < LightsInZone.Length; j++)
			{
				LightsInZone[j].ApplyLightSetting(block, isRecall ? 0f : state.duration, state.lightSeed, j);
			}
		}
	}
}
namespace AWO.Modules.WEE.Patches
{
	[HarmonyPatch]
	internal static class Patch_CmdInterpreterReadLog
	{
		[HarmonyPatch(typeof(LG_ComputerTerminalCommandInterpreter), "ReadLog")]
		[HarmonyPostfix]
		private static void Post_ReadLog(LG_ComputerTerminalCommandInterpreter __instance, string param1)
		{
			if (SetTerminalLog.LogEventQueue.TryGetValue((__instance.m_terminal.SyncID, param1), out Queue<WardenObjectiveEventData> value))
			{
				CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(DoEvents(value)), (Action)null);
			}
		}

		private static IEnumerator DoEvents(Queue<WardenObjectiveEventData> eData)
		{
			yield return (object)new WaitForSeconds(3f);
			while (eData.Count > 0)
			{
				WardenObjectiveManager.CheckAndExecuteEventsOnTrigger(eData.Dequeue(), (eWardenObjectiveEventTrigger)0, false, 0f);
			}
		}
	}
	[HarmonyPatch]
	internal static class Patch_LG_DimensionPortal
	{
		[HarmonyPatch(typeof(LG_DimensionPortal), "Setup")]
		[HarmonyPostfix]
		private static void Post_Setup(LG_DimensionPortal __instance)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			StartPortalEvent.Portals.Add(new GlobalZoneIndex(__instance.SpawnNode.m_dimension.DimensionIndex, __instance.SpawnNode.LayerType, __instance.SpawnNode.m_zone.LocalIndex), __instance);
		}
	}
	[HarmonyPatch]
	internal static class Patch_LG_WeakDoorButton
	{
		[HarmonyPatch(typeof(LG_WeakDoor), "Setup")]
		[HarmonyPostfix]
		private static void Post_Setup(LG_WeakDoor __instance)
		{
			DoInteractWeakDoorsEvent.WeakDoors.GetOrAddNew(((LG_ZoneExpander)__instance.Gate).CoursePortal.m_nodeA.m_zone.ID).Add(__instance);
		}
	}
	[HarmonyPatch]
	internal static class Patch_PUI_SetPocketOtems
	{
		[HarmonyPatch(typeof(PUI_GameObjectives), "SetItems")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void Pre_SetItems(ref string txt)
		{
			if (!SetPocketItemEvent.HasEmptyPockets)
			{
				txt = string.Join("\n", new string[3]
				{
					SetPocketItemEvent.TopItems,
					txt,
					SetPocketItemEvent.BottomItems
				}.Where((string section) => !string.IsNullOrWhiteSpace(section)));
			}
		}
	}
	[HarmonyPatch]
	internal static class Patch_ZoneLightJob
	{
		[HarmonyPatch(typeof(LG_BuildZoneLightsJob), "Build")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void Pre_ZoneBuild(LG_BuildZoneLightsJob __instance, out ZoneLightReplicator? __state)
		{
			LG_Zone zone = __instance.m_zone;
			if ((Object)(object)zone == (Object)null)
			{
				__state = null;
				return;
			}
			__state = ((Component)zone).gameObject.AddOrGetComponent<ZoneLightReplicator>();
			if (!__state.IsSetup)
			{
				__state.Setup(zone);
			}
		}

		[HarmonyPatch(typeof(LG_BuildZoneLightsJob), "Build")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Post_ZoneBuild(bool __result, ZoneLightReplicator? __state)
		{
			if (__result)
			{
				__state?.Setup_UpdateLightSetting();
			}
		}
	}
	[HarmonyPatch]
	internal static class Patch_AddPage
	{
		public static bool McBased;

		[HarmonyPatch(typeof(MainMenuGuiLayer), "AddPage")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static bool Pre_AddPage(MainMenuGuiLayer __instance, eCM_MenuPage pageEnum, string pageResourcePath, ref CM_PageBase __result)
		{
			//IL_0006: Unknown resu