using System;
using System.Collections;
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.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CompanyProtocols.Networking;
using CompanyProtocols.TerminalPatches;
using GameMecanicOverhaul;
using GameNetcodeStuff;
using HarmonyLib;
using LethalNetworkAPI;
using LethalReplacementCrew;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
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("LethalCompanyProtocols")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LethalCompanyProtocols")]
[assembly: AssemblyTitle("LethalCompanyProtocols")]
[assembly: AssemblyVersion("1.0.0.0")]
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;
		}
	}
}
[HarmonyPatch(typeof(HUDManager))]
public class ClockPatch
{
	[HarmonyPatch("Update")]
	[HarmonyPostfix]
	private static void UpdateClockFluidly()
	{
		if ((Object)(object)TimeOfDay.Instance == (Object)null || (Object)(object)HUDManager.Instance?.clockNumber == (Object)null || HUDManager.Instance.Clock.canvasGroup.alpha <= 0f)
		{
			return;
		}
		float normalizedTimeOfDay = TimeOfDay.Instance.normalizedTimeOfDay;
		int num = (int)(normalizedTimeOfDay * 1080f);
		int num2 = num / 60 + 6;
		int num3 = num % 60;
		if (num2 >= 24)
		{
			((TMP_Text)HUDManager.Instance.clockNumber).text = "12:00 AM";
			return;
		}
		string arg = ((num2 >= 12) ? "PM" : "AM");
		int num4 = num2 % 12;
		if (num4 == 0)
		{
			num4 = 12;
		}
		((TMP_Text)HUDManager.Instance.clockNumber).text = $"{num4}:{num3:00} {arg}";
	}
}
[HarmonyPatch(typeof(StartOfRound), "ShipHasLeft")]
public class EnemyCalculator
{
	[HarmonyPrefix]
	private static void Prefix()
	{
		Plugin.IndoorEnemyNames.Clear();
		Plugin.OutdoorEnemyNames.Clear();
		EnemyAI[] array = Object.FindObjectsOfType<EnemyAI>();
		EnemyAI[] array2 = array;
		foreach (EnemyAI val in array2)
		{
			if (!val.isEnemyDead)
			{
				string enemyName = val.enemyType.enemyName;
				if (val.isOutside)
				{
					Plugin.OutdoorEnemyNames.Add(enemyName);
				}
				else
				{
					Plugin.IndoorEnemyNames.Add(enemyName);
				}
			}
		}
	}
}
namespace CompanyProtocols.TerminalPatches
{
	[HarmonyPatch(typeof(Terminal), "TextPostProcess")]
	public class TerminalDisplayPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Terminal __instance, ref string __result)
		{
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Invalid comparison between Unknown and I4
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(__result) || Plugin.ChosenMoonNames == null || !__result.Contains("Welcome to the exomoons catalogue"))
			{
				return;
			}
			LandingTimeManager.GenerateLandingTimes();
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("\n\n\n");
			stringBuilder.AppendLine("<color=red>[ COMPANY TARGETS - ASSIGNED MISSIONS ]</color>");
			stringBuilder.AppendLine("---------------------------------------------------\n");
			IOrderedEnumerable<SelectableLevel> orderedEnumerable = from m in __instance.moonsCatalogueList
				where Plugin.ChosenMoonNames.Contains(((Object)m).name) && !Plugin.VisitedMoonNames.Contains(((Object)m).name)
				orderby GetRiskScore(m.riskLevel)
				select m;
			if (!orderedEnumerable.Any())
			{
				stringBuilder.AppendLine("<color=yellow>ALL TARGETS CLEARED.</color>\nNo further missions available.");
			}
			else
			{
				foreach (SelectableLevel item in orderedEnumerable)
				{
					string arg = "<color=#FFFFFF>8.0h</color>";
					if (LandingTimeManager.MoonLandingTimes.TryGetValue(((Object)item).name, out MoonTimeData value))
					{
						string text = ((value.Type == LandingTimeType.Early) ? "#00FFFF" : ((value.Type != LandingTimeType.Late) ? "#FFFFFF" : "#FFA500"));
						string text2 = LandingTimeManager.FormatTimeToClock(value.TargetHour);
						arg = "<color=" + text + ">" + text2 + "</color>";
					}
					stringBuilder.AppendLine("> <b>" + item.PlanetName.ToUpper() + "</b>");
					string arg2 = (((int)item.currentWeather != -1) ? "#FFFF00" : "#FFFFFF");
					stringBuilder.AppendLine($"<size=80%><b>RISK:</b> {item.riskLevel.PadRight(4)} | <b>SCRAP:</b> {item.minScrap}-{item.maxScrap} (${(int)CalculateMoonScrapAverage(item)})</size>");
					stringBuilder.AppendLine($"<size=80%><b>INFO:</b> <color={arg2}>{item.currentWeather}</color> ({arg})</size>");
					stringBuilder.AppendLine(" ");
					stringBuilder.AppendLine("");
				}
			}
			stringBuilder.AppendLine("---------------------------------------------------");
			stringBuilder.AppendLine("[ Type moon name to route the ship ]\n");
			__result = stringBuilder.ToString();
		}

		private static int GetRiskScore(string risk)
		{
			if (string.IsNullOrEmpty(risk))
			{
				return 0;
			}
			if (risk.Contains("S"))
			{
				return 5;
			}
			if (risk.Contains("A"))
			{
				return 4;
			}
			if (risk.Contains("B"))
			{
				return 3;
			}
			if (risk.Contains("C"))
			{
				return 2;
			}
			if (risk.Contains("D"))
			{
				return 1;
			}
			return 1;
		}

		public static float CalculateMoonScrapAverage(SelectableLevel level)
		{
			if ((Object)(object)level == (Object)null || level.spawnableScrap == null || level.spawnableScrap.Count == 0)
			{
				return 0f;
			}
			float num = 0f;
			int num2 = 0;
			foreach (SpawnableItemWithRarity item in level.spawnableScrap)
			{
				num2 += item.rarity;
			}
			for (int i = 0; i < 500; i++)
			{
				int num3 = Random.Range(level.minScrap, level.maxScrap + 1);
				for (int j = 0; j < num3; j++)
				{
					num += GetWeightedRandomScrapValue(level.spawnableScrap, num2);
				}
			}
			return num / 500f;
		}

		private static float GetWeightedRandomScrapValue(List<SpawnableItemWithRarity> pool, int totalWeight)
		{
			int num = Random.Range(0, totalWeight);
			int num2 = 0;
			foreach (SpawnableItemWithRarity item in pool)
			{
				num2 += item.rarity;
				if (num < num2)
				{
					float num3 = Random.Range(item.spawnableItem.minValue, item.spawnableItem.maxValue);
					return num3 * 0.4f;
				}
			}
			return 0f;
		}
	}
	[HarmonyPatch(typeof(Terminal), "Start")]
	public class TerminalPricePatch
	{
		[HarmonyPostfix]
		private static void Postfix(Terminal __instance)
		{
			TerminalKeyword val = ((IEnumerable<TerminalKeyword>)__instance.terminalNodes.allKeywords).FirstOrDefault((Func<TerminalKeyword, bool>)((TerminalKeyword k) => k.word == "route"));
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			CompatibleNoun[] compatibleNouns = val.compatibleNouns;
			foreach (CompatibleNoun val2 in compatibleNouns)
			{
				if (!((Object)(object)val2.result != (Object)null))
				{
					continue;
				}
				val2.result.itemCost = 0;
				if (val2.result.terminalOptions == null)
				{
					continue;
				}
				CompatibleNoun[] terminalOptions = val2.result.terminalOptions;
				foreach (CompatibleNoun val3 in terminalOptions)
				{
					if ((Object)(object)val3.result != (Object)null)
					{
						val3.result.itemCost = 0;
					}
				}
			}
		}
	}
}
namespace CompanyProtocols.Networking
{
	public class Networking
	{
		public LNetworkVariable<string[]> ChosenMoonsVar;

		public LNetworkVariable<string[]> VisitedMoonsVar;

		public LNetworkVariable<int[]> MoonSeedsVar;

		public LNetworkMessage<string> HudAlertMsg;

		public LNetworkMessage<int> RequestSyncMsg;

		public LNetworkMessage<int> SyncQuotaMsg;

		public static Networking Instance { get; private set; }

		public Networking()
		{
			Instance = this;
			Plugin.Log.LogInfo((object)"[GMO Networking] Starting Initialization...");
			try
			{
				ChosenMoonsVar = LNetworkVariable<string[]>.Connect("GMO_ChosenMoons", new string[0], (LNetworkVariableWritePerms)0, (Action<string[], string[]>)delegate(string[] oldVal, string[] newVal)
				{
					if (newVal != null)
					{
						Plugin.ChosenMoonNames.Clear();
						Plugin.ChosenMoonNames = newVal.ToList();
					}
				});
				VisitedMoonsVar = LNetworkVariable<string[]>.Connect("GMO_VisitedMoons", new string[0], (LNetworkVariableWritePerms)0, (Action<string[], string[]>)delegate(string[] oldVal, string[] newVal)
				{
					if (newVal != null)
					{
						Plugin.VisitedMoonNames.Clear();
						Plugin.VisitedMoonNames = newVal.ToList();
					}
				});
				MoonSeedsVar = LNetworkVariable<int[]>.Connect("GMO_MoonSeeds", new int[0], (LNetworkVariableWritePerms)0, (Action<int[], int[]>)delegate(int[] oldVal, int[] newVal)
				{
					if (newVal != null)
					{
						Plugin.MoonSeeds.Clear();
						Plugin.MoonSeeds = newVal.ToList();
						LandingTimeManager.GenerateLandingTimes();
					}
				});
				SyncQuotaMsg = LNetworkMessage<int>.Connect("GMO_SyncQuota", (Action<int, ulong>)null, (Action<int>)null, (Action<int, ulong>)null);
				Plugin.Log.LogInfo((object)"[GMO Networking] Variables connected.");
				HudAlertMsg = LNetworkMessage<string>.Connect("GMO_HudAlert", (Action<string, ulong>)null, (Action<string>)null, (Action<string, ulong>)null);
				RequestSyncMsg = LNetworkMessage<int>.Connect("GMO_RequestSync", (Action<int, ulong>)null, (Action<int>)null, (Action<int, ulong>)null);
				Plugin.Log.LogInfo((object)"[GMO Networking] Messages connected.");
				SyncQuotaMsg.OnClientReceived += delegate(int newQuota)
				{
					Plugin.Log.LogInfo((object)$"[GMO NetMsg] Syncing quota fulfilled: {newQuota}");
					TimeOfDay.Instance.quotaFulfilled = newQuota;
					TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
				};
				HudAlertMsg.OnClientReceived += delegate(string moonName)
				{
					Plugin.Log.LogInfo((object)("[GMO NetMsg] Received HUD Alert for: " + moonName));
					if ((Object)(object)HUDManager.Instance != (Object)null)
					{
						HUDManager.Instance.DisplayTip("DESTINATION CHANGED", "The Company deploys you on " + moonName + " !", true, false, "LC_Tip1");
					}
					else
					{
						Plugin.Log.LogWarning((object)"[GMO NetMsg] HUDManager.Instance is NULL, cannot display alert.");
					}
				};
				RequestSyncMsg.OnServerReceived += delegate(int val, ulong clientId)
				{
					Plugin.Log.LogInfo((object)$"[GMO NetMsg] Server received Sync Request from Client ID: {clientId}");
					if ((Object)(object)NetworkManager.Singleton != (Object)null && NetworkManager.Singleton.IsServer)
					{
						Plugin.Log.LogInfo((object)"[GMO NetMsg] Processing sync for client...");
						ChosenMoonsVar.Value = Plugin.ChosenMoonNames.ToArray();
						VisitedMoonsVar.Value = Plugin.VisitedMoonNames.ToArray();
						MoonSeedsVar.Value = Plugin.MoonSeeds.ToArray();
					}
					else
					{
						Plugin.Log.LogWarning((object)"[GMO NetMsg] RequestSync received but this peer is not the Server.");
					}
				};
				Plugin.Log.LogInfo((object)"[GMO Networking] All handlers hooked successfully.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[GMO Networking] CRITICAL ERROR DURING INIT: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		public static void Init()
		{
			if (Instance == null)
			{
				Plugin.Log.LogInfo((object)"[GMO Networking] Initializing Singleton...");
				new Networking();
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class NetworkLifeCycle
	{
		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static void SyncOnStartHost(StartOfRound __instance)
		{
			if (NetworkManager.Singleton.IsConnectedClient)
			{
				Networking.Instance.RequestSyncMsg.SendServer((int)NetworkManager.Singleton.LocalClientId);
			}
		}
	}
}
namespace LethalReplacementCrew
{
	[HarmonyPatch]
	public class ReplacementCrewHandler : MonoBehaviour
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Item, bool> <>9__11_0;

			public static Func<PlayerControllerB, bool> <>9__11_1;

			public static Func<SpawnableEnemyWithRarity, bool> <>9__12_0;

			public static Func<PlayerControllerB, bool> <>9__12_1;

			public static Func<SpawnableEnemyWithRarity, bool> <>9__15_0;

			public static Func<PlayerControllerB, bool> <>9__15_1;

			public static HandleNamedMessageDelegate <>9__20_0;

			public static HandleNamedMessageDelegate <>9__20_1;

			internal bool <SpawnScrapScattered>b__11_0(Item item)
			{
				return item.isScrap && (Object)(object)item.spawnPrefab != (Object)null;
			}

			internal bool <SpawnScrapScattered>b__11_1(PlayerControllerB p)
			{
				return p.isPlayerControlled;
			}

			internal bool <SpawnMaskedOnGround>b__12_0(SpawnableEnemyWithRarity e)
			{
				return e.enemyType.enemyName.Contains("Masked");
			}

			internal bool <SpawnMaskedOnGround>b__12_1(PlayerControllerB p)
			{
				return p.isPlayerControlled;
			}

			internal bool <SpawnMaskedOnGround>b__15_0(SpawnableEnemyWithRarity e)
			{
				return e.enemyType.enemyName.Contains("Masked");
			}

			internal bool <SpawnMaskedOnGround>b__15_1(PlayerControllerB p)
			{
				return p.isPlayerControlled;
			}

			internal void <RegisterNetworkMessages>b__20_0(ulong senderId, FastBufferReader reader)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				if (!NetworkManager.Singleton.IsServer)
				{
					Vector3 pos = default(Vector3);
					((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
					Quaternion rot = default(Quaternion);
					((FastBufferReader)(ref reader)).ReadValueSafe(ref rot);
					SpawnFakeShipLocal(pos, rot);
				}
			}

			internal void <RegisterNetworkMessages>b__20_1(ulong senderId, FastBufferReader reader)
			{
				if (!NetworkManager.Singleton.IsServer)
				{
					ShowIntrusionAlertLocal();
				}
			}
		}

		[CompilerGenerated]
		private sealed class <DisablePhysicsAfterDelay>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject ship;

			public Rigidbody rb;

			public float delay;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DisablePhysicsAfterDelay>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)rb != (Object)null)
					{
						rb.isKinematic = true;
						rb.useGravity = false;
						Physics.SyncTransforms();
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ExecuteEventSequence>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private GameObject[] <nodes>5__1;

			private Transform <targetNode>5__2;

			private Vector3 <groundPosition>5__3;

			private Vector3 <shipPosition>5__4;

			private Quaternion <flatRotation>5__5;

			private GameObject <ship>5__6;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ExecuteEventSequence>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<nodes>5__1 = null;
				<targetNode>5__2 = null;
				<ship>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Expected O, but got Unknown
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Expected O, but got Unknown
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<nodes>5__1 = GameObject.FindGameObjectsWithTag("OutsideAINode");
					if (<nodes>5__1 == null || <nodes>5__1.Length == 0)
					{
						return false;
					}
					<targetNode>5__2 = <nodes>5__1[Random.Range(0, <nodes>5__1.Length)].transform;
					<groundPosition>5__3 = <targetNode>5__2.position;
					<shipPosition>5__4 = <groundPosition>5__3 + Vector3.up * heightOffset;
					SendAlertToAllClients();
					<flatRotation>5__5 = Quaternion.Euler(0f, <targetNode>5__2.eulerAngles.y, 0f);
					<ship>5__6 = SpawnFakeShipLocal(<shipPosition>5__4, <flatRotation>5__5);
					SyncShipToClients(<shipPosition>5__4, <flatRotation>5__5);
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(10f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					SpawnScrapScattered(<groundPosition>5__3, 8f);
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					SpawnMaskedOnGround(<groundPosition>5__3, 6f);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static float heightOffset = 40f;

		private const string SHIP_SPAWN_MESSAGE = "ReplacementCrew_SpawnShip";

		private const string HUD_ALERT_MESSAGE = "ReplacementCrew_HUDAlert";

		public static GameObject FakeShipPrefab = null;

		private static bool hasEventOccurredThisLevel = false;

		private static int lastCheckedHour = -1;

		[HarmonyPatch(typeof(RoundManager), "FinishGeneratingLevel")]
		[HarmonyPostfix]
		private static void ResetLevelStatus()
		{
			hasEventOccurredThisLevel = false;
			lastCheckedHour = -1;
		}

		[HarmonyPatch(typeof(TimeOfDay), "Update")]
		[HarmonyPostfix]
		private static void CheckTimeForEvent(TimeOfDay __instance)
		{
			if (!NetworkManager.Singleton.IsServer || hasEventOccurredThisLevel)
			{
				return;
			}
			if (StartOfRound.Instance.inShipPhase || (Object)(object)StartOfRound.Instance.currentLevel == (Object)null)
			{
				lastCheckedHour = -1;
				return;
			}
			float num = 7.85f;
			string name = ((Object)StartOfRound.Instance.currentLevel).name;
			if (LandingTimeManager.MoonLandingTimes.TryGetValue(name, out MoonTimeData value))
			{
				num = value.TargetHour;
			}
			float num2 = 6f + __instance.normalizedTimeOfDay * 18f;
			int num3 = (int)num2;
			if (num2 >= num + 4f && num3 != lastCheckedHour && num3 % 2 == 0)
			{
				lastCheckedHour = num3;
				if (Random.value < 0.025f)
				{
					hasEventOccurredThisLevel = true;
					((MonoBehaviour)RoundManager.Instance).StartCoroutine(ExecuteEventSequence());
				}
			}
		}

		[IteratorStateMachine(typeof(<ExecuteEventSequence>d__8))]
		private static IEnumerator ExecuteEventSequence()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ExecuteEventSequence>d__8(0);
		}

		private static void ShowIntrusionAlertLocal()
		{
			EventHUDUtility.DisplayWarning("EMERGENCY ATMOSPHERIC ALERT", "UNIDENTIFIED VESSEL DETECTED\nINTRUSION IN LUNAR AIRSPACE", HUDManager.Instance.meteorShowerWarningAudio);
		}

		private static Vector3 GetGuaranteedNavMeshPosition(Vector3 center, float radius, int maxAttempts = 30)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			NavMeshHit val3 = default(NavMeshHit);
			for (int i = 0; i < maxAttempts; i++)
			{
				Vector2 val = Random.insideUnitCircle * radius;
				Vector3 val2 = center + new Vector3(val.x, 0f, val.y);
				if (NavMesh.SamplePosition(val2, ref val3, 2f, -1))
				{
					return ((NavMeshHit)(ref val3)).position;
				}
			}
			NavMeshHit val4 = default(NavMeshHit);
			if (NavMesh.SamplePosition(center, ref val4, 5f, -1))
			{
				Debug.LogWarning((object)"[GMO] Fallback to snapped center for NavMesh.");
				return ((NavMeshHit)(ref val4)).position;
			}
			Debug.LogError((object)"[GMO] Impossible de trouver un point NavMesh, spawn forcé au point brut !");
			return center;
		}

		private static void SpawnScrapScattered(Vector3 centerNodePos, float spawnRadius)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkManager.Singleton.IsServer)
			{
				return;
			}
			List<Item> list = StartOfRound.Instance.allItemsList.itemsList.Where((Item item) => item.isScrap && (Object)(object)item.spawnPrefab != (Object)null).ToList();
			if (list.Count == 0)
			{
				return;
			}
			int num = StartOfRound.Instance.allPlayerScripts.Count((PlayerControllerB p) => p.isPlayerControlled);
			int num2 = Random.Range(Mathf.Max(1, num / 2), num + 1);
			List<NetworkObjectReference> list2 = new List<NetworkObjectReference>();
			List<int> list3 = new List<int>();
			for (int i = 0; i < num2; i++)
			{
				Item val = list[Random.Range(0, list.Count)];
				Vector3 guaranteedNavMeshPosition = GetGuaranteedNavMeshPosition(centerNodePos, spawnRadius);
				guaranteedNavMeshPosition += Vector3.up * 0.5f;
				GameObject val2 = Object.Instantiate<GameObject>(val.spawnPrefab, guaranteedNavMeshPosition, Quaternion.identity);
				NetworkObject component = val2.GetComponent<NetworkObject>();
				if ((Object)(object)component != (Object)null)
				{
					component.Spawn(false);
					int num3 = (int)((float)Random.Range(val.minValue, val.maxValue) * 0.4f);
					GrabbableObject component2 = val2.GetComponent<GrabbableObject>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.targetFloorPosition = guaranteedNavMeshPosition - Vector3.up * 0.5f;
						component2.SetScrapValue(num3);
						list2.Add(NetworkObjectReference.op_Implicit(component));
						list3.Add(num3);
					}
				}
			}
			if (list2.Count > 0)
			{
				RoundManager.Instance.SyncScrapValuesClientRpc(list2.ToArray(), list3.ToArray());
			}
		}

		private static void SpawnMaskedOnGround(Vector3 centerNodePos, float spawnRadius)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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)
			if (!NetworkManager.Singleton.IsServer)
			{
				return;
			}
			EnemyType val = ((IEnumerable<SpawnableEnemyWithRarity>)RoundManager.Instance.currentLevel.Enemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity e) => e.enemyType.enemyName.Contains("Masked")))?.enemyType;
			if (!((Object)(object)val == (Object)null))
			{
				int num = StartOfRound.Instance.allPlayerScripts.Count((PlayerControllerB p) => p.isPlayerControlled);
				for (int i = 0; i < num; i++)
				{
					Vector3 guaranteedNavMeshPosition = GetGuaranteedNavMeshPosition(centerNodePos, spawnRadius);
					RoundManager.Instance.SpawnEnemyGameObject(guaranteedNavMeshPosition, 0f, -1, val);
				}
			}
		}

		private static GameObject SpawnFakeShipLocal(Vector3 pos, Quaternion rot)
		{
			//IL_001b: 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)
			if ((Object)(object)FakeShipPrefab == (Object)null)
			{
				LoadAssets();
			}
			GameObject val = Object.Instantiate<GameObject>(FakeShipPrefab, pos, rot);
			SetLayerRecursive(val, 8);
			Rigidbody component = val.GetComponent<Rigidbody>();
			component.mass = 5000f;
			component.useGravity = true;
			component.isKinematic = false;
			component.collisionDetectionMode = (CollisionDetectionMode)1;
			GameObject val2 = GameObject.Find("Environment");
			if ((Object)(object)val2 != (Object)null)
			{
				val.transform.SetParent(val2.transform);
			}
			((MonoBehaviour)RoundManager.Instance).StartCoroutine(DisablePhysicsAfterDelay(val, component, 10f));
			return val;
		}

		[IteratorStateMachine(typeof(<DisablePhysicsAfterDelay>d__14))]
		private static IEnumerator DisablePhysicsAfterDelay(GameObject ship, Rigidbody rb, float delay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DisablePhysicsAfterDelay>d__14(0)
			{
				ship = ship,
				rb = rb,
				delay = delay
			};
		}

		private static void SpawnMaskedOnGround(Vector3 groundPos, Vector3 AINode)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			EnemyType val = ((IEnumerable<SpawnableEnemyWithRarity>)RoundManager.Instance.currentLevel.Enemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity e) => e.enemyType.enemyName.Contains("Masked")))?.enemyType;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			int num = StartOfRound.Instance.allPlayerScripts.Count((PlayerControllerB p) => p.isPlayerControlled);
			NavMeshHit val3 = default(NavMeshHit);
			for (int i = 0; i < num; i++)
			{
				Vector3 val2 = groundPos + new Vector3(Random.Range(-3f, 3f), 0f, Random.Range(-3f, 3f));
				if (NavMesh.SamplePosition(val2, ref val3, 10f, -1))
				{
					RoundManager.Instance.SpawnEnemyGameObject(((NavMeshHit)(ref val3)).position, 0f, -1, val);
				}
				else
				{
					RoundManager.Instance.SpawnEnemyGameObject(AINode, 0f, -1, val);
				}
			}
		}

		private static void SetLayerRecursive(GameObject obj, int newLayer)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			obj.layer = newLayer;
			foreach (Transform item in obj.transform)
			{
				Transform val = item;
				SetLayerRecursive(((Component)val).gameObject, newLayer);
			}
		}

		private static void SendAlertToAllClients()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsServer)
			{
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll("ReplacementCrew_HUDAlert", new FastBufferWriter(0, (Allocator)2, -1), (NetworkDelivery)3);
				ShowIntrusionAlertLocal();
			}
		}

		private static void SyncShipToClients(Vector3 pos, Quaternion rot)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(28, (Allocator)2, -1);
			((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
			((FastBufferWriter)(ref val)).WriteValueSafe(ref rot);
			NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll("ReplacementCrew_SpawnShip", val, (NetworkDelivery)3);
		}

		public static void LoadAssets()
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			AssetBundle val = AssetBundle.LoadFromFile(Path.Combine(directoryName, "fakeshipevent"));
			if ((Object)(object)val != (Object)null)
			{
				FakeShipPrefab = val.LoadAsset<GameObject>("FakeShip");
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPostfix]
		private static void RegisterNetworkMessages()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			if ((Object)(object)NetworkManager.Singleton == (Object)null)
			{
				return;
			}
			CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
			object obj = <>c.<>9__20_0;
			if (obj == null)
			{
				HandleNamedMessageDelegate val = delegate(ulong senderId, FastBufferReader reader)
				{
					//IL_0025: Unknown result type (might be due to invalid IL or missing references)
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					if (!NetworkManager.Singleton.IsServer)
					{
						Vector3 pos = default(Vector3);
						((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
						Quaternion rot = default(Quaternion);
						((FastBufferReader)(ref reader)).ReadValueSafe(ref rot);
						SpawnFakeShipLocal(pos, rot);
					}
				};
				<>c.<>9__20_0 = val;
				obj = (object)val;
			}
			customMessagingManager.RegisterNamedMessageHandler("ReplacementCrew_SpawnShip", (HandleNamedMessageDelegate)obj);
			CustomMessagingManager customMessagingManager2 = NetworkManager.Singleton.CustomMessagingManager;
			object obj2 = <>c.<>9__20_1;
			if (obj2 == null)
			{
				HandleNamedMessageDelegate val2 = delegate
				{
					if (!NetworkManager.Singleton.IsServer)
					{
						ShowIntrusionAlertLocal();
					}
				};
				<>c.<>9__20_1 = val2;
				obj2 = (object)val2;
			}
			customMessagingManager2.RegisterNamedMessageHandler("ReplacementCrew_HUDAlert", (HandleNamedMessageDelegate)obj2);
		}
	}
}
namespace LethalCompanyProtocols
{
	internal class LagFixer
	{
		[HarmonyPatch(typeof(StartOfRound), "StartGame")]
		[HarmonyPrefix]
		private static void SpeedUpLoading()
		{
			Application.backgroundLoadingPriority = (ThreadPriority)4;
			GC.Collect();
		}

		[HarmonyPatch(typeof(RoundManager), "GenerateLevel")]
		[HarmonyPrefix]
		private static void PreGenerateLevel()
		{
			QualitySettings.asyncUploadBufferSize = 64;
		}
	}
}
namespace GameMecanicOverhaul
{
	[HarmonyPatch(typeof(StartOfRound), "ArriveAtLevel")]
	public class AutoLandingPatch
	{
		[HarmonyPostfix]
		private static void Postfix(StartOfRound __instance)
		{
			if (NetworkManager.Singleton.IsServer && Plugin.IsDiverting)
			{
				__instance.StartGameServerRpc();
			}
		}
	}
	[HarmonyPatch(typeof(EndRoundStatsPatch), "ReplaceEndGameScreen")]
	public class DayEndPatch
	{
		[HarmonyPrefix]
		private static void Prefix()
		{
			ScrapTracker.CalculateCollectedScrap();
			Plugin.PlayersRegistry.Clear();
			int num = 0;
			bool flag = false;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!val.isPlayerControlled && !val.isPlayerDead)
				{
					continue;
				}
				bool flag2 = !val.isPlayerDead && (val.isInHangarShipRoom || val.isInElevator);
				if (flag2)
				{
					flag = true;
				}
				string causeOfDeath = "None";
				if (val.isPlayerDead)
				{
					causeOfDeath = ((object)(CauseOfDeath)(ref val.causeOfDeath)).ToString();
				}
				else if (!flag2)
				{
					causeOfDeath = "Abandoned";
				}
				Plugin.PlayersRegistry[val.playerClientId] = new Plugin.PlayerData
				{
					PlayerName = val.playerUsername,
					IsAlive = flag2,
					Health = val.health,
					CauseOfDeath = causeOfDeath
				};
				if (flag2)
				{
					continue;
				}
				if (val.isPlayerDead)
				{
					if ((Object)(object)val.deadBody == (Object)null || !val.deadBody.isInShip)
					{
						num++;
					}
				}
				else
				{
					num++;
				}
			}
			if (!flag)
			{
				Plugin.collectedScrapSurLune = 0;
				Plugin.collectedNB = 0;
			}
			Terminal val2 = Object.FindObjectOfType<Terminal>();
			int num2 = (((Object)(object)val2 != (Object)null) ? val2.groupCredits : 0);
			int num3 = num2;
			for (int j = 0; j < num; j++)
			{
				num3 -= Mathf.CeilToInt((float)num3 * 0.2f);
			}
			Plugin.TeamsPenalty = num2 - num3;
		}
	}
	[HarmonyPatch(typeof(DeleteFileButton), "DeleteFile")]
	public class DeletePatch
	{
		[HarmonyPrefix]
		private static void Prefix(DeleteFileButton __instance)
		{
			int fileToDelete = __instance.fileToDelete;
			if (1 == 0)
			{
			}
			string text = fileToDelete switch
			{
				0 => "LCSaveFile1", 
				1 => "LCSaveFile2", 
				2 => "LCSaveFile3", 
				_ => "LCSaveFile1", 
			};
			if (1 == 0)
			{
			}
			string text2 = text;
			string path = Path.Combine(Application.persistentDataPath, text2 + "_gmo.txt");
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[GMO] Error deleting custom save files: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	public class DisconnectPatch
	{
		[HarmonyPatch("ResetGameValuesToDefault")]
		[HarmonyPostfix]
		public static void ResetVariablesOnDisconnect()
		{
			Plugin.CurrentRunMultiplier = 1f;
			Plugin.collectedScrapSurLune = 0;
			Plugin.totalScrapSurLune = 0;
			Plugin.TeamsPenalty = 0;
			Plugin.collectedNB = 0;
			Plugin.allNB = 0;
			Plugin.IsDiverting = false;
			Plugin.VisitedMoonNames.Clear();
			Plugin.ChosenMoonNames.Clear();
			Plugin.MoonSeeds.Clear();
			LandingTimeManager.LandingTimePatch.IsTimeAppliedForToday = false;
		}
	}
	[HarmonyPatch(typeof(HUDManager), "FillEndGameStats")]
	public class EndRoundPatch
	{
		[HarmonyPrefix]
		public static void Prefix()
		{
			if (StartOfRound.Instance.currentLevelID != 3)
			{
				Plugin.VisitedMoonNames.Add(((Object)StartOfRound.Instance.currentLevel).name);
				LandingTimeManager.GenerateLandingTimes();
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "FillEndGameStats")]
	public class EndRoundStatsPatch
	{
		[HarmonyPrefix]
		public static bool ReplaceEndGameScreen(HUDManager __instance, EndOfGameStats stats)
		{
			if ((Object)(object)GMO_UIManager.Instance == (Object)null)
			{
				GMO_UIManager.Instance = ((Component)__instance).gameObject.AddComponent<GMO_UIManager>();
				GMO_UIManager.Instance.Initialize();
			}
			HUDManager.Instance.RemoveSpectateUI();
			if (StartOfRound.Instance.currentLevelID != 3)
			{
				GMO_UIManager.Instance.ShowResults(stats);
			}
			return false;
		}
	}
	public static class EventHUDUtility
	{
		[CompilerGenerated]
		private sealed class <WarningAnimationSequence>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private float <elapsed>5__1;

			private float <alertTimer>5__2;

			private float <pulse>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WarningAnimationSequence>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<elapsed>5__1 = 0f;
					goto IL_0086;
				case 1:
					<>1__state = -1;
					goto IL_0086;
				case 2:
					<>1__state = -1;
					goto IL_0102;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_0086:
					if (<elapsed>5__1 < 0.2f)
					{
						<elapsed>5__1 += Time.deltaTime;
						_canvasGroup.alpha = <elapsed>5__1 / 0.2f;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<alertTimer>5__2 = 0f;
					goto IL_0102;
					IL_0102:
					if (<alertTimer>5__2 < 8f)
					{
						<alertTimer>5__2 += Time.deltaTime;
						<pulse>5__3 = 0.75f + Mathf.Sin(Time.time * 10f) * 0.25f;
						((TMP_Text)_titleText).alpha = <pulse>5__3;
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<elapsed>5__1 = 0f;
					break;
				}
				if (<elapsed>5__1 < 0.5f)
				{
					<elapsed>5__1 += Time.deltaTime;
					_canvasGroup.alpha = 1f - <elapsed>5__1 / 0.5f;
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static GameObject _warningCanvasObj;

		private static TextMeshProUGUI _titleText;

		private static TextMeshProUGUI _bodyText;

		private static CanvasGroup _canvasGroup;

		public static void DisplayWarning(string title, string body, AudioClip sfx = null)
		{
			if (!((Object)(object)HUDManager.Instance == (Object)null))
			{
				if ((Object)(object)_warningCanvasObj == (Object)null)
				{
					BuildWarningUI();
				}
				((TMP_Text)_titleText).text = title;
				((TMP_Text)_bodyText).text = body;
				if ((Object)(object)sfx != (Object)null && (Object)(object)HUDManager.Instance.UIAudio != (Object)null)
				{
					HUDManager.Instance.UIAudio.PlayOneShot(sfx, 1f);
				}
				((MonoBehaviour)HUDManager.Instance).StartCoroutine(WarningAnimationSequence());
			}
		}

		private static void BuildWarningUI()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("Systems/UI/Canvas");
			if (!((Object)(object)val == (Object)null))
			{
				_warningCanvasObj = new GameObject("GMO_WarningUI");
				_warningCanvasObj.transform.SetParent(val.transform, false);
				RectTransform val2 = _warningCanvasObj.AddComponent<RectTransform>();
				val2.anchorMin = Vector2.zero;
				val2.anchorMax = Vector2.one;
				val2.offsetMin = Vector2.zero;
				val2.offsetMax = Vector2.zero;
				_canvasGroup = _warningCanvasObj.AddComponent<CanvasGroup>();
				_canvasGroup.alpha = 0f;
				GameObject val3 = new GameObject("Background");
				val3.transform.SetParent(_warningCanvasObj.transform, false);
				Image val4 = val3.AddComponent<Image>();
				((Graphic)val4).color = new Color(0f, 0f, 0f, 0.1f);
				RectTransform rectTransform = ((Graphic)val4).rectTransform;
				rectTransform.anchorMin = new Vector2(0f, 0.5f);
				rectTransform.anchorMax = new Vector2(1f, 0.5f);
				rectTransform.pivot = new Vector2(0.5f, 0.5f);
				rectTransform.sizeDelta = new Vector2(0f, 100f);
				VerticalLayoutGroup val5 = val3.AddComponent<VerticalLayoutGroup>();
				((LayoutGroup)val5).childAlignment = (TextAnchor)4;
				((HorizontalOrVerticalLayoutGroup)val5).childControlHeight = true;
				((HorizontalOrVerticalLayoutGroup)val5).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)val5).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)val5).childForceExpandWidth = true;
				((LayoutGroup)val5).padding = new RectOffset(20, 20, 20, 20);
				((HorizontalOrVerticalLayoutGroup)val5).spacing = 10f;
				ContentSizeFitter val6 = val3.AddComponent<ContentSizeFitter>();
				val6.verticalFit = (FitMode)2;
				TMP_FontAsset font = ((TMP_Text)HUDManager.Instance.controlTipLines[0]).font;
				GameObject val7 = new GameObject("TitleText");
				val7.transform.SetParent(val3.transform, false);
				_titleText = val7.AddComponent<TextMeshProUGUI>();
				((TMP_Text)_titleText).font = font;
				((TMP_Text)_titleText).fontSize = 38f;
				((Graphic)_titleText).color = new Color(0.9f, 0f, 0f, 1f);
				((TMP_Text)_titleText).alignment = (TextAlignmentOptions)514;
				((TMP_Text)_titleText).characterSpacing = 8f;
				((TMP_Text)_titleText).fontStyle = (FontStyles)1;
				((TMP_Text)_titleText).enableWordWrapping = true;
				GameObject val8 = new GameObject("BodyText");
				val8.transform.SetParent(val3.transform, false);
				_bodyText = val8.AddComponent<TextMeshProUGUI>();
				((TMP_Text)_bodyText).font = font;
				((TMP_Text)_bodyText).fontSize = 18f;
				((Graphic)_bodyText).color = new Color(0.8f, 0.8f, 0.8f, 0.9f);
				((TMP_Text)_bodyText).alignment = (TextAlignmentOptions)514;
				((TMP_Text)_bodyText).characterSpacing = 2f;
				((TMP_Text)_bodyText).lineSpacing = 10f;
				((TMP_Text)_bodyText).enableWordWrapping = true;
			}
		}

		private static void CreateSubtleLine(Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 sizeOffset)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Line");
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(0.8f, 0.1f, 0.1f, 0.3f);
			RectTransform rectTransform = ((Graphic)val2).rectTransform;
			rectTransform.anchorMin = anchorMin;
			rectTransform.anchorMax = anchorMax;
			rectTransform.sizeDelta = sizeOffset;
		}

		private static void CreateBorderLine(Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 sizeOffset)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("BorderLine");
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(1f, 0f, 0f, 0.6f);
			RectTransform rectTransform = ((Graphic)val2).rectTransform;
			rectTransform.anchorMin = anchorMin;
			rectTransform.anchorMax = anchorMax;
			rectTransform.sizeDelta = sizeOffset;
		}

		[IteratorStateMachine(typeof(<WarningAnimationSequence>d__8))]
		private static IEnumerator WarningAnimationSequence()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WarningAnimationSequence>d__8(0);
		}
	}
	public static class GMO_Animations
	{
		[CompilerGenerated]
		private sealed class <TerminalSequence>d__0 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GMO_UIElements ui;

			public EndOfGameStats stats;

			public Action<bool> onComplete;

			private float <totalScrapInLevel>5__1;

			private float <collectedScrapValue>5__2;

			private float <ratio>5__3;

			private int <collectedCount>5__4;

			private int <totalCount>5__5;

			private string <grade>5__6;

			private StringBuilder <sb>5__7;

			private TMP_FontAsset <font>5__8;

			private IEnumerator <>s__9;

			private Transform <child>5__10;

			private IEnumerator <>s__11;

			private Transform <child>5__12;

			private IEnumerator <>s__13;

			private Transform <child>5__14;

			private Dictionary<ulong, Plugin.PlayerData>.Enumerator <>s__15;

			private KeyValuePair<ulong, Plugin.PlayerData> <entry>5__16;

			private ulong <playerId>5__17;

			private Plugin.PlayerData <pData>5__18;

			private string <pName>5__19;

			private string <status>5__20;

			private bool <isDead>5__21;

			private List<string>.Enumerator <>s__22;

			private string <enemy>5__23;

			private List<string>.Enumerator <>s__24;

			private string <enemy>5__25;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <TerminalSequence>d__0(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 4:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 5:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				case -5:
				case 6:
					try
					{
					}
					finally
					{
						<>m__Finally3();
					}
					break;
				}
				<grade>5__6 = null;
				<sb>5__7 = null;
				<font>5__8 = null;
				<>s__9 = null;
				<child>5__10 = null;
				<>s__11 = null;
				<child>5__12 = null;
				<>s__13 = null;
				<child>5__14 = null;
				<>s__15 = default(Dictionary<ulong, Plugin.PlayerData>.Enumerator);
				<entry>5__16 = default(KeyValuePair<ulong, Plugin.PlayerData>);
				<pData>5__18 = null;
				<pName>5__19 = null;
				<status>5__20 = null;
				<>s__22 = default(List<string>.Enumerator);
				<enemy>5__23 = null;
				<>s__24 = default(List<string>.Enumerator);
				<enemy>5__25 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0554: Unknown result type (might be due to invalid IL or missing references)
				//IL_055e: Expected O, but got Unknown
				//IL_07f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0808: Unknown result type (might be due to invalid IL or missing references)
				//IL_0812: Expected O, but got Unknown
				//IL_08e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_08f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0903: Expected O, but got Unknown
				//IL_094a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0954: Expected O, but got Unknown
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Expected O, but got Unknown
				//IL_06fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0707: Expected O, but got Unknown
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Expected O, but got Unknown
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Expected O, but got Unknown
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						onComplete(obj: false);
						((TMP_Text)ui.GeneralStatsText).text = "";
						((TMP_Text)ui.TitleText).text = "ESTABLISHING CONNECTION...";
						<>s__9 = ui.PlayerListContent.GetEnumerator();
						try
						{
							while (<>s__9.MoveNext())
							{
								<child>5__10 = (Transform)<>s__9.Current;
								Object.Destroy((Object)(object)((Component)<child>5__10).gameObject);
								<child>5__10 = null;
							}
						}
						finally
						{
							if (<>s__9 is IDisposable disposable)
							{
								disposable.Dispose();
							}
						}
						<>s__9 = null;
						<>s__11 = ui.IndoorContent.GetEnumerator();
						try
						{
							while (<>s__11.MoveNext())
							{
								<child>5__12 = (Transform)<>s__11.Current;
								Object.Destroy((Object)(object)((Component)<child>5__12).gameObject);
								<child>5__12 = null;
							}
						}
						finally
						{
							if (<>s__11 is IDisposable disposable2)
							{
								disposable2.Dispose();
							}
						}
						<>s__11 = null;
						<>s__13 = ui.OutdoorContent.GetEnumerator();
						try
						{
							while (<>s__13.MoveNext())
							{
								<child>5__14 = (Transform)<>s__13.Current;
								Object.Destroy((Object)(object)((Component)<child>5__14).gameObject);
								<child>5__14 = null;
							}
						}
						finally
						{
							if (<>s__13 is IDisposable disposable3)
							{
								disposable3.Dispose();
							}
						}
						<>s__13 = null;
						((TMP_Text)ui.IndoorTitle).text = "INDOOR (0)";
						((TMP_Text)ui.OutdoorTitle).text = "OUTDOOR (0)";
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						if (Plugin.EnableGameCoreOverhaul.Value)
						{
							((TMP_Text)ui.TitleText).text = $"MISSION REPORT | {Plugin.ChosenMoonNames.Count + 1 - Plugin.VisitedMoonNames.Count} DAYS UNTIL DEADLINE";
						}
						else
						{
							((TMP_Text)ui.TitleText).text = $"MISSION REPORT | {Mathf.CeilToInt(TimeOfDay.Instance.timeUntilDeadline / TimeOfDay.Instance.totalTime)} DAYS UNTIL DEADLINE";
						}
						HUDManager.Instance.HideHUD(true);
						((Component)HUDManager.Instance.chatTextField).gameObject.SetActive(false);
						<totalScrapInLevel>5__1 = Plugin.totalScrapSurLune;
						<collectedScrapValue>5__2 = Plugin.collectedScrapSurLune;
						<ratio>5__3 = ((<totalScrapInLevel>5__1 > 0f) ? (<collectedScrapValue>5__2 / <totalScrapInLevel>5__1) : 0f);
						<collectedCount>5__4 = Plugin.collectedNB;
						<totalCount>5__5 = Plugin.allNB;
						<grade>5__6 = "D";
						if (<ratio>5__3 >= 0.95f)
						{
							<grade>5__6 = "S";
						}
						else if (<ratio>5__3 > 0.75f)
						{
							<grade>5__6 = "A";
						}
						else if (<ratio>5__3 > 0.5f)
						{
							<grade>5__6 = "B";
						}
						else if (<ratio>5__3 > 0.25f)
						{
							<grade>5__6 = "C";
						}
						<sb>5__7 = new StringBuilder();
						<sb>5__7.AppendLine("<color=#FF720D>SECTOR:</color> " + RoundManager.Instance.currentLevel.PlanetName);
						<sb>5__7.AppendLine($"<color=#FF720D>ITEMS RETRIEVED:</color> {<collectedCount>5__4} / {<totalCount>5__5}");
						<sb>5__7.AppendLine($"<color=#FF720D>SCRAP COLLECTED:</color> {<collectedScrapValue>5__2}$ / {<totalScrapInLevel>5__1}$");
						<sb>5__7.AppendLine($"<color=#FF720D>CREW EFFICIENCY:</color> {<ratio>5__3 * 100f:F0}%");
						<sb>5__7.AppendLine("");
						<sb>5__7.AppendLine("");
						<sb>5__7.AppendLine("<size=150%>GRADE: <color=#FFFFFF>[ " + <grade>5__6 + " ]</color></size>");
						<sb>5__7.AppendLine("");
						if (Plugin.TeamsPenalty > 0)
						{
							<sb>5__7.AppendLine($"<color=red>CASUALTY FINES:</color> -{Plugin.TeamsPenalty}$");
						}
						else
						{
							<sb>5__7.AppendLine("<color=green>CASUALTY FINES:</color> NONE");
						}
						<>2__current = Type(ui.GeneralStatsText, <sb>5__7.ToString());
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(0.3f);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						<font>5__8 = ((TMP_Text)HUDManager.Instance.weightCounter).font;
						<>s__15 = Plugin.PlayersRegistry.GetEnumerator();
						<>1__state = -3;
						goto IL_073f;
					case 4:
						<>1__state = -3;
						<pData>5__18 = null;
						<pName>5__19 = null;
						<status>5__20 = null;
						<entry>5__16 = default(KeyValuePair<ulong, Plugin.PlayerData>);
						goto IL_073f;
					case 5:
						<>1__state = -4;
						<enemy>5__23 = null;
						goto IL_0830;
					case 6:
						<>1__state = -5;
						<enemy>5__25 = null;
						goto IL_0921;
					case 7:
						{
							<>1__state = -1;
							ui.BtnObj.SetActive(true);
							onComplete(obj: true);
							return false;
						}
						IL_073f:
						if (<>s__15.MoveNext())
						{
							<entry>5__16 = <>s__15.Current;
							<playerId>5__17 = <entry>5__16.Key;
							<pData>5__18 = <entry>5__16.Value;
							<pName>5__19 = <pData>5__18.PlayerName;
							<status>5__20 = "ACTIVE";
							<isDead>5__21 = !<pData>5__18.IsAlive;
							if (<isDead>5__21)
							{
								<status>5__20 = "DECEASED (" + <pData>5__18.CauseOfDeath + ")";
							}
							else if (<pData>5__18.Health <= 20)
							{
								<status>5__20 = $"CRITICAL ({<pData>5__18.Health}HP)";
							}
							else if (<pData>5__18.Health <= 75)
							{
								<status>5__20 = $"INJURED ({<pData>5__18.Health}HP)";
							}
							else
							{
								<status>5__20 = $"STABLE ({<pData>5__18.Health}HP)";
							}
							ui.CreatePlayerRow(<pName>5__19, <status>5__20, <isDead>5__21, <font>5__8);
							<>2__current = (object)new WaitForSeconds(0.15f);
							<>1__state = 4;
							return true;
						}
						<>m__Finally1();
						<>s__15 = default(Dictionary<ulong, Plugin.PlayerData>.Enumerator);
						((TMP_Text)ui.IndoorTitle).text = $"INDOOR ({Plugin.IndoorEnemyNames.Count})";
						<>s__22 = Plugin.IndoorEnemyNames.GetEnumerator();
						<>1__state = -4;
						goto IL_0830;
						IL_0830:
						if (<>s__22.MoveNext())
						{
							<enemy>5__23 = <>s__22.Current;
							ui.CreateSimpleRow(ui.IndoorContent, "> " + <enemy>5__23.ToUpper(), new Color(1f, 0.6f, 0f), <font>5__8);
							<>2__current = (object)new WaitForSeconds(0.05f);
							<>1__state = 5;
							return true;
						}
						<>m__Finally2();
						<>s__22 = default(List<string>.Enumerator);
						((TMP_Text)ui.OutdoorTitle).text = $"OUTDOOR ({Plugin.OutdoorEnemyNames.Count})";
						<>s__24 = Plugin.OutdoorEnemyNames.GetEnumerator();
						<>1__state = -5;
						goto IL_0921;
						IL_0921:
						if (<>s__24.MoveNext())
						{
							<enemy>5__25 = <>s__24.Current;
							ui.CreateSimpleRow(ui.OutdoorContent, "> " + <enemy>5__25.ToUpper(), new Color(1f, 0.6f, 0f), <font>5__8);
							<>2__current = (object)new WaitForSeconds(0.05f);
							<>1__state = 6;
							return true;
						}
						<>m__Finally3();
						<>s__24 = default(List<string>.Enumerator);
						<>2__current = (object)new WaitForSeconds(3f);
						<>1__state = 7;
						return true;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__15).Dispose();
			}

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>s__22).Dispose();
			}

			private void <>m__Finally3()
			{
				<>1__state = -1;
				((IDisposable)<>s__24).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <Type>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public TextMeshProUGUI el;

			public string t;

			private int <total>5__1;

			private TMP_TextInfo <textInfo>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Type>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<textInfo>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (((TMP_Text)el).maxVisibleCharacters >= ((TMP_Text)el).textInfo.characterCount)
					{
						goto IL_00d8;
					}
				}
				else
				{
					<>1__state = -1;
					((TMP_Text)el).text = t;
					((TMP_Text)el).maxVisibleCharacters = 0;
					<total>5__1 = t.Length;
					<textInfo>5__2 = ((TMP_Text)el).textInfo;
				}
				if (((TMP_Text)el).maxVisibleCharacters < <total>5__1)
				{
					TextMeshProUGUI obj = el;
					int maxVisibleCharacters = ((TMP_Text)obj).maxVisibleCharacters;
					((TMP_Text)obj).maxVisibleCharacters = maxVisibleCharacters + 1;
					<>2__current = (object)new WaitForSeconds(0.01f);
					<>1__state = 1;
					return true;
				}
				goto IL_00d8;
				IL_00d8:
				((TMP_Text)el).maxVisibleCharacters = 99999;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[IteratorStateMachine(typeof(<TerminalSequence>d__0))]
		public static IEnumerator TerminalSequence(GMO_UIElements ui, EndOfGameStats stats, Action<bool> onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TerminalSequence>d__0(0)
			{
				ui = ui,
				stats = stats,
				onComplete = onComplete
			};
		}

		[IteratorStateMachine(typeof(<Type>d__1))]
		private static IEnumerator Type(TextMeshProUGUI el, string t)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Type>d__1(0)
			{
				el = el,
				t = t
			};
		}
	}
	public class GMO_UIElements
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__13_0;

			internal void <BuildUI>b__13_0()
			{
				GMO_UIManager.Instance.OnContinueClicked();
			}
		}

		public GameObject CanvasObj = null;

		public GameObject BtnObj = null;

		public TextMeshProUGUI TitleText = null;

		public TextMeshProUGUI GeneralStatsText = null;

		public Transform PlayerListContent = null;

		public Transform IndoorContent = null;

		public Transform OutdoorContent = null;

		public TextMeshProUGUI IndoorTitle = null;

		public TextMeshProUGUI OutdoorTitle = null;

		private Color _cBlack05 = new Color(0f, 0f, 0f, 0.5f);

		private Color _cOrange05 = new Color(1f, 0.45f, 0.05f, 0.5f);

		private Color _cOrangeFull = new Color(1f, 0.45f, 0.05f, 1f);

		private Color _cRed = new Color(0.8f, 0.1f, 0.1f, 1f);

		public void BuildUI(Transform parent)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_006c: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: 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_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Expected O, but got Unknown
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: 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_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Expected O, but got Unknown
			TMP_FontAsset font = ((TMP_Text)HUDManager.Instance.weightCounter).font;
			CanvasObj = new GameObject("GMO_MissionReport");
			Canvas val = CanvasObj.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 9999;
			CanvasObj.AddComponent<GraphicRaycaster>();
			CanvasScaler val2 = CanvasObj.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.matchWidthOrHeight = 0.5f;
			Image val3 = new GameObject("GlobalBackground").AddComponent<Image>();
			((Component)val3).transform.SetParent(CanvasObj.transform, false);
			((Graphic)val3).color = _cBlack05;
			((Graphic)val3).raycastTarget = true;
			Stretch(((Graphic)val3).rectTransform);
			GameObject val4 = new GameObject("TerminalFrame");
			val4.transform.SetParent(CanvasObj.transform, false);
			Image val5 = val4.AddComponent<Image>();
			((Graphic)val5).color = _cOrange05;
			((Graphic)val5).raycastTarget = false;
			RectTransform rectTransform = ((Graphic)val5).rectTransform;
			rectTransform.anchorMin = new Vector2(0.1f, 0.1f);
			rectTransform.anchorMax = new Vector2(0.9f, 0.9f);
			Vector2 val7 = (rectTransform.offsetMin = (rectTransform.offsetMax = Vector2.zero));
			TitleText = CreateTxt("Title", val4.transform, font, 50, new Vector2(0f, -50f));
			((TMP_Text)TitleText).rectTransform.anchorMin = new Vector2(0f, 1f);
			((TMP_Text)TitleText).rectTransform.anchorMax = new Vector2(1f, 1f);
			((TMP_Text)TitleText).rectTransform.pivot = new Vector2(0.5f, 1f);
			((TMP_Text)TitleText).text = "MISSION REPORT";
			((Graphic)TitleText).color = Color.white;
			((TMP_Text)TitleText).alignment = (TextAlignmentOptions)514;
			GeneralStatsText = CreateTxt("Stats", val4.transform, font, 26, new Vector2(40f, -120f));
			((TMP_Text)GeneralStatsText).rectTransform.anchorMin = new Vector2(0f, 1f);
			((TMP_Text)GeneralStatsText).rectTransform.anchorMax = new Vector2(0.6f, 1f);
			((TMP_Text)GeneralStatsText).rectTransform.pivot = new Vector2(0f, 1f);
			((TMP_Text)GeneralStatsText).alignment = (TextAlignmentOptions)257;
			((Graphic)GeneralStatsText).color = Color.white;
			((TMP_Text)GeneralStatsText).rectTransform.sizeDelta = new Vector2(0f, 250f);
			float num = 0.12f;
			float num2 = 0.45f;
			CreateColumn(val4.transform, "Crew", new Vector2(0.05f, num), new Vector2(0.33f, num2), "CREW STATUS", out PlayerListContent, out TextMeshProUGUI _);
			CreateColumn(val4.transform, "Indoor", new Vector2(0.35f, num), new Vector2(0.64f, num2), "INDOOR (0)", out IndoorContent, out IndoorTitle);
			CreateColumn(val4.transform, "Outdoor", new Vector2(0.66f, num), new Vector2(0.95f, num2), "OUTDOOR (0)", out OutdoorContent, out OutdoorTitle);
			BtnObj = new GameObject("ActionBtn");
			BtnObj.transform.SetParent(CanvasObj.transform, false);
			RectTransform val8 = BtnObj.AddComponent<RectTransform>();
			((Vector2)(ref val7))..ctor(0.5f, 0.15f);
			val8.anchorMax = val7;
			val8.anchorMin = val7;
			val8.sizeDelta = new Vector2(300f, 40f);
			Image val9 = BtnObj.AddComponent<Image>();
			((Graphic)val9).color = _cOrangeFull;
			((Graphic)val9).raycastTarget = true;
			ButtonClickedEvent onClick = BtnObj.AddComponent<Button>().onClick;
			object obj = <>c.<>9__13_0;
			if (obj == null)
			{
				UnityAction val10 = delegate
				{
					GMO_UIManager.Instance.OnContinueClicked();
				};
				<>c.<>9__13_0 = val10;
				obj = (object)val10;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			TextMeshProUGUI val11 = CreateTxt("Label", BtnObj.transform, font, 28, Vector2.zero);
			((TMP_Text)val11).text = "CONTINUE";
			((Graphic)val11).color = Color.black;
			((TMP_Text)val11).alignment = (TextAlignmentOptions)514;
			Stretch(((TMP_Text)val11).rectTransform);
			BtnObj.transform.SetAsLastSibling();
			CanvasObj.SetActive(false);
		}

		private void CreatePlayerScrollView(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			GameObject val = new GameObject("PlayerList_ScrollView");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0.05f, 0.1f);
			val2.anchorMax = new Vector2(0.95f, 0.5f);
			Vector2 offsetMin = (val2.offsetMax = Vector2.zero);
			val2.offsetMin = offsetMin;
			((Graphic)val.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.4f);
			ScrollRect val3 = val.AddComponent<ScrollRect>();
			val3.horizontal = false;
			val3.vertical = true;
			GameObject val4 = new GameObject("Viewport");
			val4.transform.SetParent(val.transform, false);
			Stretch(val4.AddComponent<RectTransform>());
			val4.AddComponent<Mask>().showMaskGraphic = false;
			((Graphic)val4.AddComponent<Image>()).color = Color.white;
			GameObject val5 = new GameObject("Content");
			val5.transform.SetParent(val4.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			val6.anchorMin = new Vector2(0f, 1f);
			val6.anchorMax = new Vector2(1f, 1f);
			val6.pivot = new Vector2(0.5f, 1f);
			val6.sizeDelta = new Vector2(0f, 100f);
			VerticalLayoutGroup val7 = val5.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val7).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val7).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val7).spacing = 5f;
			((LayoutGroup)val7).padding = new RectOffset(10, 10, 10, 10);
			val5.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			val3.content = val6;
			val3.viewport = val4.GetComponent<RectTransform>();
			PlayerListContent = (Transform)(object)val6;
		}

		public void CreatePlayerRow(string name, string status, bool isDead, TMP_FontAsset font)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0055: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("PlayerRow");
			val.transform.SetParent(PlayerListContent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			LayoutElement val3 = val.AddComponent<LayoutElement>();
			val3.minHeight = 30f;
			val3.flexibleWidth = 1f;
			TextMeshProUGUI val4 = CreateTxt("Name", val.transform, font, 20, Vector2.zero);
			((TMP_Text)val4).text = name;
			((TMP_Text)val4).alignment = (TextAlignmentOptions)513;
			((TMP_Text)val4).rectTransform.anchorMin = new Vector2(0f, 0f);
			((TMP_Text)val4).rectTransform.anchorMax = new Vector2(0.6f, 1f);
			((TMP_Text)val4).rectTransform.offsetMin = new Vector2(5f, 0f);
			((TMP_Text)val4).rectTransform.offsetMax = Vector2.zero;
			TextMeshProUGUI val5 = CreateTxt("Status", val.transform, font, 18, Vector2.zero);
			((TMP_Text)val5).text = status;
			((Graphic)val5).color = (isDead ? Color.red : Color.green);
			((TMP_Text)val5).alignment = (TextAlignmentOptions)516;
			((TMP_Text)val5).enableAutoSizing = true;
			((TMP_Text)val5).fontSizeMin = 10f;
			((TMP_Text)val5).fontSizeMax = 18f;
			((TMP_Text)val5).enableWordWrapping = false;
			((TMP_Text)val5).rectTransform.anchorMin = new Vector2(0.4f, 0f);
			((TMP_Text)val5).rectTransform.anchorMax = new Vector2(1f, 1f);
			((TMP_Text)val5).rectTransform.offsetMin = Vector2.zero;
			((TMP_Text)val5).rectTransform.offsetMax = new Vector2(-5f, 0f);
		}

		private void CreateColumn(Transform parent, string n, Vector2 min, Vector2 max, string title, out Transform content, out TextMeshProUGUI titleTxt)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Expected O, but got Unknown
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Expected O, but got Unknown
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Expected O, but got Unknown
			GameObject val = new GameObject(n + "_Scroll");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = min;
			val2.anchorMax = max;
			Vector2 offsetMin = (val2.offsetMax = Vector2.zero);
			val2.offsetMin = offsetMin;
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = new Color(0f, 0f, 0f, 0.6f);
			titleTxt = CreateTxt(n + "_Title", parent, ((TMP_Text)HUDManager.Instance.weightCounter).font, 18, Vector2.zero);
			((TMP_Text)titleTxt).rectTransform.anchorMin = new Vector2(min.x, max.y + 0.005f);
			((TMP_Text)titleTxt).rectTransform.anchorMax = new Vector2(max.x, max.y + 0.05f);
			RectTransform rectTransform = ((TMP_Text)titleTxt).rectTransform;
			offsetMin = (((TMP_Text)titleTxt).rectTransform.offsetMax = Vector2.zero);
			rectTransform.offsetMin = offsetMin;
			((TMP_Text)titleTxt).text = title.ToUpper();
			((Graphic)titleTxt).color = _cOrangeFull;
			((TMP_Text)titleTxt).alignment = (TextAlignmentOptions)514;
			((TMP_Text)titleTxt).fontStyle = (FontStyles)1;
			GameObject val4 = new GameObject("Viewport");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			Stretch(val5);
			val4.AddComponent<RectMask2D>();
			GameObject val6 = new GameObject("Content");
			val6.transform.SetParent(val4.transform, false);
			content = (Transform)(object)val6.AddComponent<RectTransform>();
			((RectTransform)content).anchorMin = new Vector2(0f, 1f);
			((RectTransform)content).anchorMax = new Vector2(1f, 1f);
			((RectTransform)content).pivot = new Vector2(0.5f, 1f);
			RectTransform val7 = (RectTransform)content;
			offsetMin = (((RectTransform)content).offsetMax = Vector2.zero);
			val7.offsetMin = offsetMin;
			VerticalLayoutGroup val8 = val6.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val8).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val8).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val8).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val8).childForceExpandHeight = false;
			((LayoutGroup)val8).padding = new RectOffset(5, 5, 5, 5);
			((HorizontalOrVerticalLayoutGroup)val8).spacing = 4f;
			val6.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			ScrollRect val9 = val.AddComponent<ScrollRect>();
			val9.content = (RectTransform)content;
			val9.viewport = val5;
			val9.horizontal = false;
			val9.vertical = true;
		}

		public void CreateSimpleRow(Transform container, string text, Color color, TMP_FontAsset font)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("EnemyRow");
			val.transform.SetParent(container, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			TextMeshProUGUI val3 = CreateTxt("Text", val.transform, font, 16, Vector2.zero);
			((TMP_Text)val3).text = text;
			((Graphic)val3).color = color;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)val3).rectTransform.anchorMin = Vector2.zero;
			((TMP_Text)val3).rectTransform.anchorMax = Vector2.one;
			((TMP_Text)val3).rectTransform.offsetMin = new Vector2(5f, 0f);
			((TMP_Text)val3).rectTransform.offsetMax = new Vector2(-5f, 0f);
			LayoutElement val4 = val.AddComponent<LayoutElement>();
			val4.minHeight = 22f;
			val4.preferredWidth = 800f;
		}

		private TextMeshProUGUI CreateTxt(string n, Transform p, TMP_FontAsset f, int s, Vector2 pos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(n);
			val.transform.SetParent(p, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).font = f;
			((TMP_Text)val2).fontSize = s;
			((Graphic)val2).raycastTarget = false;
			((TMP_Text)val2).rectTransform.anchoredPosition = pos;
			return val2;
		}

		private void Stretch(RectTransform r)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)r == (Object)null))
			{
				r.anchorMin = Vector2.zero;
				r.anchorMax = Vector2.one;
				r.offsetMin = Vector2.zero;
				r.offsetMax = Vector2.zero;
				((Transform)r).localScale = Vector3.one;
			}
		}
	}
	public class GMO_UIManager : MonoBehaviour
	{
		public static GMO_UIManager Instance;

		public GMO_UIElements Elements = null;

		private bool _isAnimating = false;

		public void Initialize()
		{
			Instance = this;
			Elements = new GMO_UIElements();
			Elements.BuildUI(((Component)this).transform);
		}

		public void ShowResults(EndOfGameStats stats)
		{
			((MonoBehaviour)this).StopAllCoroutines();
			Elements.CanvasObj.SetActive(true);
			Elements.BtnObj.SetActive(false);
			HUDManager.Instance.HideHUD(true);
			((Component)HUDManager.Instance.chatTextField).gameObject.SetActive(false);
			Plugin.IsCustomMenuOpen = true;
			SetPlayerInputs(enabled: false);
			((MonoBehaviour)this).StartCoroutine(GMO_Animations.TerminalSequence(Elements, stats, delegate(bool done)
			{
				_isAnimating = !done;
			}));
		}

		public void OnContinueClicked()
		{
			if (!_isAnimating)
			{
				Elements.CanvasObj.SetActive(false);
				SetPlayerInputs(enabled: true);
				Plugin.IsCustomMenuOpen = false;
				HUDManager.Instance.HideHUD(false);
				((Component)HUDManager.Instance.chatTextField).gameObject.SetActive(true);
			}
		}

		public void SetPlayerInputs(bool enabled)
		{
			Cursor.visible = !enabled;
			Cursor.lockState = (CursorLockMode)(enabled ? 1 : 0);
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)localPlayerController != (Object)null)
			{
				localPlayerController.disableLookInput = !enabled;
				localPlayerController.disableMoveInput = !enabled;
				localPlayerController.isFreeCamera = !enabled;
			}
		}

		private void Update()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			if (Elements != null && (Object)(object)Elements.CanvasObj != (Object)null && Elements.CanvasObj.activeSelf && (int)Cursor.lockState > 0)
			{
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	public class HUDRemoverPatches
	{
		[HarmonyPatch("DisplayGlobalNotification")]
		[HarmonyPrefix]
		private static bool BlockGlobalAlerts(string displayText)
		{
			if ((Object)(object)TimeOfDay.Instance != (Object)null && TimeOfDay.Instance.daysUntilDeadline <= 0 && !string.IsNullOrEmpty(displayText) && displayText.Contains("HALT"))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("DisplayDaysLeft")]
		[HarmonyPrefix]
		private static bool BlockDaysLeftAlert(int daysLeft)
		{
			return false;
		}
	}
	public enum LandingTimeType
	{
		Early,
		Normal,
		Late
	}
	public class MoonTimeData
	{
		public LandingTimeType Type;

		public float TargetHour;
	}
	public static class LandingTimeManager
	{
		[HarmonyPatch(typeof(TimeOfDay), "SyncTimeClientRpc")]
		public class LandingTimePatch
		{
			public static bool IsTimeAppliedForToday;

			[HarmonyPostfix]
			private static void Postfix(TimeOfDay __instance)
			{
				if (!((Object)(object)StartOfRound.Instance?.currentLevel == (Object)null) && !StartOfRound.Instance.inShipPhase && !IsTimeAppliedForToday && !(__instance.globalTime > 250f))
				{
					GenerateLandingTimes();
					string name = ((Object)StartOfRound.Instance.currentLevel).name;
					if (MoonLandingTimes.TryGetValue(name, out MoonTimeData value))
					{
						float num = value.TargetHour - 6f;
						float num2 = __instance.lengthOfHours * (float)__instance.numberOfHours;
						float globalTime = num / 18f * num2;
						__instance.globalTime = globalTime;
						IsTimeAppliedForToday = true;
					}
				}
			}
		}

		[HarmonyPatch(typeof(StartOfRound))]
		public class RoundResetPatch
		{
			[HarmonyPatch("ShipLeave")]
			[HarmonyPostfix]
			private static void ResetTimeFlagLeave()
			{
				LandingTimePatch.IsTimeAppliedForToday = false;
			}

			[HarmonyPatch("StartGame")]
			[HarmonyPostfix]
			private static void ResetTimeFlagStart()
			{
				LandingTimePatch.IsTimeAppliedForToday = false;
			}
		}

		public static Dictionary<string, MoonTimeData> MoonLandingTimes = new Dictionary<string, MoonTimeData>();

		public static void GenerateLandingTimes()
		{
			if (Plugin.ChosenMoonNames == null || Plugin.MoonSeeds == null || Plugin.MoonSeeds.Count == 0)
			{
				return;
			}
			MoonLandingTimes.Clear();
			for (int i = 0; i < Plugin.ChosenMoonNames.Count; i++)
			{
				string text = Plugin.ChosenMoonNames[i];
				int num = ((i < Plugin.MoonSeeds.Count) ? Plugin.MoonSeeds[i] : Plugin.MoonSeeds[0]);
				int count = Plugin.VisitedMoonNames.Count;
				int seed = num + count + text.GetHashCode();
				Random random = new Random(seed);
				random.Next();
				int num2 = random.Next(0, 3);
				LandingTimeType landingTimeType = (LandingTimeType)num2;
				float targetHour;
				switch (landingTimeType)
				{
				case LandingTimeType.Early:
					targetHour = (float)(6.2 + random.NextDouble() * 0.8);
					break;
				case LandingTimeType.Late:
					targetHour = (float)(9.0 + random.NextDouble() * 1.5);
					break;
				default:
					landingTimeType = LandingTimeType.Normal;
					targetHour = 7.85f;
					break;
				}
				MoonLandingTimes[text] = new MoonTimeData
				{
					Type = landingTimeType,
					TargetHour = targetHour
				};
			}
		}

		public static string FormatTimeToClock(float rawHours)
		{
			int num = Mathf.FloorToInt(rawHours);
			int num2 = Mathf.FloorToInt((rawHours - (float)num) * 60f);
			string arg = ((num >= 12) ? "PM" : "AM");
			int num3 = num % 12;
			if (num3 == 0)
			{
				num3 = 12;
			}
			return $"{num3}:{num2:D2} {arg}";
		}
	}
	[HarmonyPatch(typeof(StartMatchLever), "Start")]
	public class FixLeverInteractionPatch
	{
		[HarmonyPostfix]
		public static void Postfix(StartMatchLever __instance)
		{
			if ((Object)(object)__instance.triggerScript != (Object)null)
			{
				__instance.triggerScript.timeToHold = 2f;
				__instance.triggerScript.hoverTip = "Pull lever : [E]";
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "StartGame")]
	public class LaunchPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(StartOfRound __instance)
		{
			if (!NetworkManager.Singleton.IsServer)
			{
				return true;
			}
			List<string> list = Plugin.ChosenMoonNames.Where((string name) => !Plugin.VisitedMoonNames.Contains(name)).ToList();
			if (__instance.currentLevelID == 3)
			{
				Plugin.IsDiverting = true;
				return true;
			}
			if (list.Count <= 0)
			{
				int groupCredits = Object.FindObjectOfType<Terminal>().groupCredits;
				Plugin.IsDiverting = true;
				__instance.ChangeLevelServerRpc(3, groupCredits);
				Networking.Instance.HudAlertMsg.SendClients("Gordion");
				return false;
			}
			if (Plugin.ChosenMoonNames.Contains(((Object)__instance.currentLevel).name) && !Plugin.VisitedMoonNames.Contains(((Object)__instance.currentLevel).name))
			{
				Plugin.IsDiverting = true;
				return true;
			}
			if (list.Count > 0)
			{
				string randomName = list[Random.Range(0, list.Count)];
				SelectableLevel val = ((IEnumerable<SelectableLevel>)__instance.levels).FirstOrDefault((Func<SelectableLevel, bool>)((SelectableLevel l) => ((Object)l).name == randomName));
				int groupCredits2 = Object.FindObjectOfType<Terminal>().groupCredits;
				if ((Object)(object)val != (Object)null)
				{
					Plugin.IsDiverting = true;
					__instance.ChangeLevelServerRpc(val.levelID, groupCredits2);
				}
				if ((Object)(object)val != (Object)null)
				{
					Networking.Instance.HudAlertMsg.SendClients(val.PlanetName);
				}
				return false;
			}
			Plugin.IsDiverting = true;
			return true;
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	public class LevelUIPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void PostfixXP(HUDManager __instance)
		{
			if ((Object)(object)__instance.playerLevelMeter != (Object)null && ((Component)__instance.playerLevelMeter).gameObject.activeSelf)
			{
				((Component)__instance.playerLevelMeter).gameObject.SetActive(false);
				if ((Object)(object)__instance.playerLevelBoxAnimator != (Object)null)
				{
					((Component)__instance.playerLevelBoxAnimator).gameObject.SetActive(false);
				}
				if ((Object)(object)__instance.endgameStatsAnimator != (Object)null)
				{
					((Component)__instance.endgameStatsAnimator).gameObject.SetActive(false);
				}
			}
		}

		[HarmonyPatch(typeof(HUDManager), "Update")]
		[HarmonyPrefix]
		private static bool PlateformeHUDLock(HUDManager __instance)
		{
			if (Plugin.IsCustomMenuOpen)
			{
				HUDManager.Instance.HideHUD(true);
				((Component)HUDManager.Instance.chatTextField).gameObject.SetActive(false);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	public class MeteorShowerUIPatcher
	{
		[HarmonyPatch("MeteorShowerWarningHUD")]
		[HarmonyPrefix]
		public static bool ReplaceMeteorUI(HUDManager __instance)
		{
			EventHUDUtility.DisplayWarning("EMERGENCY WEATHER ALERT", "METEOR SHOWERS DETECTED.\nTAKE SHELTER IMMEDIATELY.\n\nYOUR AUTOPILOT SATELLITE ISSUED A WEATHER WARNING", __instance.meteorShowerWarningAudio);
			return false;
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "SaveGame")]
	public class OnDisconnectedPatch
	{
		[HarmonyPrefix]
		private static void Prefix()
		{
			Plugin.SaveData();
		}
	}
	[BepInPlugin("com.mrkixcat.companyprotocols", "Company Protocols", "0.2.4")]
	public class Plugin : BaseUnityPlugin
	{
		public class PlayerData
		{
			public string PlayerName = "";

			public bool IsAlive = true;

			public int Health = 100;

			public string CauseOfDeath = "";
		}

		public static Plugin Instance = null;

		public static ManualLogSource Log = null;

		private readonly Harmony harmony = new Harmony("com.mrkixcat.companyprotocols");

		public static ConfigEntry<string> ExcludedMoons = null;

		public static ConfigEntry<float> BaseMultiplier = null;

		public static ConfigEntry<float> MultiplierIncrement = null;

		public static ConfigEntry<bool> EnableGameCoreOverhaul = null;

		public static ConfigEntry<bool> EnableEndOfRoundStats = null;

		public static ConfigEntry<bool> EnableScrapScanner = null;

		public static ConfigEntry<bool> EnableBetterClock = null;

		public static ConfigEntry<bool> EnableVariableMoons = null;

		public static ConfigEntry<int> MinMoons = null;

		public static ConfigEntry<int> MaxMoons = null;

		public static ConfigEntry<bool> PreventLastQuotaMoons = null;

		public static float CurrentRunMultiplier = 1f;

		public static List<string> VisitedMoonNames = new List<string>();

		public static List<string> ChosenMoonNames = new List<string>();

		public static List<int> MoonSeeds = new List<int>();

		public static int collectedScrapSurLune = 0;

		public static int totalScrapSurLune = 0;

		public static int TeamsPenalty = 0;

		public static int collectedNB = 0;

		public static int allNB = 0;

		public static bool IsDiverting;

		public static List<string> IndoorEnemyNames = new List<string>();

		public static List<string> OutdoorEnemyNames = new List<string>();

		public static bool IsCustomMenuOpen = false;

		public static Dictionary<ulong, PlayerData> PlayersRegistry = new Dictionary<ulong, PlayerData>();

		public static List<string> LastQuotaMoonNames = new List<string>();

		public static void Init(ConfigFile config)
		{
			EnableGameCoreOverhaul = config.Bind<bool>("Server", "GameCoreOverhaul", false, "");
			EnableScrapScanner = config.Bind<bool>("Server", "ScrapNumberScanner", false, "");
			ExcludedMoons = config.Bind<string>("Server", "Excluded Moons", "Gordion,Liquidation,Paradon", "These moons will not be chosen.");
			BaseMultiplier = config.Bind<float>("Server", "Base Multiplier", 1f, "Base multiplier of the first quota.");
			MultiplierIncrement = config.Bind<float>("Server", "Multiplier Increment", 0.5f, "How much are increasing future quotas.");
			EnableVariableMoons = config.Bind<bool>("Server", "Enable Variable Moon Count", false, "If true, the number of moons chosen each quota will be random between Min and Max.");
			MinMoons = config.Bind<int>("Server", "Min Moons", 2, "Minimum number of moons to select (Min 1).");
			MaxMoons = config.Bind<int>("Server", "Max Moons", 4, "Maximum number of moons to select.");
			PreventLastQuotaMoons = config.Bind<bool>("Server", "Prevent Last Quota Moons", true, "If true, moons from the previous quota won't appear in the next one.");
			EnableEndOfRoundStats = config.Bind<bool>("Client", "EndOfRoundStats", false, "");
			EnableBetterClock = config.Bind<bool>("Client", "BetterClock", false, "");
		}

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Log = ((BaseUnityPlugin)this).Logger;
			try
			{
				Init(((BaseUnityPlugin)this).Config);
				CurrentRunMultiplier = BaseMultiplier.Value;
				if (EnableGameCoreOverhaul.Value)
				{
					harmony.PatchAll(typeof(ScrapTracker));
					harmony.PatchAll(typeof(QuotaPatch));
					harmony.PatchAll(typeof(WeatherSyncPatch));
					harmony.PatchAll(typeof(SaveLoadPatch));
					harmony.PatchAll(typeof(LaunchPatch));
					harmony.PatchAll(typeof(ReplacementCrewHandler));
					harmony.PatchAll(typeof(DeletePatch));
					harmony.PatchAll(typeof(TerminalDisplayPatch));
					harmony.PatchAll(typeof(OnDisconnectedPatch));
					harmony.PatchAll(typeof(HUDRemoverPatches));
					harmony.PatchAll(typeof(AutoLandingPatch));
					harmony.PatchAll(typeof(DisconnectPatch));
					harmony.PatchAll(typeof(EventHUDUtility));
					harmony.PatchAll(typeof(Networking));
					harmony.PatchAll(typeof(NetworkLifeCycle));
					harmony.PatchAll(typeof(MeteorShowerUIPatcher));
					harmony.PatchAll(typeof(EndRoundPatch));
					harmony.PatchAll(typeof(TerminalPricePatch));
					harmony.PatchAll(typeof(LandingTimeManager.LandingTimePatch));
					harmony.PatchAll(typeof(LandingTimeManager.RoundResetPatch));
					harmony.PatchAll(typeof(ForceDeadlineDisplayPatch));
					harmony.PatchAll(typeof(CustomBuyingRatePatch));
				}
				if (EnableEndOfRoundStats.Value)
				{
					harmony.PatchAll(typeof(ScrapTracker));
					harmony.PatchAll(typeof(EnemyCalculator));
					harmony.PatchAll(typeof(HUDRemoverPatches));
					harmony.PatchAll(typeof(GMO_UIManager));
					harmony.PatchAll(typeof(GMO_UIElements));
					harmony.PatchAll(typeof(GMO_Animations));
					harmony.PatchAll(typeof(DayEndPatch));
					harmony.PatchAll(typeof(ScrapScan));
					harmony.PatchAll(typeof(EndRoundStatsPatch));
					harmony.PatchAll(typeof(LevelUIPatch));
				}
				if (EnableScrapScanner.Value)
				{
					harmony.PatchAll(typeof(ScrapTracker));
					harmony.PatchAll(typeof(ScrapMessager));
				}
				if (EnableBetterClock.Value)
				{
					harmony.PatchAll(typeof(ClockPatch));
				}
				Networking.Init();
				Log.LogInfo((object)"Company Protocols loaded successfully");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Company Protocols can't load : " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		public static void SaveData()
		{
			try
			{
				string path = Path.Combine(Application.persistentDataPath, GameNetworkManager.Instance.currentSaveFileName + "_gmo.txt");
				string contents = string.Format("{0};{1};{2};{3};{4}", CurrentRunMultiplier, string.Join(",", MoonSeeds), string.Join(",", ChosenMoonNames), string.Join(",", VisitedMoonNames), TimeOfDay.Instance.profitQuota);
				File.WriteAllText(path, contents);
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[SAVE ERROR] : " + ex.Message));
			}
		}

		public static void LoadData()
		{
			try
			{
				string path = Path.Combine(Application.persistentDataPath, GameNetworkManager.Instance.currentSaveFileName + "_gmo.txt");
				if (!File.Exists(path))
				{
					CurrentRunMultiplier = BaseMultiplier.Value;
					if (NetworkManager.Singleton.IsServer)
					{
						GenerateInitialQuota();
					}
					return;
				}
				string text = File.ReadAllText(path);
				string[] array = text.Split(';');
				if (array.Length >= 1)
				{
					float.TryParse(array[0], out CurrentRunMultiplier);
				}
				if (array.Length >= 2)
				{
					MoonSeeds = (from s in array[1].Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
						select int.Parse(s)).ToList();
				}
				if (array.Length >= 3)
				{
					ChosenMoonNames = array[2].Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
				}
				if (array.Length >= 4)
				{
					VisitedMoonNames = array[3].Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
					int num = ChosenMoonNames.Count + 1 - VisitedMoonNames.Count;
					TimeOfDay.Instance.timeUntilDeadline = (float)num * TimeOfDay.Instance.totalTime;
					TimeOfDay.Instance.quotaVariables.deadlineDaysAmount = num;
					TimeOfDay.Instance.SyncTimeClientRpc(TimeOfDay.Instance.globalTime, (int)TimeOfDay.Instance.timeUntilDeadline);
					if ((Object)(object)StartOfRound.Instance.deadlineMonitorText != (Object)null)
					{
						((TMP_Text)StartOfRound.Instance.deadlineMonitorText).text = $"DEADLINE:\n {num} Days";
					}
				}
				if (array.Length >= 5 && int.TryParse(array[4], out var result))
				{
					TimeOfDay.Instance.profitQuota = result;
					if ((Object)(object)StartOfRound.Instance.profitQuotaMonitorText != (Object)null)
					{
						((TMP_Text)StartOfRound.Instance.profitQuotaMonitorText).text = $"PROFIT QUOTA:\n${TimeOfDay.Instance.quotaFulfilled}/{result}";
					}
					if ((Object)(object)HUDManager.Instance != (Object)null)
					{
						HUDManager.Instance.SetQuota(result, -1);
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[LOAD ERROR] : " + ex.Message));
			}
		}

		public static void GenerateInitialQuota()
		{
			if (NetworkManager.Singleton.IsServer)
			{
				TimeOfDay.Instance.SetNewProfitQuota();
			}
		}

		public static string GetTargetMoonsNames()
		{
			if (ChosenMoonNames == null || ChosenMoonNames.Count == 0)
			{
				return "None";
			}
			IEnumerable<string> enumerable = from l in StartOfRound.Instance.levels
				where (Object)(object)l != (Object)null && ChosenMoonNames.Contains(((Object)l).name)
				select l.PlanetName.Replace("\n", "");
			return enumerable.Any() ? string.Join(", ", enumerable) : "Unknown";
		}
	}
	[HarmonyPatch(typeof(TimeOfDay), "SetBuyingRateForDay")]
	public class CustomBuyingRatePatch
	{
		[HarmonyPrefix]
		public static bool Prefix(TimeOfDay __instance)
		{
			if (!NetworkManager.Singleton.IsServer)
			{
				return false;
			}
			int daysUntilDeadline = __instance.daysUntilDeadline;
			float num = 0.3f;
			switch (daysUntilDeadline)
			{
			case 1:
				num = 1f;
				if (Plugin.MoonSeeds != null && Plugin.MoonSeeds.Count > 0)
				{
					Random random = new Random(Plugin.MoonSeeds[0] + 42);
					if (random.Next(0, 1000) < 1)
					{
						num = 1.7f;
						Plugin.Log.LogInfo((object)"[GMO] JACKPOT ! Le protocole de rachat est passé à 170% !");
					}
				}
				break;
			case 2:
				num = 0.77f;
				break;
			case 3:
				num = 0.53f;
				break;
			default:
				num = 0.3f;
				break;
			}
			if ((Object)(object)StartOfRound.Instance != (Object)null)
			{
				StartOfRound.Instance.companyBuyingRate = num;
				StartOfRound.Instance.SyncCompanyBuyingRateClientRpc(num);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(TimeOfDay), "UpdateProfitQuotaCurrentTime")]
	public class ForceDeadlineDisplayPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(TimeOfDay __instance)
		{
			if (!NetworkManager.Singleton.IsServer)
			{
				return true;
			}
			int num = Plugin.ChosenMoonNames.Count + 1 - Plugin.VisitedMoonNames.Count;
			__instance.timeUntilDeadline = (float)num * __instance.totalTime;
			__instance.quotaVariables.deadlineDaysAmount = num;
			__instance.SyncTimeClientRpc(__instance.globalTime, (int)__instance.timeUntilDeadline);
			if ((Object)(object)StartOfRound.Instance.deadlineMonitorText != (Object)null)
			{
				((TMP_Text)StartOfRound.Instance.deadlineMonitorText).text = $"DEADLINE:\n {num} Days";
			}
			if ((Object)(object)StartOfRound.Instance.profitQuotaMonitorText != (Object)null)
			{
				((TMP_Text)StartOfRound.Instance.profitQuotaMonitorText).text = $"PROFIT QUOTA:\n${__instance.quotaFulfilled}/{__instance.profitQuota}";
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(TimeOfDay), "SetNewProfitQuota")]
	public class QuotaPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(TimeOfDay __instance)
		{
			Plugin.VisitedMoonNames.Clear();
			Plugin.ChosenMoonNames.Clear();
			if (!NetworkManager.Singleton.IsServer)
			{
				return false;
			}
			if (__instance.timesFulfilledQuota > 0)
			{
				Plugin.CurrentRunMultiplier += Plugin.MultiplierIncrement.Value;
			}
			else
			{
				Plugin.CurrentRunMultiplier = Plugin.BaseMultiplier.Value;
			}
			GenerateRandomMoons();
			float num = 0f;
			int num2 = 0;
			foreach (string name in Plugin.ChosenMoonNames)
			{
				SelectableLevel val = ((IEnumerable<SelectableLevel>)StartOfRound.Instance.levels).FirstOrDefault((Func<SelectableLevel, bool>)((SelectableLevel l) => ((Object)l).name == name));
				if ((Object)(object)val != (Object)null)
				{
					float num3 = 1f;
					if (val.PlanetName == "7 Dine")
					{
						num3 = 0.5f;
					}
					float num4 = TerminalDisplayPatch.CalculateMoonScrapAverage(val) * num3;
					num += num4;
					num2++;
				}
			}
			if (num2 > 0)
			{
				float num5 = num / 3f;
				float num6 = num5 * Plugin.CurrentRunMultiplier;
				__instance.profitQuota = Mathf.RoundToInt(num6);
			}
			__instance.quotaFulfilled = 0;
			int num7 = Plugin.ChosenMoonNames.Count - Plugin.VisitedMoonNames.Count;
			int num8 = Mathf.Max(num7, 1);
			__instance.timeUntilDeadline = (float)num8 * __instance.totalTime;
			__instance.quotaVariables.deadlineDaysAmount = num8;
			Plugin.MoonSeeds.Clear();
			for (int i = 0; i < Plugin.ChosenMoonNames.Count; i++)
			{
				Plugin.MoonSeeds.Add(Random.Range(1000, 999999));
			}
			Plugin.SaveData();
			if (NetworkManager.Singleton.IsServer)
			{
				Networking.Instance.ChosenMoonsVar.Value = Plugin.ChosenMoonNames.ToArray();
				Networking.Instance.VisitedMoonsVar.Value = Plugin.VisitedMoonNames.ToArray();
				Networking.Instance.MoonSeedsVar.Value = Plugin.MoonSeeds.ToArray();
			}
			__instance.SyncNewProfitQuotaClientRpc(__instance.profitQuota, 0, __instance.timesFulfilledQuota);
			return false;
		}

		public static void GenerateRandomMoons()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.levels == null)
			{
				return;
			}
			Random random = new Random(Guid.NewGuid().GetHashCode());
			if (Plugin.ChosenMoonNames.Count > 0)
			{
				Plugin.LastQuotaMoonNames = new List<string>(Plugin.ChosenMoonNames);
			}
			Networking.Instance.ChosenMoonsVar.Value = Array.Empty<string>();
			Networking.Instance.VisitedMoonsVar.Value = Array.Empty<string>();
			Networking.Instance.MoonSeedsVar.Value = Array.Empty<int>();
			Plugin.ChosenMoonNames.Clear();
			Plugin.VisitedMoonNames.Clear();
			Plugin.MoonSeeds.Clear();
			string[] excludedConfig = (from s in Plugin.ExcludedMoons.Value.Split(',')
				select s.Trim().ToLower()).ToArray();
			List<SelectableLevel> list = StartOfRound.Instance.levels.Where(delegate(SelectableLevel l)
			{
				if ((Object)(object)l == (Object)null || l.levelID == 3)
				{
					return false;
				}
				string lowName = l.PlanetName.ToLower();
				if (excludedConfig.Any((string ex) => lowName.Contains(ex)))
				{
					return false;
				}
				return (!Plugin.PreventLastQuotaMoons.Value || !Plugin.LastQuotaMoonNames.Contains(((Object)l).name)) ? true : false;
			}).ToList();
			if (list.Count < Plugin.MinMoons.Value)
			{
				list = StartOfRound.Instance.levels.Where((SelectableLevel l) => (Object)(object)l != (Object)null && l.levelID != 3 && !excludedConfig.Any((string ex) => l.PlanetName.ToLower().Contains(ex))).ToList();
			}
			int num = 3;
			if (Plugin.EnableVariableMoons.Value)
			{
				int num2 = Mathf.Clamp(Plugin.MinMoons.Value, 1, list.Count);
				int num3 = Mathf.Clamp(Plugin.MaxMoons.Value, num2, list.Count);
				num = random.Next(num2, num3 + 1);
			}
			else
			{
				num = Math.Min(3, list.Count);
			}
			for (int i = 0; i < num; i++)
			{
				if (list.Count == 0)
				{
					break;
				}
				int index = random.Next(list.Count);
				Plugin.ChosenMoonNames.Add(((Object)list[index]).name);
				list.RemoveAt(index);
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "LoadShipGrabbableItems")]
	public class SaveLoadPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (NetworkManager.Singleton.IsServer)
			{
				Plugin.LoadData();
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class ScrapMessager
	{
		[HarmonyPatch("OnShipLandedMiscEvents")]
		[HarmonyPostfix]
		private static void Postfix()
		{
			Plugin.IsDiverting = false;
			ScrapTracker.ScanMapForPotentialScrap();
			if (((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				ScrapTracker.SendChatMessage();
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class ScrapScan
	{
		[HarmonyPatch("OnShipLandedMiscEvents")]
		[HarmonyPostfix]
		private static void Postfix()
		{
			Plugin.IsDiverting = false;
			ScrapTracker.ScanMapForPotentialScrap();
		}
	}
	public class ScrapTracker
	{
		private static string[] excludedItems = new string[3] { "Knife", "Shotgun", "Key" };

		private static int interiorCount = 0;

		private static int exteriorCount = 0;

		private static HashSet<int> _trackedScrapIds = new HashSet<int>();

		public static void ScanMapForPotentialScrap()
		{
			ResetTracker();
			GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
			GrabbableObject[] array2 = array;
			foreach (GrabbableObject val in array2)
			{
				if (IsValidTargetScrap(val))
				{
					_trackedScrapIds.Add(((Object)val).GetInstanceID());
					Plugin.totalScrapSurLune += val.scrapValue;
					Plugin.allNB++;
					if (!val.itemProperties.itemName.Equals("Hive") && !val.itemProperties.itemName.Equals("Egg"))
					{
						interiorCount++;
					}
					else
					{
						exteriorCount++;
					}
				}
			}
		}

		public static void CalculateCollectedScrap()
		{
			Plugin.collectedScrapSurLune = 0;
			Plugin.collectedNB = 0;
			IEnumerable<GrabbableObject> enumerable = from obj in Object.FindObjectsOfType<GrabbableObject>()
				where IsInShip(obj)
				select obj;
			foreach (GrabbableObject item in enumerable)
			{
				if (_trackedScrapIds.Contains(((Object)item).GetInstanceID()))
				{
					Plugin.collectedScrapSurLune += item.scrapValue;
					Plugin.collectedNB++;
				}
			}
		}

		private static void ResetTracker()
		{
			Plugin.totalScrapSurLune = 0;
			Plugin.allNB = 0;
			Plugin.collectedScrapSurLune = 0;
			Plugin.collectedNB = 0;
			interiorCount = 0;
			exteriorCount = 0;
			_trackedScrapIds.Clear();
		}

		private static bool IsValidTargetScrap(GrabbableObject obj)
		{
			if ((Object)(object)obj == (Object)null || (Object)(object)obj.itemProperties == (Object)null)
			{
				return false;
			}
			return obj.scrapValue > 0 && !excludedItems.Contains(obj.itemProperties.itemName) && !IsInShip(obj);
		}

		public static bool IsInShip(GrabbableObject obj)
		{
			if ((Object)(object)obj == (Object)null)
			{
				return false;
			}
			return obj.isInShipRoom || obj.isInElevator;
		}

		public static void SendChatMessage()
		{
			HUDManager instance = HUDManager.Instance;
			PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)val == (Object)null) && !((Object)TimeOfDay.Instance.currentLevel).name.Equals("CompanyBuildingLevel"))
			{
				if (interiorCount > 0)
				{
					instance.AddTextToChatOnServer($"Indoor Scrap : {interiorCount}", -1);
				}
				if (exteriorCount > 0)
				{
					instance.AddTextToChatOnServer($"Outdoor Scrap : {exteriorCount}", -1);
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class WeatherSyncPatch
	{
		[CompilerGenerated]
		private sealed class <SetWeatherCoroutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public StartOfRound __instance;

			private float <timeout>5__1;

			private int <dayOffset>5__2;

			private int <i>5__3;

			private SelectableLevel <level>5__4;

			private int <baseSeed>5__5;

			private int <moonIndex>5__6;

			private int <finalWeatherSeed>5__7;

			private Random <moonWeatherRnd>5__8;

			private int <weatherIndex>5__9;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SetWeatherCoroutine>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<level>5__4 = null;
				<moonWeatherRnd>5__8 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected O, but got Unknown
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_021b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Unknown result type (might be due to invalid IL or missing references)
				//IL_020b: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<timeout>5__1 = 5f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((Plugin.MoonSeeds == null || Plugin.MoonSeeds.Count == 0) && <timeout>5__1 > 0f)
				{
					<timeout>5__1 -= 0.5f;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				}
				if (Plugin.MoonSeeds == null || Plugin.MoonSeeds.Count == 0)
				{
					return false;
				}
				<dayOffset>5__2 = Plugin.VisitedMoonNames.Count;
				<i>5__3 = 0;
				while (<i>5__3 < __instance.levels.Length)
				{
					<level>5__4 = __instance.levels[<i>5__3];
					if (<level>5__4.randomWeathers == null || <level>5__4.randomWeathers.Length == 0)
					{
						<level>5__4.currentWeather = (LevelWeatherType)(-1);
					}
					else
					{
						<moonIndex>5__6 = Plugin.ChosenMoonNames.IndexOf(((Object)<level>5__4).name);
						if (<moonIndex>5__6 != -1 && <moonIndex>5__6 < Plugin.MoonSeeds.Count)
						{
							<baseSeed>5__5 = Plugin.MoonSeeds[<moonIndex>5__6];
						}
						else
						{
							<baseSeed>5__5 = ((Object)<level>5__4).name.GetHashCode();
						}
						<finalWeatherSeed>5__7 = <baseSeed>5__5 + <dayOffset>5__2 + ((Object)<level>5__4).name.GetHashCode();
						<moonWeatherRnd>5__8 = new Random(<finalWeatherSeed>5__7);
						if (<moonWeatherRnd>5__8.Next(0, 100) < 60)
						{
							<weatherIndex>5__9 = <moonWeatherRnd>5__8.Next(0, <level>5__4.randomWeathers.Length);
							<level>5__4.currentWeather = <level>5__4.randomWeathers[<weatherIndex>5__9].weatherType;
						}
						else
						{
							<level>5__4.currentWeather = (LevelWeatherType)(-1);
						}
						<level>5__4 = null;
						<moonWeatherRnd>5__8 = null;
					}
					<i>5__3++;
				}
				Debug.Log((object)$"[GMO] Météo synchronisée pour le jour {<dayOffset>5__2} !");
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPatch("SetPlanetsWeather")]
		[HarmonyPrefix]
		private static bool Prefix(StartOfRound __instance)
		{
			((MonoBehaviour)__instance).StartCoroutine(SetWeatherCoroutine(__instance));
			return false;
		}

		[IteratorStateMachine(typeof(<SetWeatherCoroutine>d__1))]
		private static IEnumerator SetWeatherCoroutine(StartOfRound __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetWeatherCoroutine>d__1(0)
			{
				__instance = __instance
			};
		}
	}
}