using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FacilityMeltdown.API;
using FacilityMeltdown.MeltdownSequence.Behaviours;
using GeneralImprovements.Utilities;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using OpenMonitors.Monitors;
using ShipMeltdown.Patches;
using ShipMeltdown.Utils;
using ShipMeltdown.Utils.Monitors;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ShipMeltdown")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+2613f7fec103a7e7734090fcbd108ef5b1c3c208")]
[assembly: AssemblyProduct("ShipMeltdown")]
[assembly: AssemblyTitle("ShipMeltdown")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ShipMeltdown
{
	public class Config
	{
		internal static Config? Instance;

		internal ConfigEntry<Key> toggleEmergencyLights;

		internal ConfigEntry<bool> shipDoorMalfunction;

		public Key getToggleEmergencyLights => toggleEmergencyLights.Value;

		public bool getShipDoorMalfunction => shipDoorMalfunction.Value;

		public Config(ConfigFile file)
		{
			Instance = this;
			toggleEmergencyLights = file.Bind<Key>("Main", "Toggle Emergency Lights", (Key)99, (ConfigDescription)null);
			shipDoorMalfunction = file.Bind<bool>("Main", "Ship Doors Malfunction", true, (ConfigDescription)null);
		}
	}
	[BepInPlugin("catragryff.ShipMeltdown", "ShipMeltdown", "1.7.50")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class ShipMeltdown : BaseUnityPlugin
	{
		internal const string modGUID = "catragryff.ShipMeltdown";

		internal const string modName = "ShipMeltdown";

		internal const string modVersion = "1.7.50";

		internal readonly Harmony harmony = new Harmony("catragryff.ShipMeltdown");

		internal static ShipMeltdown instance;

		private static bool openMonitorSupport;

		private static bool generalImprovementsSupport;

		internal static ManualLogSource mls = Logger.CreateLogSource("ShipMeltdown");

		public static Config ShipMeltdownConfig { get; private set; }

		public void Awake()
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
			}
			mls.LogInfo((object)"ShipMeltdown loading...");
			ShipMeltdownConfig = new Config(((BaseUnityPlugin)this).Config);
			openMonitorSupport = Chainloader.PluginInfos.Keys.Contains("xxxstoner420bongmasterxxx.open_monitors");
			generalImprovementsSupport = Chainloader.PluginInfos.Keys.Contains("ShaosilGaming.GeneralImprovements");
			if (Chainloader.PluginInfos.Keys.Contains("PizzaProbability"))
			{
				mls.LogError((object)"PizzaProbability detected ! This mod is incompatible with ShipMeltdown. Trying to remove PizzaProbability patches to avoid breaking the game...");
				Harmony.UnpatchID("PizzaProbability");
			}
			harmony.PatchAll(typeof(StartOfRoundPatch1));
			if ((int)ShipMeltdownConfig.getToggleEmergencyLights != 0)
			{
				harmony.PatchAll(typeof(StartOfRoundPatch2));
			}
			harmony.PatchAll(typeof(MeltdownHandlerPatch));
			if (generalImprovementsSupport)
			{
				mls.LogInfo((object)"Adding GeneralImprovements support");
				MonitorCompatibilityHandler.AddMonitorCompatibilityHandler(new GeneralImprovements());
			}
			if (openMonitorSupport)
			{
				mls.LogInfo((object)"Adding OpenMonitor support");
				MonitorCompatibilityHandler.AddMonitorCompatibilityHandler(new OpenMonitor());
			}
			if (!openMonitorSupport && !generalImprovementsSupport)
			{
				mls.LogInfo((object)"No monitor support were added. Adding the default one");
				MonitorCompatibilityHandler.AddMonitorCompatibilityHandler(new DefaultMonitor(), removeDefaultHandler: false);
			}
			StartOfRoundPatch1.failure = (DialogueSegment[])(object)new DialogueSegment[1];
			StartOfRoundPatch1.failure[0] = new DialogueSegment
			{
				waitTime = 6f,
				bodyText = "Ship engines not detected. The company warned you not to play with radiations"
			};
			MeltdownAPI.RegisterMeltdownListener((Action)ShipPanic.OnMeltdownStarted);
			mls.LogInfo((object)"ShipMeltdown loaded");
		}
	}
	internal static class ShipPanic
	{
		internal static float delta;

		internal static bool repeat = true;

		internal static float delta2;

		internal static HangarShipDoor h;

		internal static Queue<(Light, Color)> colors;

		internal static Queue<(Light, bool)> toggleGroup;

		private static HashSet<Light> affected;

		internal static bool canTakeOff = true;

		internal static float meltdownTimer;

		internal static ControlledTask KillSystems;

		internal static ControlledTask BreakLever;

		internal static ControlledTask takeOff;

		internal static bool OnlyLights;

		public static bool CanTakeOff => canTakeOff;

		public static void OnMeltdownStarted()
		{
			if (KillSystems == null)
			{
				KillSystems = new ControlledTask(MostSystemsDead, shouldBeDoneOnlyOnce: true);
			}
			if (BreakLever == null)
			{
				BreakLever = new ControlledTask(ShipCantTakeOff, shouldBeDoneOnlyOnce: true);
			}
			if (takeOff == null)
			{
				takeOff = new ControlledTask(delegate
				{
					canTakeOff = true;
					StartOfRound.Instance.shipHasLanded = false;
					StartOfRound.Instance.shipIsLeaving = true;
					StartOfRound.Instance.shipAnimator.ResetTrigger("ShipLeave");
					StartOfRound.Instance.shipAnimator.SetTrigger("ShipLeave");
				}, shouldBeDoneOnlyOnce: true);
			}
			meltdownTimer = 120f;
			delta = 0f;
			delta2 = 0f;
			LightAlarm();
		}

		private static void ShipCantTakeOff()
		{
			canTakeOff = false;
			Object.FindObjectOfType<StartMatchLever>().triggerScript.interactable = false;
		}

		internal static void LightAlarm(int emergencyType = 0)
		{
			//IL_004c: 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_0053: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			if (colors == null)
			{
				colors = new Queue<(Light, Color)>();
			}
			if (toggleGroup == null)
			{
				toggleGroup = new Queue<(Light, bool)>();
			}
			if (affected == null)
			{
				affected = new HashSet<Light>();
			}
			while (colors.Count > 0)
			{
				var (val, color) = colors.Dequeue();
				val.color = color;
			}
			foreach (var (val2, enabled) in toggleGroup)
			{
				((Behaviour)val2).enabled = enabled;
			}
			toggleGroup.Clear();
			if (emergencyType == -1)
			{
				OnlyLights = false;
				return;
			}
			Light[] componentsInChildren = ((Component)instance.shipRoomLights).GetComponentsInChildren<Light>();
			Light[] componentsInChildren2 = ((Component)instance.shipAnimator).GetComponentsInChildren<Light>();
			foreach (Light val3 in componentsInChildren2)
			{
				if (affected.Add(val3))
				{
					colors.Enqueue((val3, val3.color));
					val3.color = Color.red;
					if (!componentsInChildren.Contains(val3))
					{
						toggleGroup.Enqueue((val3, ((Behaviour)val3).enabled));
					}
				}
			}
			if (emergencyType == 1)
			{
				OnlyLights = true;
			}
			if (emergencyType == 0)
			{
				h = Object.FindObjectOfType<HangarShipDoor>();
				h.SetDoorButtonsEnabled(false);
			}
		}

		internal static void ToggleLightsOnly()
		{
			foreach (var (val, flag) in toggleGroup)
			{
				((Behaviour)val).enabled = flag && !((Behaviour)val).enabled;
			}
			StartOfRound.Instance.shipRoomLights.ToggleShipLights();
		}

		internal static void TryWithoutNullPo(Action action)
		{
			try
			{
				action();
			}
			catch (NullReferenceException)
			{
			}
		}

		private static void MostSystemsDead()
		{
			h.hydraulicsDisplay.SetActive(false);
			MonitorCompatibilityHandler.MostSystemsDead();
		}

		internal static void ReviveSystems()
		{
			//IL_0054: 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)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			h.hydraulicsDisplay.SetActive(true);
			KillSystems.Reset();
			BreakLever.Reset();
			MonitorCompatibilityHandler.MaintainScreenOffReset();
			takeOff.Reset();
			canTakeOff = true;
			foreach (var (val, color) in colors)
			{
				val.color = color;
			}
			colors.Clear();
			foreach (var (val2, enabled) in toggleGroup)
			{
				((Behaviour)val2).enabled = enabled;
			}
			toggleGroup.Clear();
			affected.Clear();
			MonitorCompatibilityHandler.ReviveSystems();
			if (repeat)
			{
				h.shipDoorsAnimator.SetBool("Closed", true);
			}
		}
	}
}
namespace ShipMeltdown.Utils
{
	public class ControlledTask
	{
		private Action action;

		private bool hasBeenPerformed;

		private readonly bool shouldBeDoneOnlyOnce;

		public ControlledTask(Action action, bool shouldBeDoneOnlyOnce)
		{
			this.action = action;
			this.shouldBeDoneOnlyOnce = shouldBeDoneOnlyOnce;
			base..ctor();
		}

		public void Reset()
		{
			hasBeenPerformed = false;
		}

		public void Run()
		{
			if ((shouldBeDoneOnlyOnce && !hasBeenPerformed) || !shouldBeDoneOnlyOnce)
			{
				action();
				hasBeenPerformed = true;
			}
		}
	}
	public static class MonitorCompatibilityHandler
	{
		private static Queue<MonitorCompatibility> handlers = new Queue<MonitorCompatibility>();

		public static void AddMonitorCompatibilityHandler(MonitorCompatibility mc, bool removeDefaultHandler = true)
		{
			foreach (MonitorCompatibility handler in handlers)
			{
				if (mc.GetType() == handler.GetType())
				{
					LogQueueState(success: false, mc.GetType().ToString());
					return;
				}
			}
			MonitorCompatibility result = null;
			if (removeDefaultHandler && handlers.TryPeek(out result) && result.GetType() == typeof(DefaultMonitor))
			{
				handlers.Dequeue();
			}
			handlers.Enqueue(mc);
			LogQueueState();
		}

		private static void LogQueueState(bool success = true, string? type = null)
		{
			StringBuilder stringBuilder;
			if (success)
			{
				stringBuilder = new StringBuilder("A new monitor handler has been registered. ");
			}
			else
			{
				stringBuilder = new StringBuilder("Not registering handler of type ");
				stringBuilder.Append(type);
				stringBuilder.Append(" because one of the same type has already been registered. ");
			}
			stringBuilder.AppendLine($"There are now {handlers.Count} handlers loaded");
			int num = 0;
			foreach (MonitorCompatibility handler in handlers)
			{
				stringBuilder.Append(num++);
				stringBuilder.Append(" :");
				stringBuilder.AppendLine(handler.GetType().ToString());
			}
			ShipMeltdown.mls.LogInfo((object)stringBuilder);
		}

		internal static void MaintainScreenOff()
		{
			foreach (MonitorCompatibility handler in handlers)
			{
				handler.MaintainScreenOff().Run();
			}
		}

		internal static void MaintainScreenOffReset()
		{
			foreach (MonitorCompatibility handler in handlers)
			{
				handler.MaintainScreenOff().Reset();
			}
		}

		internal static void MostSystemsDead()
		{
			foreach (MonitorCompatibility handler in handlers)
			{
				handler.MostSystemsDead();
			}
		}

		internal static void ReviveSystems()
		{
			foreach (MonitorCompatibility handler in handlers)
			{
				handler.ReviveSystems();
			}
		}
	}
	public interface MonitorCompatibility
	{
		ControlledTask MaintainScreenOff();

		void MostSystemsDead();

		void ReviveSystems();
	}
}
namespace ShipMeltdown.Utils.Monitors
{
	public class DefaultMonitor : MonitorCompatibility
	{
		private ControlledTask maintainScreenOff = new ControlledTask(delegate
		{
			StartOfRound.Instance.mapScreen.SwitchScreenOn(false);
		}, shouldBeDoneOnlyOnce: false);

		internal DefaultMonitor()
		{
		}

		public ControlledTask MaintainScreenOff()
		{
			return maintainScreenOff;
		}

		public void MostSystemsDead()
		{
			ShipPanic.TryWithoutNullPo(delegate
			{
				((Behaviour)StartOfRound.Instance.deadlineMonitorText).enabled = false;
			});
			ShipPanic.TryWithoutNullPo(delegate
			{
				((Behaviour)StartOfRound.Instance.deadlineMonitorBGImage).enabled = false;
			});
			ShipPanic.TryWithoutNullPo(delegate
			{
				((Behaviour)StartOfRound.Instance.profitQuotaMonitorText).enabled = false;
			});
			ShipPanic.TryWithoutNullPo(delegate
			{
				((Behaviour)StartOfRound.Instance.profitQuotaMonitorBGImage).enabled = false;
			});
		}

		public void ReviveSystems()
		{
			ShipPanic.TryWithoutNullPo(delegate
			{
				((Behaviour)StartOfRound.Instance.deadlineMonitorText).enabled = true;
			});
			ShipPanic.TryWithoutNullPo(delegate
			{
				((Behaviour)StartOfRound.Instance.deadlineMonitorBGImage).enabled = true;
			});
			ShipPanic.TryWithoutNullPo(delegate
			{
				((Behaviour)StartOfRound.Instance.profitQuotaMonitorText).enabled = true;
			});
			ShipPanic.TryWithoutNullPo(delegate
			{
				((Behaviour)StartOfRound.Instance.profitQuotaMonitorBGImage).enabled = true;
			});
		}
	}
	public class GeneralImprovements : MonitorCompatibility
	{
		internal static Queue<TextMeshProUGUI> monitors_text;

		internal static Queue<ManualCameraRenderer> monitors_cameras;

		internal static Queue<MeshRenderer> monitors_mesh;

		private ControlledTask maintainScreenOff = new ControlledTask(delegate
		{
			StartOfRound.Instance.mapScreen.SwitchScreenOn(false);
		}, shouldBeDoneOnlyOnce: false);

		internal GeneralImprovements()
		{
			ShipMeltdown.instance.harmony.PatchAll(typeof(StartOfRoundGeneralPatch));
			ShipMeltdown.instance.harmony.PatchAll(typeof(MonitorsHelperPatch));
		}

		public ControlledTask MaintainScreenOff()
		{
			return maintainScreenOff;
		}

		public void MostSystemsDead()
		{
			foreach (TextMeshProUGUI item in monitors_text)
			{
				((Behaviour)item).enabled = false;
			}
			foreach (ManualCameraRenderer monitors_camera in monitors_cameras)
			{
				((Behaviour)monitors_camera).enabled = false;
			}
			foreach (MeshRenderer item2 in monitors_mesh)
			{
				((Renderer)item2).enabled = false;
			}
			StartOfRound.Instance.mapScreen.SwitchScreenOn(false);
			MonitorsHelperPatch.allow = false;
		}

		public void ReviveSystems()
		{
			foreach (TextMeshProUGUI item in monitors_text)
			{
				((Behaviour)item).enabled = true;
			}
			foreach (ManualCameraRenderer monitors_camera in monitors_cameras)
			{
				((Behaviour)monitors_camera).enabled = true;
			}
			foreach (MeshRenderer item2 in monitors_mesh)
			{
				((Renderer)item2).enabled = true;
			}
			MonitorsHelperPatch.allow = true;
			StartOfRound.Instance.mapScreen.SwitchScreenOn(true);
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal static class StartOfRoundGeneralPatch
	{
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPostfix]
		[HarmonyAfter(new string[] { "ShaosilGaming.GeneralImprovements" })]
		private static void StartPatch()
		{
			if (GeneralImprovements.monitors_cameras == null)
			{
				GeneralImprovements.monitors_cameras = new Queue<ManualCameraRenderer>();
			}
			GeneralImprovements.monitors_cameras.Clear();
			if (GeneralImprovements.monitors_mesh == null)
			{
				GeneralImprovements.monitors_mesh = new Queue<MeshRenderer>();
			}
			GeneralImprovements.monitors_mesh.Clear();
			if (GeneralImprovements.monitors_text == null)
			{
				GeneralImprovements.monitors_text = new Queue<TextMeshProUGUI>();
			}
			GeneralImprovements.monitors_text.Clear();
			ManualCameraRenderer[] components = ((Component)StartOfRound.Instance).GetComponents<ManualCameraRenderer>();
			foreach (ManualCameraRenderer val in components)
			{
				if (((Behaviour)val).enabled)
				{
					GeneralImprovements.monitors_cameras.Enqueue(val);
				}
			}
			components = ((Component)StartOfRound.Instance).GetComponentsInChildren<ManualCameraRenderer>();
			foreach (ManualCameraRenderer val2 in components)
			{
				if (((Behaviour)val2).enabled)
				{
					GeneralImprovements.monitors_cameras.Enqueue(val2);
				}
			}
			MeshRenderer[] components2 = ((Component)StartOfRound.Instance).GetComponents<MeshRenderer>();
			foreach (MeshRenderer val3 in components2)
			{
				if (((Renderer)val3).enabled)
				{
					GeneralImprovements.monitors_mesh.Enqueue(val3);
				}
			}
			components2 = ((Component)StartOfRound.Instance).GetComponentsInChildren<MeshRenderer>();
			foreach (MeshRenderer val4 in components2)
			{
				if (((Renderer)val4).enabled)
				{
					GeneralImprovements.monitors_mesh.Enqueue(val4);
				}
			}
			TextMeshProUGUI[] components3 = ((Component)StartOfRound.Instance).GetComponents<TextMeshProUGUI>();
			foreach (TextMeshProUGUI val5 in components3)
			{
				if (((Behaviour)val5).enabled)
				{
					GeneralImprovements.monitors_text.Enqueue(val5);
				}
			}
			components3 = ((Component)StartOfRound.Instance).GetComponentsInChildren<TextMeshProUGUI>();
			foreach (TextMeshProUGUI val6 in components3)
			{
				if (((Behaviour)val6).enabled)
				{
					GeneralImprovements.monitors_text.Enqueue(val6);
				}
			}
			ShipMeltdown.mls.LogInfo((object)$"Found {GeneralImprovements.monitors_cameras.Count} ManualCameraRenderers, {GeneralImprovements.monitors_mesh.Count} MeshRenderers, {GeneralImprovements.monitors_text.Count} TextMeshProUGUIs while initializing queues for GeneralImprovements support");
		}
	}
	[HarmonyPatch(typeof(MonitorsHelper))]
	internal static class MonitorsHelperPatch
	{
		internal static bool allow = true;

		[HarmonyPatch("ToggleExtraMonitorsPower")]
		[HarmonyPrefix]
		private static bool ToggleExtraMonitorsPowerPatch()
		{
			return allow;
		}
	}
	public class OpenMonitor : MonitorCompatibility
	{
		private ControlledTask maintainScreenOff = new ControlledTask(delegate
		{
			StartOfRound.Instance.mapScreen.SwitchScreenOn(false);
		}, shouldBeDoneOnlyOnce: false);

		internal OpenMonitor()
		{
			ShipMeltdown.instance.harmony.PatchAll(typeof(CreditsMonitorPatch));
			ShipMeltdown.instance.harmony.PatchAll(typeof(LifeSupportMonitorPatch));
			if (CreditsMonitorPatch.act == null)
			{
				CreditsMonitorPatch.act = new ControlledTask(delegate
				{
					((Behaviour)((Component)CreditsMonitor.Instance).GetComponent<TextMeshProUGUI>()).enabled = CreditsMonitorPatch.meshEnable;
				}, shouldBeDoneOnlyOnce: true);
			}
			CreditsMonitorPatch.meshEnable = true;
			if (LifeSupportMonitorPatch.act == null)
			{
				LifeSupportMonitorPatch.act = new ControlledTask(delegate
				{
					((Behaviour)((Component)LifeSupportMonitor.Instance).GetComponent<TextMeshProUGUI>()).enabled = LifeSupportMonitorPatch.meshEnable;
				}, shouldBeDoneOnlyOnce: true);
			}
			LifeSupportMonitorPatch.meshEnable = true;
		}

		public ControlledTask MaintainScreenOff()
		{
			return maintainScreenOff;
		}

		public void MostSystemsDead()
		{
			if (!Config.HideCredits.Value)
			{
				CreditsMonitorPatch.meshEnable = false;
				CreditsMonitor.Instance.UpdateMonitor();
			}
			if (!Config.HideLifeSupport.Value)
			{
				LifeSupportMonitorPatch.meshEnable = false;
				LifeSupportMonitor.Instance.UpdateMonitor();
			}
			if (Config.KeepBlueBackground2.Value)
			{
				((Behaviour)StartOfRound.Instance.deadlineMonitorBGImage).enabled = false;
			}
			if (Config.KeepBlueBackground1.Value)
			{
				((Behaviour)StartOfRound.Instance.profitQuotaMonitorBGImage).enabled = false;
			}
			((Behaviour)StartOfRound.Instance.deadlineMonitorText).enabled = false;
			((Behaviour)StartOfRound.Instance.profitQuotaMonitorText).enabled = false;
			if (!Config.HideDay.Value)
			{
				((Behaviour)DayMonitor.Instance.textMesh).enabled = false;
			}
			if (!Config.HideLoot.Value)
			{
				((Behaviour)LootMonitor.Instance.textMesh).enabled = false;
			}
			if (!Config.HideTime.Value)
			{
				((Behaviour)TimeMonitor.Instance.textMesh).enabled = false;
			}
			if (!Config.HideLifeSupport.Value)
			{
				((Behaviour)LifeSupportMonitor.Instance).enabled = false;
			}
			if (!Config.HidePlayersLifeSupport.Value)
			{
				((Behaviour)PlayersLifeSupportMonitor.Instance.textMesh).enabled = false;
			}
		}

		public void ReviveSystems()
		{
			if (!Config.HideCredits.Value)
			{
				CreditsMonitorPatch.meshEnable = true;
				CreditsMonitor.Instance.UpdateMonitor();
			}
			if (!Config.HideLifeSupport.Value)
			{
				LifeSupportMonitorPatch.meshEnable = true;
				LifeSupportMonitor.Instance.UpdateMonitor();
			}
			if (Config.KeepBlueBackground2.Value)
			{
				((Behaviour)StartOfRound.Instance.deadlineMonitorBGImage).enabled = true;
			}
			if (Config.KeepBlueBackground1.Value)
			{
				((Behaviour)StartOfRound.Instance.profitQuotaMonitorBGImage).enabled = true;
			}
			((Behaviour)StartOfRound.Instance.deadlineMonitorText).enabled = true;
			((Behaviour)StartOfRound.Instance.profitQuotaMonitorText).enabled = true;
			if (!Config.HideCredits.Value)
			{
				((Behaviour)CreditsMonitor.Instance).enabled = true;
			}
			if (!Config.HideDay.Value)
			{
				((Behaviour)DayMonitor.Instance.textMesh).enabled = true;
			}
			if (!Config.HideLoot.Value)
			{
				((Behaviour)LootMonitor.Instance.textMesh).enabled = true;
			}
			if (!Config.HideTime.Value)
			{
				((Behaviour)TimeMonitor.Instance.textMesh).enabled = true;
			}
			if (!Config.HideLifeSupport.Value)
			{
				((Behaviour)LifeSupportMonitor.Instance).enabled = true;
			}
			if (!Config.HidePlayersLifeSupport.Value)
			{
				((Behaviour)PlayersLifeSupportMonitor.Instance.textMesh).enabled = true;
			}
		}
	}
	[HarmonyPatch(typeof(CreditsMonitor))]
	public class CreditsMonitorPatch
	{
		internal static bool meshEnable = true;

		internal static ControlledTask? act;

		[HarmonyPrefix]
		[HarmonyPatch("UpdateMonitor")]
		private static bool UpdatePatch()
		{
			if (!meshEnable)
			{
				act.Run();
				return false;
			}
			act.Reset();
			act.Run();
			act.Reset();
			return true;
		}
	}
	[HarmonyPatch(typeof(LifeSupportMonitor))]
	public class LifeSupportMonitorPatch
	{
		internal static bool meshEnable = true;

		internal static ControlledTask? act;

		[HarmonyPrefix]
		[HarmonyPatch("UpdateMonitor")]
		private static bool UpdatePatch()
		{
			if (!meshEnable)
			{
				act.Run();
				return false;
			}
			act.Reset();
			act.Run();
			act.Reset();
			return true;
		}
	}
}
namespace ShipMeltdown.Patches
{
	[HarmonyPatch(typeof(MeltdownHandler))]
	public class MeltdownHandlerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnDisable")]
		private static void onDisablePatch()
		{
			ShipPanic.ReviveSystems();
			ShipPanic.meltdownTimer = 120f;
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void UpdatePatch()
		{
			ShipPanic.meltdownTimer -= Time.deltaTime;
			if (ShipPanic.meltdownTimer >= 0f)
			{
				ShipPanic.delta += Time.deltaTime;
				ShipPanic.delta2 += Time.deltaTime;
			}
			if (ShipPanic.meltdownTimer >= 0f && ShipPanic.delta > 0.5f + ShipPanic.meltdownTimer / 120f * 5f)
			{
				ShipPanic.delta = 0f;
				foreach (var (val, flag) in ShipPanic.toggleGroup)
				{
					((Behaviour)val).enabled = flag && !((Behaviour)val).enabled;
				}
				StartOfRound.Instance.shipRoomLights.ToggleShipLights();
			}
			if (ShipPanic.meltdownTimer <= 30f)
			{
				ShipPanic.KillSystems.Run();
				MonitorCompatibilityHandler.MaintainScreenOff();
			}
			if (Config.Instance.shipDoorMalfunction.Value && ShipPanic.meltdownTimer >= 0f && ShipPanic.delta2 > 10f)
			{
				ShipPanic.h.shipDoorsAnimator.SetBool("Closed", ShipPanic.repeat);
				ShipPanic.repeat = !ShipPanic.repeat;
				ShipPanic.delta2 = 0f;
			}
			if (ShipPanic.meltdownTimer < 3f)
			{
				ShipPanic.BreakLever.Run();
			}
			if (ShipPanic.meltdownTimer <= -16f)
			{
				ShipPanic.takeOff.Run();
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal static class StartOfRoundPatch1
	{
		internal static DialogueSegment[] failure;

		[HarmonyPrefix]
		[HarmonyPatch("ShipLeave")]
		internal static bool ShipLeavePatch()
		{
			if (!ShipPanic.CanTakeOff)
			{
				StartOfRound.Instance.shipIsLeaving = false;
				HUDManager.Instance.ReadDialogue(failure);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal static class StartOfRoundPatch2
	{
		private static int emergencyType = 1;

		private static float delta = 0f;

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void UpdatePatch()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (((ButtonControl)Keyboard.current[Config.Instance.toggleEmergencyLights.Value]).wasReleasedThisFrame && !MeltdownAPI.MeltdownStarted && StartOfRound.Instance.localPlayerController.isInElevator)
			{
				ShipPanic.LightAlarm(emergencyType);
				emergencyType = -emergencyType;
			}
			if (ShipPanic.OnlyLights && delta >= 5f)
			{
				ShipPanic.ToggleLightsOnly();
				delta = 0f;
			}
			else if (ShipPanic.OnlyLights)
			{
				delta += Time.deltaTime;
			}
		}
	}
}