using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LC_API.BundleAPI;
using LC_API.Comp;
using LC_API.Data;
using LC_API.Extensions;
using LC_API.GameInterfaceAPI;
using LC_API.ManualPatches;
using LC_API.ServerAPI;
using Microsoft.CodeAnalysis;
using Steamworks;
using Steamworks.Data;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = ".NET Framework 4.6")]
[assembly: AssemblyCompany("LC_API")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Utilities for plugin devs")]
[assembly: AssemblyFileVersion("2.1.1.0")]
[assembly: AssemblyInformationalVersion("2.1.1")]
[assembly: AssemblyProduct("LC_API")]
[assembly: AssemblyTitle("LC_API")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LC_API
{
	internal static class CheatDatabase
	{
		private const string DAT_CD_BROADCAST = "LC_API_CD_Broadcast";

		private const string SIG_REQ_GUID = "LC_API_ReqGUID";

		private const string SIG_SEND_MODS = "LC_APISendMods";

		private static Dictionary<string, PluginInfo> PluginsLoaded = new Dictionary<string, PluginInfo>();

		public static void RunLocalCheatDetector()
		{
			PluginsLoaded = Chainloader.PluginInfos;
			using Dictionary<string, PluginInfo>.ValueCollection.Enumerator enumerator = PluginsLoaded.Values.GetEnumerator();
			while (enumerator.MoveNext())
			{
				switch (enumerator.Current.Metadata.GUID)
				{
				case "mikes.lethalcompany.mikestweaks":
				case "mom.llama.enhancer":
				case "Posiedon.GameMaster":
				case "LethalCompanyScalingMaster":
				case "verity.amberalert":
					ModdedServer.SetServerModdedOnly();
					break;
				}
			}
		}

		public static void OtherPlayerCheatDetector()
		{
			Plugin.Log.LogWarning((object)"Asking all other players for their mod list..");
			GameTips.ShowTip("Mod List:", "Asking all other players for installed mods..");
			GameTips.ShowTip("Mod List:", "Check the logs for more detailed results.\n<size=13>(Note that if someone doesnt show up on the list, they may not have LC_API installed)</size>");
			Networking.Broadcast("LC_API_CD_Broadcast", "LC_API_ReqGUID");
		}

		internal static void CDNetGetString(string data, string signature)
		{
			if (data == "LC_API_CD_Broadcast" && signature == "LC_API_ReqGUID")
			{
				string text = "";
				foreach (PluginInfo value in PluginsLoaded.Values)
				{
					text = text + "\n" + value.Metadata.GUID;
				}
				Networking.Broadcast(GameNetworkManager.Instance.localPlayerController.playerUsername + " responded with these mods:" + text, "LC_APISendMods");
			}
			if (signature == "LC_APISendMods")
			{
				GameTips.ShowTip("Mod List:", data);
				Plugin.Log.LogWarning((object)data);
			}
		}
	}
	[BepInPlugin("LC_API", "LC_API", "2.1.1")]
	public sealed class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		private ConfigEntry<bool> configOverrideModServer;

		private ConfigEntry<bool> configLegacyAssetLoading;

		private ConfigEntry<bool> configDisableBundleLoader;

		public static bool Initialized { get; private set; }

		private void Awake()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			configOverrideModServer = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Force modded server browser", false, "Should the API force you into the modded server browser?");
			configLegacyAssetLoading = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Legacy asset bundle loading", false, "Should the BundleLoader use legacy asset loading? Turning this on may help with loading assets from older plugins.");
			configDisableBundleLoader = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable BundleLoader", false, "Should the BundleLoader be turned off? Enable this if you are having problems with mods that load assets using a different method from LC_API's BundleLoader.");
			Log = ((BaseUnityPlugin)this).Logger;
			((BaseUnityPlugin)this).Logger.LogWarning((object)"\n.____    _________           _____  __________ .___  \r\n|    |   \\_   ___ \\         /  _  \\ \\______   \\|   | \r\n|    |   /    \\  \\/        /  /_\\  \\ |     ___/|   | \r\n|    |___\\     \\____      /    |    \\|    |    |   | \r\n|_______ \\\\______  /______\\____|__  /|____|    |___| \r\n        \\/       \\//_____/        \\/                 \r\n                                                     ");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"LC_API Starting up..");
			if (configOverrideModServer.Value)
			{
				ModdedServer.SetServerModdedOnly();
			}
			Harmony val = new Harmony("ModAPI");
			MethodInfo methodInfo = AccessTools.Method(typeof(GameNetworkManager), "SteamMatchmaking_OnLobbyCreated", (Type[])null, (Type[])null);
			AccessTools.Method(typeof(GameNetworkManager), "LobbyDataIsJoinable", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ServerPatch), "OnLobbyCreate", (Type[])null, (Type[])null);
			MethodInfo methodInfo3 = AccessTools.Method(typeof(MenuManager), "Awake", (Type[])null, (Type[])null);
			MethodInfo methodInfo4 = AccessTools.Method(typeof(ServerPatch), "CacheMenuManager", (Type[])null, (Type[])null);
			MethodInfo methodInfo5 = AccessTools.Method(typeof(HUDManager), "AddChatMessage", (Type[])null, (Type[])null);
			MethodInfo methodInfo6 = AccessTools.Method(typeof(ServerPatch), "ChatInterpreter", (Type[])null, (Type[])null);
			val.Patch((MethodBase)methodInfo3, new HarmonyMethod(methodInfo4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)methodInfo5, new HarmonyMethod(methodInfo6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Networking.GetString = (Action<string, string>)Delegate.Combine(Networking.GetString, new Action<string, string>(CheatDatabase.CDNetGetString));
			Networking.GetListString = (Action<List<string>, string>)Delegate.Combine(Networking.GetListString, new Action<List<string>, string>(Networking.LCAPI_NET_SYNCVAR_SET));
		}

		internal void Start()
		{
			Initialize();
		}

		internal void OnDestroy()
		{
			Initialize();
		}

		internal void Initialize()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			if (!Initialized)
			{
				Initialized = true;
				if (!configDisableBundleLoader.Value)
				{
					BundleLoader.Load(configLegacyAssetLoading.Value);
				}
				GameObject val = new GameObject("API");
				Object.DontDestroyOnLoad((Object)val);
				val.AddComponent<LC_APIManager>();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"LC_API Started!");
				CheatDatabase.RunLocalCheatDetector();
			}
		}

		internal static void PatchMethodManual(MethodInfo method, MethodInfo patch, Harmony harmony)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			harmony.Patch((MethodBase)method, new HarmonyMethod(patch), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "LC_API";

		public const string PLUGIN_NAME = "LC_API";

		public const string PLUGIN_VERSION = "2.1.1";
	}
}
namespace LC_API.ServerAPI
{
	public static class ModdedServer
	{
		private static bool moddedOnly;

		[Obsolete("Use SetServerModdedOnly() instead. This will be removed/private in a future update.")]
		public static bool setModdedOnly;

		public static bool ModdedOnly => moddedOnly;

		public static void SetServerModdedOnly()
		{
			moddedOnly = true;
			Plugin.Log.LogMessage((object)"A plugin has set your game to only allow you to play with other people who have mods!");
		}

		public static void OnSceneLoaded()
		{
			if (Object.op_Implicit((Object)(object)GameNetworkManager.Instance) && ModdedOnly)
			{
				GameNetworkManager instance = GameNetworkManager.Instance;
				instance.gameVersionNum += 16440;
				setModdedOnly = true;
			}
		}
	}
	public static class Networking
	{
		public static Action<string, string> GetString = delegate
		{
		};

		public static Action<List<string>, string> GetListString = delegate
		{
		};

		public static Action<int, string> GetInt = delegate
		{
		};

		public static Action<float, string> GetFloat = delegate
		{
		};

		public static Action<Vector3, string> GetVector3 = delegate
		{
		};

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

		public static void Broadcast(string data, string signature)
		{
			if (data.Contains("/"))
			{
				Plugin.Log.LogError((object)"Invalid character in broadcasted string event! ( / )");
				return;
			}
			HUDManager.Instance.AddTextToChatOnServer("<size=0>NWE/" + data + "/" + signature + "/" + NetworkBroadcastDataType.BDstring.ToString() + "/" + GameNetworkManager.Instance.localPlayerController.playerClientId + "/</size>", -1);
		}

		public static void Broadcast(List<string> data, string signature)
		{
			string text = "";
			foreach (string datum in data)
			{
				if (datum.Contains("/"))
				{
					Plugin.Log.LogError((object)"Invalid character in broadcasted string event! ( / )");
					return;
				}
				if (datum.Contains("\n"))
				{
					Plugin.Log.LogError((object)"Invalid character in broadcasted string event! ( NewLine )");
					return;
				}
				text = text + datum + "\n";
			}
			HUDManager.Instance.AddTextToChatOnServer("<size=0>NWE/" + data?.ToString() + "/" + signature + "/" + NetworkBroadcastDataType.BDlistString.ToString() + "/" + GameNetworkManager.Instance.localPlayerController.playerClientId + "/</size>", -1);
		}

		public static void Broadcast(int data, string signature)
		{
			HUDManager.Instance.AddTextToChatOnServer("<size=0>NWE/" + data + "/" + signature + "/" + NetworkBroadcastDataType.BDint.ToString() + "/" + GameNetworkManager.Instance.localPlayerController.playerClientId + "/</size>", -1);
		}

		public static void Broadcast(float data, string signature)
		{
			HUDManager.Instance.AddTextToChatOnServer("<size=0>NWE/" + data + "/" + signature + "/" + NetworkBroadcastDataType.BDfloat.ToString() + "/" + GameNetworkManager.Instance.localPlayerController.playerClientId + "/</size>", -1);
		}

		public static void Broadcast(Vector3 data, string signature)
		{
			//IL_0016: 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)
			HUDManager instance = HUDManager.Instance;
			string[] obj = new string[9] { "<size=0>NWE/", null, null, null, null, null, null, null, null };
			Vector3 val = data;
			obj[1] = ((object)(Vector3)(ref val)).ToString();
			obj[2] = "/";
			obj[3] = signature;
			obj[4] = "/";
			obj[5] = NetworkBroadcastDataType.BDvector3.ToString();
			obj[6] = "/";
			obj[7] = GameNetworkManager.Instance.localPlayerController.playerClientId.ToString();
			obj[8] = "/</size>";
			instance.AddTextToChatOnServer(string.Concat(obj), -1);
		}

		public static void RegisterSyncVariable(string name)
		{
			if (!syncStringVars.ContainsKey(name))
			{
				syncStringVars.Add(name, "");
			}
			else
			{
				Plugin.Log.LogError((object)("Cannot register Sync Variable! A Sync Variable has already been registered with name " + name));
			}
		}

		public static void SetSyncVariable(string name, string value)
		{
			if (syncStringVars.ContainsKey(name))
			{
				syncStringVars[name] = value;
				Broadcast(new List<string> { name, value }, "LCAPI_NET_SYNCVAR_SET");
			}
			else
			{
				Plugin.Log.LogError((object)("Cannot set the value of Sync Variable " + name + " as it is not registered!"));
			}
		}

		private static void SetSyncVariableB(string name, string value)
		{
			if (syncStringVars.ContainsKey(name))
			{
				syncStringVars[name] = value;
			}
			else
			{
				Plugin.Log.LogError((object)("Cannot set the value of Sync Variable " + name + " as it is not registered!"));
			}
		}

		internal static void LCAPI_NET_SYNCVAR_SET(List<string> list, string arg2)
		{
			if (arg2 == "LCAPI_NET_SYNCVAR_SET")
			{
				SetSyncVariableB(list[0], list[1]);
			}
		}

		public static string GetSyncVariable(string name)
		{
			if (syncStringVars.ContainsKey(name))
			{
				return syncStringVars[name];
			}
			Plugin.Log.LogError((object)("Cannot get the value of Sync Variable " + name + " as it is not registered!"));
			return "";
		}

		private static void GotString(string data, string signature)
		{
		}

		private static void GotInt(int data, string signature)
		{
		}

		private static void GotFloat(float data, string signature)
		{
		}

		private static void GotVector3(Vector3 data, string signature)
		{
		}
	}
}
namespace LC_API.ManualPatches
{
	internal static class ServerPatch
	{
		internal static bool OnLobbyCreate(GameNetworkManager __instance, Result result, Lobby lobby)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if ((int)result != 1)
			{
				Debug.LogError((object)$"Lobby could not be created! {result}", (Object)(object)__instance);
			}
			__instance.lobbyHostSettings.lobbyName = "[MODDED]" + __instance.lobbyHostSettings.lobbyName.ToString();
			Plugin.Log.LogMessage((object)"server pre-setup success");
			return true;
		}

		internal static bool CacheMenuManager(MenuManager __instance)
		{
			LC_APIManager.MenuManager = __instance;
			return true;
		}

		internal static bool ChatInterpreter(HUDManager __instance, string chatMessage)
		{
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			if (!chatMessage.Contains("NWE") || !chatMessage.Contains("<size=0>"))
			{
				return true;
			}
			string[] array = chatMessage.Split(new char[1] { '/' });
			if (array.Length < 5)
			{
				if (array.Length >= 3)
				{
					if (!int.TryParse(array[4], out var result))
					{
						Plugin.Log.LogWarning((object)"Failed to parse player ID!!");
						return false;
					}
					if ((result == (int)GameNetworkManager.Instance.localPlayerController.playerClientId) & !LC_APIManager.netTester)
					{
						return false;
					}
					Enum.TryParse<NetworkBroadcastDataType>(array[3], out var result2);
					switch (result2)
					{
					case NetworkBroadcastDataType.BDstring:
						Networking.GetString(array[1], array[2]);
						break;
					case NetworkBroadcastDataType.BDint:
						Networking.GetInt(int.Parse(array[1]), array[2]);
						break;
					case NetworkBroadcastDataType.BDfloat:
						Networking.GetFloat(float.Parse(array[1]), array[2]);
						break;
					case NetworkBroadcastDataType.BDvector3:
					{
						string[] array2 = array[1].Replace("(", "").Replace(")", "").Split(new char[1] { ',' });
						Vector3 arg = default(Vector3);
						if (array2.Length == 3)
						{
							if (float.TryParse(array2[0], out var result3) && float.TryParse(array2[1], out var result4) && float.TryParse(array2[2], out var result5))
							{
								arg.x = result3;
								arg.y = result4;
								arg.z = result5;
							}
							else
							{
								Plugin.Log.LogError((object)"Vector3 Network receive fail. This is a failure of the API, and it should be reported as a bug.");
							}
						}
						else
						{
							Plugin.Log.LogError((object)"Vector3 Network receive fail. This is a failure of the API, and it should be reported as a bug.");
						}
						Networking.GetVector3(arg, array[2]);
						break;
					}
					case NetworkBroadcastDataType.BDlistString:
					{
						string[] source = array[1].Split(new char[1] { '\n' });
						Networking.GetListString(source.ToList(), array[2]);
						break;
					}
					}
					_ = LC_APIManager.netTester;
					return false;
				}
				Plugin.Log.LogError((object)"Generic Network receive fail. This is a failure of the API, and it should be reported as a bug.");
				Plugin.Log.LogError((object)$"Generic Network receive fail (expected 5+ data fragments, got {array.Length}). This is a failure of the API, and it should be reported as a bug.");
				return true;
			}
			if (!int.TryParse(array[4], out var result6))
			{
				Plugin.Log.LogWarning((object)("Failed to parse player ID '" + array[4] + "'!!"));
				return false;
			}
			if ((result6 == (int)GameNetworkManager.Instance.localPlayerController.playerClientId) & !LC_APIManager.netTester)
			{
				return false;
			}
			if (!Enum.TryParse<NetworkBroadcastDataType>(array[3], out var result7))
			{
				Plugin.Log.LogError((object)("Unknown datatype - unable to parse '" + array[3] + "' into a known data type!"));
				return false;
			}
			switch (result7)
			{
			case NetworkBroadcastDataType.BDstring:
				Networking.GetString.InvokeActionSafe(array[1], array[2]);
				break;
			case NetworkBroadcastDataType.BDint:
				Networking.GetInt.InvokeActionSafe(int.Parse(array[1]), array[2]);
				break;
			case NetworkBroadcastDataType.BDfloat:
				Networking.GetFloat.InvokeActionSafe(float.Parse(array[1]), array[2]);
				break;
			case NetworkBroadcastDataType.BDvector3:
			{
				string text = array[1].Trim('(', ')');
				string[] array3 = text.Split(new char[1] { ',' });
				Vector3 param = default(Vector3);
				float result8;
				float result9;
				float result10;
				if (array3.Length != 3)
				{
					Plugin.Log.LogError((object)$"Vector3 Network receive fail (expected 3 numbers, got {array3.Length} number(?)(s) instead). This is a failure of the API, and it should be reported as a bug. (passing an empty Vector3 in its place)");
				}
				else if (float.TryParse(array3[0], out result8) && float.TryParse(array3[1], out result9) && float.TryParse(array3[2], out result10))
				{
					param.x = result8;
					param.y = result9;
					param.z = result10;
				}
				else
				{
					Plugin.Log.LogError((object)("Vector3 Network receive fail (failed to parse '" + text + "' as numbers). This is a failure of the API, and it should be reported as a bug."));
				}
				Networking.GetVector3.InvokeActionSafe(param, array[2]);
				break;
			}
			}
			_ = LC_APIManager.netTester;
			return false;
		}

		internal static bool ChatCommands(HUDManager __instance, CallbackContext context)
		{
			if (__instance.chatTextField.text.ToLower().Contains("/modcheck"))
			{
				CheatDatabase.OtherPlayerCheatDetector();
				return false;
			}
			return true;
		}
	}
}
namespace LC_API.GameInterfaceAPI
{
	public static class GameState
	{
		private static readonly Action NothingAction = delegate
		{
		};

		public static int AlivePlayerCount { get; private set; }

		public static ShipState ShipState { get; private set; }

		public static event Action PlayerDied;

		public static event Action LandOnMoon;

		public static event Action WentIntoOrbit;

		public static event Action ShipStartedLeaving;

		internal static void GSUpdate()
		{
			if (!((Object)(object)StartOfRound.Instance == (Object)null))
			{
				if (StartOfRound.Instance.shipHasLanded && ShipState != ShipState.OnMoon)
				{
					ShipState = ShipState.OnMoon;
					GameState.LandOnMoon.InvokeActionSafe();
				}
				if (StartOfRound.Instance.inShipPhase && ShipState != 0)
				{
					ShipState = ShipState.InOrbit;
					GameState.WentIntoOrbit.InvokeActionSafe();
				}
				if (StartOfRound.Instance.shipIsLeaving && ShipState != ShipState.LeavingMoon)
				{
					ShipState = ShipState.LeavingMoon;
					GameState.ShipStartedLeaving.InvokeActionSafe();
				}
				if (AlivePlayerCount < StartOfRound.Instance.livingPlayers)
				{
					GameState.PlayerDied.InvokeActionSafe();
				}
				AlivePlayerCount = StartOfRound.Instance.livingPlayers;
			}
		}

		static GameState()
		{
			GameState.PlayerDied = NothingAction;
			GameState.LandOnMoon = NothingAction;
			GameState.WentIntoOrbit = NothingAction;
			GameState.ShipStartedLeaving = NothingAction;
		}
	}
	public class GameTips
	{
		private static List<string> tipHeaders = new List<string>();

		private static List<string> tipBodys = new List<string>();

		private static float lastMessageTime;

		public static void ShowTip(string header, string body)
		{
			tipHeaders.Add(header);
			tipBodys.Add(body);
		}

		public static void UpdateInternal()
		{
			lastMessageTime -= Time.deltaTime;
			if ((tipHeaders.Count > 0) & (lastMessageTime < 0f))
			{
				lastMessageTime = 5f;
				if ((Object)(object)HUDManager.Instance != (Object)null)
				{
					HUDManager.Instance.DisplayTip(tipHeaders[0], tipBodys[0], false, false, "LC_Tip1");
				}
				tipHeaders.RemoveAt(0);
				tipBodys.RemoveAt(0);
			}
		}
	}
}
namespace LC_API.Extensions
{
	public static class DelegateExtensions
	{
		private static readonly PropertyInfo PluginGetLogger = AccessTools.Property(typeof(BaseUnityPlugin), "Logger");

		public static void InvokeActionSafe(this Action action)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if (action == null)
			{
				return;
			}
			Delegate[] invocationList = action.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				try
				{
					((Action)@delegate)();
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Exception while invoking hook callback!");
					string asmName = @delegate.GetMethodInfo().DeclaringType.Assembly.FullName;
					PluginInfo val = ((IEnumerable<PluginInfo>)Chainloader.PluginInfos.Values).FirstOrDefault((Func<PluginInfo, bool>)((PluginInfo pi) => ((object)pi.Instance).GetType().Assembly.FullName == asmName));
					if (val == null)
					{
						Plugin.Log.LogError((object)ex.ToString());
						break;
					}
					((ManualLogSource)PluginGetLogger.GetValue(val.Instance)).LogError((object)ex.ToString());
				}
			}
		}

		public static void InvokeActionSafe<T>(this Action<T> action, T param)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (action == null)
			{
				return;
			}
			Delegate[] invocationList = action.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				try
				{
					((Action<T>)@delegate)(param);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Exception while invoking hook callback!");
					string asmName = @delegate.GetMethodInfo().DeclaringType.Assembly.FullName;
					PluginInfo val = ((IEnumerable<PluginInfo>)Chainloader.PluginInfos.Values).FirstOrDefault((Func<PluginInfo, bool>)((PluginInfo pi) => ((object)pi.Instance).GetType().Assembly.FullName == asmName));
					if (val == null)
					{
						Plugin.Log.LogError((object)ex.ToString());
						break;
					}
					((ManualLogSource)PluginGetLogger.GetValue(val.Instance)).LogError((object)ex.ToString());
				}
			}
		}

		public static void InvokeActionSafe<T1, T2>(this Action<T1, T2> action, T1 param1, T2 param2)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			if (action == null)
			{
				return;
			}
			Delegate[] invocationList = action.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				try
				{
					((Action<T1, T2>)@delegate)(param1, param2);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Exception while invoking hook callback!");
					string asmName = @delegate.GetMethodInfo().DeclaringType.Assembly.FullName;
					PluginInfo val = ((IEnumerable<PluginInfo>)Chainloader.PluginInfos.Values).FirstOrDefault((Func<PluginInfo, bool>)((PluginInfo pi) => ((object)pi.Instance).GetType().Assembly.FullName == asmName));
					if (val == null)
					{
						Plugin.Log.LogError((object)ex.ToString());
						break;
					}
					((ManualLogSource)PluginGetLogger.GetValue(val.Instance)).LogError((object)ex.ToString());
				}
			}
		}

		internal static void InvokeParameterlessDelegate<T>(this T paramlessDelegate) where T : Delegate
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			if ((Delegate?)paramlessDelegate == (Delegate?)null)
			{
				return;
			}
			Delegate[] invocationList = paramlessDelegate.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				try
				{
					((T)@delegate).DynamicInvoke();
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Exception while invoking hook callback!");
					string asmName = @delegate.GetMethodInfo().DeclaringType.Assembly.FullName;
					PluginInfo val = ((IEnumerable<PluginInfo>)Chainloader.PluginInfos.Values).FirstOrDefault((Func<PluginInfo, bool>)((PluginInfo pi) => ((object)pi.Instance).GetType().Assembly.FullName == asmName));
					if (val == null)
					{
						Plugin.Log.LogError((object)ex.ToString());
						break;
					}
					((ManualLogSource)PluginGetLogger.GetValue(val.Instance)).LogError((object)ex.ToString());
				}
			}
		}
	}
}
namespace LC_API.Data
{
	internal enum NetworkBroadcastDataType
	{
		Unknown,
		BDint,
		BDfloat,
		BDvector3,
		BDstring,
		BDlistString
	}
	public enum ShipState
	{
		InOrbit,
		OnMoon,
		LeavingMoon
	}
}
namespace LC_API.Comp
{
	internal class LC_APIManager : MonoBehaviour
	{
		public static MenuManager MenuManager;

		public static bool netTester;

		private static int playerCount;

		private static bool wanttoCheckMods;

		private static float lobbychecktimer;

		public void Update()
		{
			GameState.GSUpdate();
			GameTips.UpdateInternal();
			if ((((Object)(object)HUDManager.Instance != (Object)null) & netTester) && (Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null)
			{
				Networking.Broadcast("testerData", "testerSignature");
			}
			if (!ModdedServer.setModdedOnly)
			{
				ModdedServer.OnSceneLoaded();
			}
			else if (ModdedServer.ModdedOnly && (Object)(object)MenuManager != (Object)null && Object.op_Implicit((Object)(object)MenuManager.versionNumberText))
			{
				((TMP_Text)MenuManager.versionNumberText).text = $"v{GameNetworkManager.Instance.gameVersionNum - 16440}\nMOD";
			}
			if ((Object)(object)GameNetworkManager.Instance != (Object)null)
			{
				if (playerCount < GameNetworkManager.Instance.connectedPlayers)
				{
					lobbychecktimer = -4.5f;
					wanttoCheckMods = true;
				}
				playerCount = GameNetworkManager.Instance.connectedPlayers;
			}
			if (lobbychecktimer < 0f)
			{
				lobbychecktimer += Time.deltaTime;
			}
			else if (wanttoCheckMods && (Object)(object)HUDManager.Instance != (Object)null)
			{
				wanttoCheckMods = false;
				CD();
			}
		}

		private void CD()
		{
			CheatDatabase.OtherPlayerCheatDetector();
		}
	}
}
namespace LC_API.BundleAPI
{
	public static class BundleLoader
	{
		[Obsolete("Use OnLoadedBundles instead. This will be removed/private in a future update.")]
		public delegate void OnLoadedAssetsDelegate();

		[Obsolete("Use GetLoadedAsset instead. This will be removed/private in a future update.")]
		public static ConcurrentDictionary<string, Object> assets = new ConcurrentDictionary<string, Object>();

		[Obsolete("Use OnLoadedBundles instead. This will be removed/private in a future update.")]
		public static OnLoadedAssetsDelegate OnLoadedAssets = LoadAssetsCompleted;

		public static bool AssetsInLegacyDirectory { get; private set; }

		public static bool LegacyLoadingEnabled { get; private set; }

		public static event Action OnLoadedBundles;

		internal static void Load(bool legacyLoading)
		{
			LegacyLoadingEnabled = legacyLoading;
			Plugin.Log.LogMessage((object)"BundleAPI will now load all asset bundles...");
			string path = Path.Combine(Paths.BepInExRootPath, "Bundles");
			if (!Directory.Exists(path))
			{
				Directory.CreateDirectory(path);
				Plugin.Log.LogMessage((object)"BundleAPI Created legacy bundle directory in BepInEx/Bundles");
			}
			string[] array = (from x in Directory.GetFiles(path, "*", SearchOption.AllDirectories)
				where !x.EndsWith(".manifest", StringComparison.CurrentCultureIgnoreCase)
				select x).ToArray();
			AssetsInLegacyDirectory = array.Length != 0;
			if (!AssetsInLegacyDirectory)
			{
				Plugin.Log.LogMessage((object)"BundleAPI got no assets to load from legacy directory");
			}
			if (AssetsInLegacyDirectory)
			{
				Plugin.Log.LogWarning((object)"The path BepInEx > Bundles is outdated and should not be used anymore! Bundles will be loaded from BepInEx > plugins from now on");
				LoadAllAssetsFromDirectory(array, legacyLoading);
			}
			string[] invalidEndings = new string[7] { ".dll", ".json", ".png", ".md", ".old", ".txt", ".exe" };
			path = Path.Combine(Paths.BepInExRootPath, "plugins");
			array = (from file in Directory.GetFiles(path, "*", SearchOption.AllDirectories)
				where !invalidEndings.Any((string ending) => file.EndsWith(ending, StringComparison.CurrentCultureIgnoreCase))
				select file).ToArray();
			if (array.Length == 0)
			{
				Plugin.Log.LogMessage((object)"BundleAPI got no assets to load from plugins folder");
			}
			else
			{
				LoadAllAssetsFromDirectory(array, legacyLoading);
			}
			OnLoadedAssets.InvokeParameterlessDelegate();
			BundleLoader.OnLoadedBundles.InvokeActionSafe();
		}

		private static void LoadAllAssetsFromDirectory(string[] array, bool legacyLoading)
		{
			if (legacyLoading)
			{
				Plugin.Log.LogMessage((object)("BundleAPI got " + array.Length + " AssetBundles to load!"));
				for (int i = 0; i < array.Length; i++)
				{
					try
					{
						SaveAsset(array[i], legacyLoading);
					}
					catch (Exception)
					{
						Plugin.Log.LogError((object)("Failed to load an assetbundle! Path: " + array[i]));
					}
				}
				return;
			}
			Plugin.Log.LogMessage((object)("BundleAPI got " + array.Length + " AssetBundles to load!"));
			for (int j = 0; j < array.Length; j++)
			{
				try
				{
					SaveAsset(array[j], legacyLoading);
				}
				catch (Exception)
				{
					Plugin.Log.LogError((object)("Failed to load an assetbundle! Path: " + array[j]));
				}
			}
		}

		public static void SaveAsset(string path, bool legacyLoad)
		{
			AssetBundle val = AssetBundle.LoadFromFile(path);
			try
			{
				string[] allAssetNames = val.GetAllAssetNames();
				foreach (string text in allAssetNames)
				{
					Plugin.Log.LogMessage((object)("Got asset for load: " + text));
					Object val2 = val.LoadAsset(text);
					if (val2 == (Object)null)
					{
						Plugin.Log.LogWarning((object)$"Skipped/failed loading an asset (from bundle '{((Object)val).name}') - Asset path: {val2}");
						continue;
					}
					string key = (legacyLoad ? text.ToUpper() : text.ToLower());
					if (assets.ContainsKey(key))
					{
						Plugin.Log.LogError((object)"BundleAPI got duplicate asset!");
						break;
					}
					assets.TryAdd(key, val2);
					Plugin.Log.LogMessage((object)("Loaded asset: " + val2.name));
				}
			}
			finally
			{
				if (val != null)
				{
					val.Unload(false);
				}
			}
		}

		public static TAsset GetLoadedAsset<TAsset>(string itemPath) where TAsset : Object
		{
			Object value = null;
			if (LegacyLoadingEnabled)
			{
				assets.TryGetValue(itemPath.ToUpper(), out value);
			}
			if (value == (Object)null)
			{
				assets.TryGetValue(itemPath.ToLower(), out value);
			}
			return (TAsset)(object)value;
		}

		private static void LoadAssetsCompleted()
		{
			Plugin.Log.LogMessage((object)"BundleAPI finished loading all assets.");
		}

		static BundleLoader()
		{
			BundleLoader.OnLoadedBundles = LoadAssetsCompleted;
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using LC_API.GameInterfaceAPI;
using LC_API.ServerAPI;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("EmployeeAssignments")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("PersonalAssignments")]
[assembly: AssemblyFileVersion("1.0.4.0")]
[assembly: AssemblyInformationalVersion("1.0.4")]
[assembly: AssemblyProduct("EmployeeAssignments")]
[assembly: AssemblyTitle("EmployeeAssignments")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace PersonalAssignments
{
	[BepInPlugin("EmployeeAssignments", "EmployeeAssignments", "1.0.4")]
	public class Plugin : BaseUnityPlugin
	{
		private static bool Initialized;

		public static ManualLogSource Log { get; private set; }

		private void Start()
		{
			Initialize();
		}

		private void OnDestroy()
		{
			Initialize();
		}

		private void Initialize()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			if (!Initialized)
			{
				Initialized = true;
				GameObject val = new GameObject("PersonalAssignmentManager");
				Object.DontDestroyOnLoad((Object)(object)val);
				val.AddComponent<PersonalAssignmentManager>();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin EmployeeAssignments is loaded!");
			}
		}
	}
	[Serializable]
	public enum AssignmentType
	{
		CollectScrapItem,
		KillMonster,
		RepairValve
	}
	[Serializable]
	public struct Assignment
	{
		public string Name;

		public string BodyText;

		public string ShortText;

		public string TargetText;

		public string FailureReason;

		public int CashReward;

		public int XPReward;

		public AssignmentType Type;

		public ulong PlayerId;

		public ulong[] targetIds;

		public int TargetsComplete;

		public Vector3 FixedTargetPosition;
	}
	public static class Assignments
	{
		public static readonly Assignment[] All = new Assignment[3]
		{
			new Assignment
			{
				Name = "SCRAP RETRIEVAL",
				BodyText = "YOU MUST COLLECT THE FOLLOWING SCRAP ITEM: [{0}] IT WILL BE MARKED AS [ASSIGNMENT TARGET]",
				ShortText = "FIND THE [{0}] MARKED 'ASSIGNMENT TARGET'",
				CashReward = 100,
				XPReward = 0,
				Type = AssignmentType.CollectScrapItem,
				targetIds = new ulong[1]
			},
			new Assignment
			{
				Name = "HUNT & KILL",
				BodyText = "YOU MUST HUNT AND KILL THE FOLLOWING ENEMY: [{0}] IT WILL BE MARKED AS [ASSIGNMENT TARGET]",
				ShortText = "FIND AND KILL THE [{0}]",
				CashReward = 200,
				XPReward = 0,
				Type = AssignmentType.KillMonster,
				targetIds = new ulong[1]
			},
			new Assignment
			{
				Name = "REPAIR VALVE",
				BodyText = "YOU MUST FIND AND REPAIR THE BROKEN VALVE",
				ShortText = "FIND AND REPAIR THE BROKEN VALVE",
				CashReward = 100,
				XPReward = 0,
				Type = AssignmentType.RepairValve,
				targetIds = new ulong[1]
			}
		};
	}
	public class AssignmentUI : MonoBehaviour
	{
		private readonly Color NONE_TEXT_COLOR = new Color(1f, 0.8277124f, 0.5235849f, 0.3254902f);

		private readonly Color BG_COLOR = new Color(1f, 0.6916346f, 0.259434f, 1f);

		private readonly Color TITLE_COLOR = new Color(1f, 0.9356132f, 0.8160377f, 1f);

		private readonly Color TEXT_COLOR = new Color(0.3584906f, 0.2703371f, 0f, 1f);

		private Canvas _canvas;

		private GameObject _noneText;

		private CanvasGroup _assignment;

		private Text _assignmentTitle;

		private Text _assignmentText;

		private Font _font;

		private QuickMenuManager _menuManager;

		public Assignment? _activeAssignment;

		private void Awake()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Component)this).gameObject.layer = 5;
			_font = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf");
			_canvas = new GameObject("Canvas").AddComponent<Canvas>();
			((Component)_canvas).transform.SetParent(((Component)this).transform);
			_canvas.sortingOrder = -100;
			_canvas.renderMode = (RenderMode)0;
			RectTransform component = ((Component)_canvas).GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(1920f, 1080f);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.zero;
			component.pivot = Vector2.zero / 2f;
			CanvasScaler val = ((Component)_canvas).gameObject.AddComponent<CanvasScaler>();
			val.uiScaleMode = (ScaleMode)1;
			val.screenMatchMode = (ScreenMatchMode)2;
			val.referenceResolution = new Vector2(1920f, 1080f);
			_noneText = new GameObject("NoneText");
			Text val2 = _noneText.AddComponent<Text>();
			val2.fontSize = 20;
			val2.font = _font;
			val2.fontStyle = (FontStyle)1;
			val2.text = "NO ASSIGNMENT ACTIVE";
			((Graphic)val2).color = NONE_TEXT_COLOR;
			val2.alignment = (TextAnchor)4;
			RectTransform component2 = _noneText.GetComponent<RectTransform>();
			((Transform)component2).SetParent((Transform)(object)component);
			component2.pivot = Vector2.one;
			component2.anchorMin = Vector2.one;
			component2.anchorMax = Vector2.one;
			component2.anchoredPosition = new Vector2(-70f, -310f);
			component2.sizeDelta = new Vector2(310f, 50f);
			_assignment = new GameObject("AssignmentPanel").AddComponent<CanvasGroup>();
			_assignment.alpha = 0.5f;
			Image val3 = ((Component)_assignment).gameObject.AddComponent<Image>();
			((Graphic)val3).color = BG_COLOR;
			RectTransform component3 = ((Component)_assignment).gameObject.GetComponent<RectTransform>();
			((Transform)component3).SetParent((Transform)(object)component);
			component3.pivot = Vector2.one;
			component3.anchorMin = Vector2.one;
			component3.anchorMax = Vector2.one;
			component3.anchoredPosition = new Vector2(-50f, -300f);
			component3.sizeDelta = new Vector2(350f, 80f);
			_assignmentTitle = new GameObject("Title").AddComponent<Text>();
			_assignmentTitle.font = _font;
			_assignmentTitle.fontSize = 20;
			_assignmentTitle.fontStyle = (FontStyle)1;
			_assignmentTitle.text = "NO ASSIGNMENT ACTIVE";
			((Graphic)_assignmentTitle).color = TITLE_COLOR;
			_assignmentTitle.alignment = (TextAnchor)0;
			RectTransform component4 = ((Component)_assignmentTitle).gameObject.GetComponent<RectTransform>();
			((Transform)component4).SetParent((Transform)(object)component3);
			component4.pivot = new Vector2(0.5f, 1f);
			component4.anchorMin = new Vector2(0f, 1f);
			component4.anchorMax = Vector2.one;
			component4.anchoredPosition = new Vector2(0f, -10f);
			component4.sizeDelta = new Vector2(-40f, 100f);
			_assignmentText = new GameObject("Text").AddComponent<Text>();
			_assignmentText.font = _font;
			_assignmentText.fontSize = 16;
			_assignmentText.fontStyle = (FontStyle)1;
			_assignmentText.text = "NO ASSIGNMENT ACTIVE";
			((Graphic)_assignmentText).color = TEXT_COLOR;
			_assignmentText.alignment = (TextAnchor)6;
			RectTransform component5 = ((Component)_assignmentText).gameObject.GetComponent<RectTransform>();
			((Transform)component5).SetParent((Transform)(object)component3);
			component5.pivot = new Vector2(0.5f, 0.5f);
			component5.anchorMin = new Vector2(0f, 0f);
			component5.anchorMax = Vector2.one;
			component5.anchoredPosition = new Vector2(0f, -10f);
			component5.sizeDelta = new Vector2(-40f, -40f);
		}

		public void SetAssignment(Assignment assignment)
		{
			_activeAssignment = assignment;
			_assignmentTitle.text = assignment.Name;
			_assignmentText.text = string.Format(assignment.ShortText, assignment.TargetText);
		}

		public void ClearAssignment()
		{
			_activeAssignment = null;
		}

		private void Update()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (Object)(object)GameNetworkManager.Instance?.localPlayerController != (Object)null && !GameNetworkManager.Instance.localPlayerController.isPlayerDead;
			if ((Object)(object)_menuManager == (Object)null)
			{
				flag = false;
				_menuManager = Object.FindAnyObjectByType<QuickMenuManager>();
			}
			else
			{
				flag &= !_menuManager.isMenuOpen;
			}
			if (_activeAssignment.HasValue && _activeAssignment.Value.FixedTargetPosition != Vector3.zero)
			{
				float num = Vector3.Distance(_activeAssignment.Value.FixedTargetPosition, ((Component)GameNetworkManager.Instance.localPlayerController).transform.position);
				_assignmentText.text = string.Format(_activeAssignment.Value.ShortText, _activeAssignment.Value.TargetText) + $" {(int)num}m";
			}
			((Component)_assignment).gameObject.SetActive(_activeAssignment.HasValue);
			_noneText.SetActive(!_activeAssignment.HasValue);
			((Behaviour)_canvas).enabled = flag;
		}
	}
	public class PersonalAssignmentManager : MonoBehaviour
	{
		private AssignmentUI _assignmentUI;

		private int _maxAssignedPlayers = 20;

		private int _minAssignedPlayers = 1;

		private bool _isHost;

		private bool _assignmentsGenerated;

		private List<Assignment> _activeServerAssignments = new List<Assignment>();

		private List<Assignment> _completedServerAssignments = new List<Assignment>();

		private Assignment? _currentAssignment;

		private List<ulong> _excludeTargetIds = new List<ulong>();

		private List<string> _enemyTypeWhitelist = new List<string> { "Centipede", "Bunker Spider", "Hoarding bug", "Crawler" };

		public void Awake()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			Networking.GetString = (Action<string, string>)Delegate.Combine(Networking.GetString, new Action<string, string>(OnGetData));
			GameState.LandOnMoon += LandedOnMoon;
			GameState.WentIntoOrbit += ShipTookOff;
			GameState.ShipStartedLeaving += ShipTakingOff;
			_assignmentUI = new GameObject("UI").AddComponent<AssignmentUI>();
			((Component)_assignmentUI).transform.SetParent(((Component)this).transform);
		}

		private void Log(string log)
		{
			Plugin.Log.LogInfo((object)log);
		}

		public void LandedOnMoon()
		{
			_assignmentsGenerated = false;
		}

		public void ShipTookOff()
		{
			_assignmentsGenerated = false;
			_assignmentUI.ClearAssignment();
		}

		public void ShipTakingOff()
		{
			_assignmentsGenerated = false;
		}

		public void Update()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			if ((Object)(object)GameNetworkManager.Instance == (Object)null || (Object)(object)RoundManager.Instance?.playersManager == (Object)null || RoundManager.Instance.playersManager.newGameIsLoading || !RoundManager.Instance.dungeonFinishedGeneratingForAllPlayers)
			{
				return;
			}
			if ((int)GameState.ShipState != 1 || !RoundManager.Instance.currentLevel.sceneName.StartsWith("Level"))
			{
				_assignmentsGenerated = false;
				return;
			}
			if (_currentAssignment.HasValue)
			{
				_assignmentUI.SetAssignment(_currentAssignment.Value);
			}
			_isHost = GameNetworkManager.Instance.isHostingGame;
			if (_isHost)
			{
				if (!_assignmentsGenerated)
				{
					GenerateAssignments();
				}
				else if (_assignmentsGenerated)
				{
					CheckCompleted();
				}
			}
		}

		private void GenerateAssignments()
		{
			_completedServerAssignments.Clear();
			_activeServerAssignments.Clear();
			_excludeTargetIds.Clear();
			PlayerControllerB[] allPlayerScripts = RoundManager.Instance.playersManager.allPlayerScripts;
			int num = Mathf.Max(_minAssignedPlayers, Mathf.Min(_maxAssignedPlayers, GameState.AlivePlayerCount / 2));
			List<int> list = new List<int>();
			for (int i = 0; i < allPlayerScripts.Length; i++)
			{
				if (allPlayerScripts[i].isPlayerControlled)
				{
					list.Add(i);
				}
			}
			Log($"Starting assignment generation for {num} players");
			for (int j = 0; j < num; j++)
			{
				int index = Random.Range(0, list.Count);
				int num2 = list[index];
				list.RemoveAt(index);
				Assignment assignment = Assignments.All[Random.Range(0, Assignments.All.Length)];
				assignment.PlayerId = allPlayerScripts[num2].playerClientId;
				Log($"created assignment for player {allPlayerScripts[num2].playerClientId}");
				switch (assignment.Type)
				{
				case AssignmentType.CollectScrapItem:
					SetupCollectScrapAssignment(ref assignment);
					break;
				case AssignmentType.KillMonster:
					SetupKillEnemyAssignment(ref assignment);
					break;
				case AssignmentType.RepairValve:
					SetupRepairValveAssignment(ref assignment);
					break;
				}
				string text = JsonUtility.ToJson((object)assignment);
				Log("Sending Message (Allocation): " + text);
				Networking.Broadcast(text, "PersonalAssignment-Allocation");
				if (assignment.PlayerId == GameNetworkManager.Instance.localPlayerController.actualClientId)
				{
					OnGetData(text, "PersonalAssignment-Allocation");
				}
				_activeServerAssignments.Add(assignment);
			}
			_assignmentsGenerated = true;
			Log("Finishing assignment generation");
		}

		private void CheckCompleted()
		{
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			foreach (Assignment activeServerAssignment in _activeServerAssignments)
			{
				switch (activeServerAssignment.Type)
				{
				case AssignmentType.CollectScrapItem:
					foreach (GrabbableObject item in RoundManager.Instance.scrapCollectedThisRound)
					{
						if (item.isInShipRoom && ((NetworkBehaviour)item).NetworkObjectId == activeServerAssignment.targetIds[0])
						{
							_activeServerAssignments.Remove(activeServerAssignment);
							_completedServerAssignments.Add(activeServerAssignment);
							if (((NetworkBehaviour)item).OwnerClientId == activeServerAssignment.PlayerId)
							{
								string text3 = JsonUtility.ToJson((object)activeServerAssignment);
								Networking.Broadcast(text3, "PersonalAssignment-Complete");
								OnGetData(text3, "PersonalAssignment-Complete");
								Log("Sending Message (Complete): " + text3);
							}
							else
							{
								Assignment assignment2 = activeServerAssignment;
								assignment2.FailureReason = "ANOTHER EMPLOYEE COLLETED THE TARGET ITEM";
								string text4 = JsonUtility.ToJson((object)assignment2);
								Networking.Broadcast(text4, "PersonalAssignment-Failed");
								OnGetData(text4, "PersonalAssignment-Failed");
								Log("Sending Message (Failed): " + text4);
							}
							break;
						}
					}
					break;
				case AssignmentType.KillMonster:
					foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
					{
						if (((NetworkBehaviour)spawnedEnemy).NetworkObjectId == activeServerAssignment.targetIds[0] && spawnedEnemy.isEnemyDead)
						{
							string text5 = JsonUtility.ToJson((object)activeServerAssignment);
							Networking.Broadcast(text5, "PersonalAssignment-Complete");
							OnGetData(text5, "PersonalAssignment-Complete");
							Item val4 = (from a in RoundManager.Instance.currentLevel.spawnableScrap?.Select((SpawnableItemWithRarity a) => a.spawnableItem)
								where a.itemName == "Gold bar"
								select a).First();
							GameObject val5 = Object.Instantiate<GameObject>(val4.spawnPrefab, spawnedEnemy.serverPosition, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer);
							GrabbableObject component3 = val5.GetComponent<GrabbableObject>();
							((Component)component3).transform.rotation = Quaternion.Euler(component3.itemProperties.restingRotation);
							component3.fallTime = 0f;
							component3.scrapValue = activeServerAssignment.CashReward;
							NetworkObject component4 = val5.GetComponent<NetworkObject>();
							component4.Spawn(false);
							((MonoBehaviour)this).StartCoroutine(WaitForScrapToSpawnToSync((NetworkObjectReference[])(object)new NetworkObjectReference[1] { NetworkObjectReference.op_Implicit(component4) }, new int[1] { activeServerAssignment.CashReward }));
							_activeServerAssignments.Remove(activeServerAssignment);
							_completedServerAssignments.Add(activeServerAssignment);
							return;
						}
					}
					break;
				case AssignmentType.RepairValve:
				{
					SteamValveHazard[] array = Object.FindObjectsOfType<SteamValveHazard>();
					SteamValveHazard[] array2 = array;
					foreach (SteamValveHazard val in array2)
					{
						if (((NetworkBehaviour)val).NetworkObjectId != activeServerAssignment.targetIds[0] || val.triggerScript.interactable)
						{
							continue;
						}
						if (((NetworkBehaviour)val.triggerScript).OwnerClientId == activeServerAssignment.PlayerId)
						{
							string text = JsonUtility.ToJson((object)activeServerAssignment);
							Networking.Broadcast(text, "PersonalAssignment-Complete");
							OnGetData(text, "PersonalAssignment-Complete");
							Log("Sending Message (Complete): " + text);
							Item val2 = (from a in RoundManager.Instance.currentLevel.spawnableScrap?.Select((SpawnableItemWithRarity a) => a.spawnableItem)
								where a.itemName == "Gold bar"
								select a).First();
							GameObject val3 = Object.Instantiate<GameObject>(val2.spawnPrefab, ((Component)val).gameObject.transform.position, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer);
							GrabbableObject component = val3.GetComponent<GrabbableObject>();
							((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
							component.fallTime = 0f;
							component.scrapValue = activeServerAssignment.CashReward;
							NetworkObject component2 = val3.GetComponent<NetworkObject>();
							component2.Spawn(false);
							((MonoBehaviour)this).StartCoroutine(WaitForScrapToSpawnToSync((NetworkObjectReference[])(object)new NetworkObjectReference[1] { NetworkObjectReference.op_Implicit(component2) }, new int[1] { activeServerAssignment.CashReward }));
						}
						else
						{
							Assignment assignment = activeServerAssignment;
							assignment.FailureReason = "ANOTHER EMPLOYEE COLLETED THE TARGET ITEM";
							string text2 = JsonUtility.ToJson((object)assignment);
							Networking.Broadcast(text2, "PersonalAssignment-Failed");
							OnGetData(text2, "PersonalAssignment-Failed");
							Log("Sending Message (Failed): " + text2);
						}
						_activeServerAssignments.Remove(activeServerAssignment);
						_completedServerAssignments.Add(activeServerAssignment);
						return;
					}
					break;
				}
				}
			}
		}

		private IEnumerator WaitForScrapToSpawnToSync(NetworkObjectReference[] spawnedScrap, int[] scrapValues)
		{
			yield return (object)new WaitForSeconds(11f);
			RoundManager.Instance.SyncScrapValuesClientRpc(spawnedScrap, scrapValues);
		}

		private void OnGetData(string data, string sig)
		{
			if (!sig.StartsWith("PersonalAssignment"))
			{
				return;
			}
			Log("Inoming data " + sig + " " + data);
			switch (sig)
			{
			case "PersonalAssignment-Allocation":
			{
				Assignment value = JsonUtility.FromJson<Assignment>(data);
				bool flag = value.PlayerId == GameNetworkManager.Instance.localPlayerController.actualClientId;
				if (flag)
				{
					_currentAssignment = value;
					ShowAssignment(_currentAssignment.Value);
				}
				switch (value.Type)
				{
				case AssignmentType.CollectScrapItem:
				{
					if (!flag)
					{
						break;
					}
					GrabbableObject[] array = Object.FindObjectsByType<GrabbableObject>((FindObjectsSortMode)0);
					for (int i = 0; i < array.Length; i++)
					{
						if (((NetworkBehaviour)array[i]).NetworkObjectId == value.targetIds[0])
						{
							SetScrapAsAssignmentTarget(array[i]);
							break;
						}
					}
					break;
				}
				case AssignmentType.KillMonster:
				{
					foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
					{
						if (((NetworkBehaviour)spawnedEnemy).NetworkObjectId == value.targetIds[0])
						{
							ScanNodeProperties componentInChildren = ((Component)spawnedEnemy).gameObject.GetComponentInChildren<ScanNodeProperties>();
							componentInChildren.headerText = "ASSIGNMENT TARGET";
						}
					}
					break;
				}
				case AssignmentType.RepairValve:
					break;
				}
				break;
			}
			case "PersonalAssignment-Complete":
			{
				Assignment assignment2 = JsonUtility.FromJson<Assignment>(data);
				switch (assignment2.Type)
				{
				case AssignmentType.CollectScrapItem:
				{
					if (((NetworkBehaviour)RoundManager.Instance).NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(assignment2.targetIds[0], out var value2))
					{
						GrabbableObject component = ((Component)value2).gameObject.GetComponent<GrabbableObject>();
						SetScrapTargetAsCompleted(component, assignment2.CashReward);
					}
					break;
				}
				}
				if (assignment2.PlayerId == GameNetworkManager.Instance.localPlayerController.actualClientId)
				{
					CompleteAssignment();
				}
				break;
			}
			case "PersonalAssignment-Failed":
			{
				Assignment assignment = JsonUtility.FromJson<Assignment>(data);
				if (assignment.PlayerId == GameNetworkManager.Instance.localPlayerController.actualClientId)
				{
					FailAssignment(assignment.FailureReason);
				}
				break;
			}
			}
		}

		private void ShowAssignment(Assignment assignment)
		{
			//IL_001b: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			if (!((Object)(object)HUDManager.Instance == (Object)null))
			{
				DialogueSegment[] array = (DialogueSegment[])(object)new DialogueSegment[1]
				{
					new DialogueSegment
					{
						speakerText = "ASSIGNMENT:" + assignment.Name,
						bodyText = "YOU HAVE BEEN SELECTED BY THE COMPANY FOR ASSIGNMENT, " + string.Format(assignment.BodyText, assignment.TargetText),
						waitTime = 10f
					}
				};
				_assignmentUI.SetAssignment(assignment);
				HUDManager.Instance.ReadDialogue(array);
			}
		}

		private void CompleteAssignment()
		{
			//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)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			if (_currentAssignment.HasValue)
			{
				DialogueSegment[] array = (DialogueSegment[])(object)new DialogueSegment[1]
				{
					new DialogueSegment
					{
						speakerText = "ASSIGNMENT COMPLETE",
						bodyText = "YOU HAVE COMPLETED THE ASSIGNMENT, WELL DONE. THE COMPANY VALUES YOUR LOYALTY",
						waitTime = 5f
					}
				};
				_assignmentUI.ClearAssignment();
				HUDManager.Instance.ReadDialogue(array);
				_currentAssignment = null;
			}
		}

		private void FailAssignment(string reason)
		{
			//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)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			if (_currentAssignment.HasValue)
			{
				DialogueSegment[] array = (DialogueSegment[])(object)new DialogueSegment[1]
				{
					new DialogueSegment
					{
						speakerText = "ASSIGNMENT FAILED",
						bodyText = "YOU FAILED TO COMPLETE THE ASSIGNMENT. REASON: " + reason,
						waitTime = 5f
					}
				};
				HUDManager.Instance.ReadDialogue(array);
				_currentAssignment = null;
			}
		}

		private void SetScrapAsAssignmentTarget(GrabbableObject scrap)
		{
			Item val = Object.Instantiate<Item>(scrap.itemProperties);
			val.itemName = "ASSIGNMENT TARGET";
			scrap.itemProperties = val;
			ScanNodeProperties componentInChildren = ((Component)scrap).gameObject.GetComponentInChildren<ScanNodeProperties>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Debug.LogError((object)("Scan node is missing for item!: " + ((Object)((Component)this).gameObject).name));
				return;
			}
			componentInChildren.headerText = "ASSIGNMENT TARGET";
			componentInChildren.subText = "Value : ???";
		}

		private void SetScrapTargetAsCompleted(GrabbableObject scrap, int reward)
		{
			scrap.SetScrapValue(reward + scrap.scrapValue);
		}

		private void SetupCollectScrapAssignment(ref Assignment assignment)
		{
			GrabbableObject[] array = Object.FindObjectsByType<GrabbableObject>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				if (!_excludeTargetIds.Contains(((NetworkBehaviour)array[i]).NetworkObjectId) && !array[i].scrapPersistedThroughRounds && array[i].itemProperties.isScrap)
				{
					assignment.targetIds[0] = ((NetworkBehaviour)array[i]).NetworkObjectId;
					assignment.TargetText = array[i].itemProperties.itemName.ToUpper();
					_excludeTargetIds.Add(((NetworkBehaviour)array[i]).NetworkObjectId);
					break;
				}
			}
		}

		private void SetupKillEnemyAssignment(ref Assignment assignment)
		{
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)RoundManager.Instance == (Object)null)
			{
				return;
			}
			bool flag = false;
			for (int i = 0; i < RoundManager.Instance.SpawnedEnemies.Count; i++)
			{
				EnemyAI val = RoundManager.Instance.SpawnedEnemies[i];
				if (_enemyTypeWhitelist.Contains(val.enemyType.enemyName) && ((NetworkBehaviour)val).IsSpawned && !val.isEnemyDead && !_excludeTargetIds.Contains(((NetworkBehaviour)val).NetworkObjectId))
				{
					assignment.targetIds[0] = ((NetworkBehaviour)val).NetworkObjectId;
					assignment.TargetText = val.enemyType.enemyName.ToUpper();
					_excludeTargetIds.Add(((NetworkBehaviour)val).NetworkObjectId);
					flag = true;
					ScanNodeProperties componentInChildren = ((Component)val).gameObject.GetComponentInChildren<ScanNodeProperties>();
					componentInChildren.headerText = "ASSIGNMENT TARGET";
					break;
				}
			}
			if (flag)
			{
				return;
			}
			List<int> list = new List<int>();
			for (int j = 0; j < RoundManager.Instance.currentLevel.Enemies.Count; j++)
			{
				SpawnableEnemyWithRarity val2 = RoundManager.Instance.currentLevel.Enemies[j];
				if (_enemyTypeWhitelist.Contains(val2.enemyType.enemyName))
				{
					list.Add(j);
				}
			}
			Vector3 val3 = Vector3.zero;
			EntranceTeleport[] array = Object.FindObjectsOfType<EntranceTeleport>();
			for (int k = 0; k < array.Length; k++)
			{
				if (!array[k].isEntranceToBuilding && array[k].entranceId == 0)
				{
					val3 = ((Component)array[k]).transform.position;
				}
			}
			int num = list[Random.Range(0, list.Count)];
			List<(EnemyVent, float)> list2 = new List<(EnemyVent, float)>();
			EnemyVent[] allEnemyVents = RoundManager.Instance.allEnemyVents;
			foreach (EnemyVent val4 in allEnemyVents)
			{
				list2.Add((val4, Vector3.Distance(val4.floorNode.position, val3)));
			}
			list2 = list2.OrderByDescending<(EnemyVent, float), float>(((EnemyVent vent, float distance) a) => a.distance).ToList();
			EnemyVent item = list2[Random.Range(0, list2.Count / 2)].Item1;
			RoundManager instance = RoundManager.Instance;
			Vector3 position = item.floorNode.position;
			Quaternion rotation = item.floorNode.rotation;
			instance.SpawnEnemyOnServer(position, ((Quaternion)(ref rotation)).eulerAngles.y, num);
			ulong[] targetIds = assignment.targetIds;
			List<EnemyAI> spawnedEnemies = RoundManager.Instance.SpawnedEnemies;
			targetIds[0] = ((NetworkBehaviour)spawnedEnemies[spawnedEnemies.Count - 1]).NetworkObjectId;
			List<EnemyAI> spawnedEnemies2 = RoundManager.Instance.SpawnedEnemies;
			assignment.TargetText = spawnedEnemies2[spawnedEnemies2.Count - 1].enemyType.enemyName.ToUpper();
			Log($"Didnt find enemy for assignment, spawning a new one {assignment.TargetText} at {item.floorNode.position}");
			_excludeTargetIds.Add(assignment.targetIds[0]);
			List<EnemyAI> spawnedEnemies3 = RoundManager.Instance.SpawnedEnemies;
			ScanNodeProperties componentInChildren2 = ((Component)spawnedEnemies3[spawnedEnemies3.Count - 1]).gameObject.GetComponentInChildren<ScanNodeProperties>();
			componentInChildren2.headerText = "ASSIGNMENT TARGET";
		}

		private void SetupRepairValveAssignment(ref Assignment assignment)
		{
			//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_001d: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = RoundManager.FindMainEntrancePosition(false);
			SteamValveHazard[] array = Object.FindObjectsByType<SteamValveHazard>((FindObjectsSortMode)0);
			float num = 0f;
			int num2 = 0;
			for (int i = 0; i < array.Length; i++)
			{
				float num3 = Vector3.Distance(val, ((Component)array[i]).transform.position);
				if (num3 > num && num3 > 80f)
				{
					num2 = i;
					num = num3;
				}
			}
			if (!_excludeTargetIds.Contains(((NetworkBehaviour)array[num2]).NetworkObjectId) && ((NetworkBehaviour)array[num2]).IsSpawned)
			{
				assignment.targetIds[0] = ((NetworkBehaviour)array[num2]).NetworkObjectId;
				assignment.TargetText = "BROKEN VALVE";
				_excludeTargetIds.Add(((NetworkBehaviour)array[num2]).NetworkObjectId);
				array[num2].valveCrackTime = 0.001f;
				array[num2].valveBurstTime = 0.01f;
				array[num2].triggerScript.interactable = true;
				assignment.FixedTargetPosition = ((Component)array[num2]).gameObject.transform.position;
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "EmployeeAssignments";

		public const string PLUGIN_NAME = "EmployeeAssignments";

		public const string PLUGIN_VERSION = "1.0.4";
	}
}