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+001aea35c7a4292b82e53ccfec88b06a5f305556")]
[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;
}
}
}
}
