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 LethalCompanyProtocols.NetcodePatcher;
using LethalNetworkAPI;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
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")]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
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()
	{
		if (!((NetworkBehaviour)StartOfRound.Instance).IsHost)
		{
			return;
		}
		Plugin.IndoorEnemyNames.Clear();
		Plugin.OutdoorEnemyNames.Clear();
		EnemyAI[] array = Object.FindObjectsOfType<EnemyAI>();
		EnemyAI[] array2 = array;
		foreach (EnemyAI val in array2)
		{
			if (!val.isEnemyDead)
			{
				((Component)StartOfRound.Instance).SendMessage(val.enemyType.enemyName);
				string enemyName = val.enemyType.enemyName;
				if (val.isOutside)
				{
					Plugin.OutdoorEnemyNames.Add(enemyName);
				}
				else
				{
					Plugin.IndoorEnemyNames.Add(enemyName);
				}
			}
		}
	}
}
namespace CompanyProtocols.Visuals
{
	[HarmonyPatch(typeof(RoundManager))]
	internal class LightingAndSunLCVisuals
	{
		[HarmonyPatch("FinishGeneratingLevel")]
		[HarmonyPostfix]
		private static void EnhanceLights()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.EnableVisualOverhaul.Value)
			{
				return;
			}
			Light[] array = Object.FindObjectsOfType<Light>();
			Light[] array2 = array;
			foreach (Light val in array2)
			{
				if ((int)val.type == 1)
				{
					HDAdditionalLightData component = ((Component)val).GetComponent<HDAdditionalLightData>();
					if ((Object)(object)component != (Object)null)
					{
						component.intensity = 150000f;
						component.EnableColorTemperature(true);
						component.SetColor(Color.white, 5500f);
						component.angularDiameter = 2.5f;
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	public class NightVisionOverrideClient
	{
		[HarmonyPatch("SetNightVisionEnabled")]
		[HarmonyPostfix]
		public static void Postfix(PlayerControllerB __instance)
		{
			if (Plugin.EnableVisualOverhaul.Value)
			{
				__instance.nightVision.intensity = 0f;
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	public class PlayerHUDOverhaul
	{
		[CompilerGenerated]
		private sealed class <LoadCustomAudio>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string fileName;

			public Action<AudioClip> callback;

			private string <path>5__1;

			private UnityWebRequest <www>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<path>5__1 = null;
				<www>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<path>5__1 = Path.Combine(Application.streamingAssetsPath, fileName);
						<www>5__2 = UnityWebRequestMultimedia.GetAudioClip(<path>5__1, (AudioType)20);
						<>1__state = -3;
						<>2__current = <www>5__2.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<www>5__2.result == 1)
						{
							callback?.Invoke(DownloadHandlerAudioClip.GetContent(<www>5__2));
						}
						<>m__Finally1();
						<www>5__2 = null;
						return false;
					}
				}
				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;
				if (<www>5__2 != null)
				{
					((IDisposable)<www>5__2).Dispose();
				}
			}

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

		private static GameObject visorOverlay;

		private static Image visorImage;

		private static float timeSinceLastDamage;

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void StartPostfix(HUDManager __instance)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_008e: 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)
			//IL_00b1: 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)
			if (Plugin.EnableHUDOverhaul.Value)
			{
				if ((Object)(object)visorOverlay == (Object)null && (Object)(object)__instance.HUDContainer != (Object)null)
				{
					visorOverlay = new GameObject("VisorHealthOverlay");
					visorOverlay.transform.SetParent(__instance.HUDContainer.transform, false);
					visorImage = visorOverlay.AddComponent<Image>();
					((Graphic)visorImage).color = new Color(0.8f, 0f, 0f, 0f);
					RectTransform component = visorOverlay.GetComponent<RectTransform>();
					component.anchorMin = Vector2.zero;
					component.anchorMax = Vector2.one;
					component.sizeDelta = Vector2.zero;
					visorOverlay.transform.SetAsFirstSibling();
				}
				HideHUDElement(__instance, "IngamePlayerHUD/TopLeftHolder/PlayerArrow");
				HideHUDElement(__instance, "IngamePlayerHUD/TopLeftHolder/Inventory");
			}
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void UpdatePostfix(HUDManager __instance)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.EnableHUDOverhaul.Value || (Object)(object)visorImage == (Object)null)
			{
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)localPlayerController != (Object)null)
			{
				float num = 1f - (float)localPlayerController.health / 100f;
				num = Mathf.Pow(num, 2f) * 0.35f;
				timeSinceLastDamage += Time.deltaTime;
				float num2 = 0f;
				if (localPlayerController.health < 30)
				{
					num2 = Mathf.Sin(Time.time * 3f) * 0.05f;
				}
				((Graphic)visorImage).color = new Color(0.6f, 0f, 0f, num + num2);
			}
		}

		private static void HideHUDElement(HUDManager hud, string path)
		{
			Transform val = hud.HUDContainer.transform.Find(path);
			if ((Object)(object)val != (Object)null)
			{
				CanvasGroup val2 = ((Component)val).GetComponent<CanvasGroup>() ?? ((Component)val).gameObject.AddComponent<CanvasGroup>();
				val2.alpha = 0f;
			}
		}

		[IteratorStateMachine(typeof(<LoadCustomAudio>d__6))]
		private static IEnumerator LoadCustomAudio(string fileName, Action<AudioClip> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadCustomAudio>d__6(0)
			{
				fileName = fileName,
				callback = callback
			};
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class RetroHorrorOverlayLCVisuals
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void ApplyHorrorOverlay()
		{
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.EnableVisualOverhaul.Value)
			{
				return;
			}
			Volume val = Object.FindObjectOfType<Volume>();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.profile == (Object)null))
			{
				VolumeProfile profile = val.profile;
				Bloom val2 = default(Bloom);
				if (!profile.TryGet<Bloom>(ref val2))
				{
					val2 = profile.Add<Bloom>(false);
				}
				((VolumeParameter<float>)(object)val2.intensity).value = 3.5f;
				((VolumeParameter<float>)(object)val2.scatter).value = 0.85f;
				((VolumeParameter<float>)(object)val2.dirtIntensity).value = 2f;
				FilmGrain val3 = default(FilmGrain);
				if (!profile.TryGet<FilmGrain>(ref val3))
				{
					val3 = profile.Add<FilmGrain>(false);
				}
				((VolumeParameter<float>)(object)val3.intensity).value = 1f;
				((VolumeParameter<float>)(object)val3.response).value = 0.8f;
				Vignette val4 = default(Vignette);
				if (!profile.TryGet<Vignette>(ref val4))
				{
					val4 = profile.Add<Vignette>(false);
				}
				((VolumeParameter<float>)(object)val4.intensity).value = 0.45f;
				((VolumeParameter<float>)(object)val4.smoothness).value = 1f;
				((VolumeParameter<Color>)(object)val4.color).value = Color.black;
				((VolumeParameter)val4.intensity).overrideState = true;
				ChromaticAberration val5 = default(ChromaticAberration);
				if (profile.TryGet<ChromaticAberration>(ref val5))
				{
					((VolumeParameter<float>)(object)val5.intensity).value = 0.25f;
				}
				LensDistortion val6 = default(LensDistortion);
				if (!profile.TryGet<LensDistortion>(ref val6))
				{
					val6 = profile.Add<LensDistortion>(false);
				}
				((VolumeParameter<float>)(object)val6.intensity).value = -0.15f;
				((VolumeParameter)val6.intensity).overrideState = true;
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class TrueDarknessLCVisuals
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void ApplyTrueDarkness()
		{
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.EnableVisualOverhaul.Value)
			{
				return;
			}
			Volume val = Object.FindObjectOfType<Volume>();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.profile == (Object)null))
			{
				VolumeProfile profile = val.profile;
				IndirectLightingController val2 = default(IndirectLightingController);
				if (!profile.TryGet<IndirectLightingController>(ref val2))
				{
					val2 = profile.Add<IndirectLightingController>(false);
				}
				((VolumeParameter<float>)(object)val2.indirectDiffuseLightingMultiplier).value = 0f;
				((VolumeParameter)val2.indirectDiffuseLightingMultiplier).overrideState = true;
				ColorAdjustments val3 = default(ColorAdjustments);
				if (profile.TryGet<ColorAdjustments>(ref val3))
				{
					((VolumeParameter<float>)(object)val3.contrast).value = 45f;
					((VolumeParameter<float>)(object)val3.postExposure).value = -1.2f;
				}
				WhiteBalance val4 = default(WhiteBalance);
				if (!profile.TryGet<WhiteBalance>(ref val4))
				{
					val4 = profile.Add<WhiteBalance>(false);
				}
				((VolumeParameter<float>)(object)val4.temperature).value = -25f;
				((VolumeParameter<float>)(object)val4.tint).value = -10f;
				((VolumeParameter)val4.temperature).overrideState = true;
				Fog val5 = default(Fog);
				if (!profile.TryGet<Fog>(ref val5))
				{
					val5 = profile.Add<Fog>(false);
				}
				((VolumeParameter<bool>)(object)val5.enabled).value = true;
				((VolumeParameter<bool>)(object)val5.enableVolumetricFog).value = true;
				((VolumeParameter<float>)(object)val5.meanFreePath).value = 15f;
				((VolumeParameter<float>)(object)val5.baseHeight).value = -10f;
				((VolumeParameter<float>)(object)val5.maximumHeight).value = 50f;
				((VolumeParameter<Color>)(object)val5.tint).value = new Color(0.05f, 0.05f, 0.05f);
			}
		}
	}
}
namespace CompanyProtocols.TerminalPatches
{
	[HarmonyPatch(typeof(Terminal), "TextPostProcess")]
	public class TerminalDisplayPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Terminal __instance, ref string __result)
		{
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Invalid comparison between Unknown and I4
			//IL_0200: 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 arg2 = ((value.Type == LandingTimeType.Early) ? "#00FFFF" : ((value.Type != LandingTimeType.Late) ? "#FFFFFF" : "#FFA500"));
						arg = $"<color={arg2}>{value.TargetHour:F1}h</color>";
					}
					stringBuilder.AppendLine("> <b>" + item.PlanetName.ToUpper() + "</b>");
					string arg3 = (((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={arg3}>{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 PlayerStatus
	{
		public string PlayerName = null;

		public bool IsAlive;

		public int Health;

		public string CauseOfDeath = null;
	}
	[Serializable]
	public class EndGameStatsData
	{
		public int TotalScrap;

		public int CollectedScrap;

		public int Penalty;

		public int CollectedCount;

		public int TotalCount;

		public List<PlayerStatusData> PlayerRegistry = new List<PlayerStatusData>();

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

		public List<string> OutdoorEnemyNames = new List<string>();
	}
	[Serializable]
	public class PlayerStatusData
	{
		public ulong ClientId;

		public string PlayerName = null;

		public bool IsAlive;

		public int Health;

		public string CauseOfDeath = null;
	}
	public class Networking
	{
		public LNetworkVariable<string[]> ChosenMoonsVar;

		public LNetworkVariable<string[]> VisitedMoonsVar;

		public LNetworkVariable<int[]> MoonSeedsVar;

		public LNetworkMessage<string> HudAlertMsg;

		public LNetworkMessage<EndGameStatsData> EndGameStatsMsg;

		public LNetworkMessage<int> RequestSyncMsg;

		public LNetworkMessage<int> PayQuotaRequestMsg;

		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 = 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 = 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 = newVal.ToList();
					}
				});
				PayQuotaRequestMsg = LNetworkMessage<int>.Connect("GMO_PayQuotaRequest", (Action<int, ulong>)null, (Action<int>)null, (Action<int, ulong>)null);
				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);
				EndGameStatsMsg = LNetworkMessage<EndGameStatsData>.Connect("GMO_EndGame", (Action<EndGameStatsData, ulong>)null, (Action<EndGameStatsData>)null, (Action<EndGameStatsData, 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.");
					}
				};
				EndGameStatsMsg.OnClientReceived += delegate(EndGameStatsData data)
				{
					Plugin.Log.LogInfo((object)"[GMO NetMsg] Received EndGameStats data.");
					Plugin.totalScrapSurLune = data.TotalScrap;
					Plugin.collectedScrapSurLune = data.CollectedScrap;
					Plugin.TeamsPenalty = data.Penalty;
					Plugin.collectedNB = data.CollectedCount;
					Plugin.allNB = data.TotalCount;
					Plugin.IndoorEnemyNames = data.IndoorEnemyNames;
					Plugin.OutdoorEnemyNames = data.OutdoorEnemyNames;
					Plugin.PlayersRegistry.Clear();
					foreach (PlayerStatusData item in data.PlayerRegistry)
					{
						Plugin.PlayersRegistry[item.ClientId] = new PlayerStatus
						{
							PlayerName = item.PlayerName,
							IsAlive = item.IsAlive,
							Health = item.Health,
							CauseOfDeath = item.CauseOfDeath
						};
					}
				};
				PayQuotaRequestMsg.OnServerReceived += delegate(int amount, ulong clientId)
				{
					Plugin.Log.LogInfo((object)$"[GMO NetMsg] Server received payment request ({amount}) from: {clientId}");
					Terminal val2 = Object.FindObjectOfType<Terminal>();
					if ((Object)(object)val2 != (Object)null && val2.groupCredits >= amount)
					{
						int num = val2.groupCredits - amount;
						val2.SyncGroupCreditsServerRpc(num, val2.numberOfItemsInDropship);
						TimeOfDay instance = TimeOfDay.Instance;
						instance.quotaFulfilled += amount;
						TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
						SyncQuotaMsg.SendClients(TimeOfDay.Instance.quotaFulfilled);
					}
				};
				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);
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	public class NetworkModOptimizer
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OptimizeNetworkSettings()
		{
			if ((Object)(object)NetworkManager.Singleton != (Object)null)
			{
				NetworkManager.Singleton.NetworkConfig.TickRate = 100u;
				Debug.Log((object)"[GMO] Network TickRate optimisé à 100.");
			}
		}
	}
}
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 && num3 != lastCheckedHour && num3 % 2 == 0)
			{
				lastCheckedHour = num3;
				if (Random.value < 0.05f)
				{
					Debug.Log((object)$"[GMO] Event triggered at {num2:F2}h (Arrival was at {num:F2}h)");
					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 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()
		{
			if (!NetworkManager.Singleton.IsServer || StartOfRound.Instance.currentLevelID == 3)
			{
				return;
			}
			Networking.Instance.MoonSeedsVar.Value = (from _ in Enumerable.Range(0, Plugin.ChosenMoonNames.Count)
				select Random.Range(1000, 999999)).ToArray();
			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 PlayerStatus
				{
					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;
			EndGameStatsData endGameStatsData = new EndGameStatsData
			{
				TotalScrap = Plugin.totalScrapSurLune,
				CollectedScrap = Plugin.collectedScrapSurLune,
				Penalty = Plugin.TeamsPenalty,
				CollectedCount = Plugin.collectedNB,
				TotalCount = Plugin.allNB,
				PlayerRegistry = new List<PlayerStatusData>(),
				IndoorEnemyNames = Plugin.IndoorEnemyNames,
				OutdoorEnemyNames = Plugin.OutdoorEnemyNames
			};
			foreach (KeyValuePair<ulong, PlayerStatus> item in Plugin.PlayersRegistry)
			{
				endGameStatsData.PlayerRegistry.Add(new PlayerStatusData
				{
					ClientId = item.Key,
					PlayerName = item.Value.PlayerName,
					IsAlive = item.Value.IsAlive,
					Health = item.Value.Health,
					CauseOfDeath = item.Value.CauseOfDeath
				});
			}
			Networking.Instance.EndGameStatsMsg.SendClients(endGameStatsData);
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	internal class DeathPenaltyPatch
	{
		[HarmonyPatch("ApplyPenalty")]
		[HarmonyPrefix]
		private static bool CancelPenaltyAtCompany()
		{
			if ((Object)(object)StartOfRound.Instance != (Object)null && (Object)(object)StartOfRound.Instance.currentLevel != (Object)null && !StartOfRound.Instance.currentLevel.planetHasTime)
			{
				return false;
			}
			return true;
		}
	}
	[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");
			string path2 = Path.Combine(Application.persistentDataPath, text2 + "_paradon_gmo.txt");
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
				if (File.Exists(path2))
				{
					File.Delete(path2);
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[GMO] Error deleting custom save files: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(DepositItemsDesk))]
	public class DepositItemsDeskPatch
	{
		[HarmonyPatch("SellAndDisplayItemProfits")]
		[HarmonyPostfix]
		public static void PreventQuotaFill(int profit)
		{
			TimeOfDay instance = TimeOfDay.Instance;
			instance.quotaFulfilled -= profit;
			TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
		}
	}
	[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();
		}
	}
	[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)
			{
				Plugin.VisitedMoonNames.Add(((Object)StartOfRound.Instance.currentLevel).name);
				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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: 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.45f);
				rectTransform.anchorMax = new Vector2(1f, 0.55f);
				rectTransform.sizeDelta = Vector2.zero;
				TMP_FontAsset font = ((TMP_Text)HUDManager.Instance.controlTipLines[0]).font;
				GameObject val5 = new GameObject("TitleText");
				val5.transform.SetParent(val3.transform, false);
				_titleText = val5.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 = false;
				GameObject val6 = new GameObject("BodyText");
				val6.transform.SetParent(val3.transform, false);
				_bodyText = val6.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 = false;
				RectTransform rectTransform2 = ((TMP_Text)_titleText).rectTransform;
				rectTransform2.anchoredPosition = new Vector2(0f, 15f);
				RectTransform rectTransform3 = ((TMP_Text)_bodyText).rectTransform;
				rectTransform3.anchoredPosition = new Vector2(0f, -25f);
			}
		}

		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, PlayerStatus>.Enumerator <>s__15;

			private KeyValuePair<ulong, PlayerStatus> <entry>5__16;

			private ulong <playerId>5__17;

			private PlayerStatus <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, PlayerStatus>.Enumerator);
				<entry>5__16 = default(KeyValuePair<ulong, PlayerStatus>);
				<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_04fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0507: Expected O, but got Unknown
				//IL_079a: Unknown result type (might be due to invalid IL or missing references)
				//IL_07b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_07bb: Expected O, but got Unknown
				//IL_088b: Unknown result type (might be due to invalid IL or missing references)
				//IL_08a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_08ac: Expected O, but got Unknown
				//IL_08f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_08fd: 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_06a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_06b0: 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;
						((TMP_Text)ui.TitleText).text = $"MISSION REPORT | {TimeOfDay.Instance.daysUntilDeadline - 1} 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_06e8;
					case 4:
						<>1__state = -3;
						<pData>5__18 = null;
						<pName>5__19 = null;
						<status>5__20 = null;
						<entry>5__16 = default(KeyValuePair<ulong, PlayerStatus>);
						goto IL_06e8;
					case 5:
						<>1__state = -4;
						<enemy>5__23 = null;
						goto IL_07d9;
					case 6:
						<>1__state = -5;
						<enemy>5__25 = null;
						goto IL_08ca;
					case 7:
						{
							<>1__state = -1;
							ui.BtnObj.SetActive(true);
							onComplete(obj: true);
							return false;
						}
						IL_06e8:
						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, PlayerStatus>.Enumerator);
						((TMP_Text)ui.IndoorTitle).text = $"INDOOR ({Plugin.IndoorEnemyNames.Count})";
						<>s__22 = Plugin.IndoorEnemyNames.GetEnumerator();
						<>1__state = -4;
						goto IL_07d9;
						IL_07d9:
						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_08ca;
						IL_08ca:
						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 (migh