darmuh-ghostCodes Source

Communities

Lethal CompanyghostCodes

Install

Last Updated

First Uploaded

Downloads

1.4M

Likes

Size

2.4MB

Dependency string

darmuh-ghostCodes-2.5.2

Dependants

1146 other mods

Mods BepInEx Client-side Server-side

Deprecated

Download

Details Required (1)Wiki Changelog Versions Analysis

The result has been truncated due to the large size, download it to view the full contents!

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.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig;
using Microsoft.CodeAnalysis;
using OpenLib;
using OpenLib.Common;
using OpenLib.Compat;
using OpenLib.ConfigManager;
using OpenLib.CoreMethods;
using OpenLib.Events;
using TMPro;
using TerminalStuff;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;
using com.github.zehsteam.ToilHead.MonoBehaviours;
using ghostCodes.Compatibility;
using ghostCodes.Configs;
using ghostCodes.Interactions;
using ghostCodes.NetcodePatcher;
using ghostCodes.Patches;
using ghostCodes.PluginStuff;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ghostcodes")]
[assembly: AssemblyDescription("https://github.com/darmuh/ghostcodes")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ghostcodes")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("d54996ea-9c7b-47cf-b5cb-fdfe2c657f71")]
[assembly: AssemblyFileVersion("2.5.2")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.5.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace ghostCodes
{
	internal class Blastdoors
	{
		internal static void HandleHungryDoor(int randomObjectNum, StartOfRound instance)
		{
			if (CodeStuff.myTerminalObjects.Count != 0)
			{
				if (((Object)((Component)CodeStuff.myTerminalObjects[randomObjectNum]).gameObject).name.Contains("BigDoor"))
				{
					Plugin.MoreLogs("The door is hungy");
					((MonoBehaviour)instance).StartCoroutine(HungryDoor(randomObjectNum));
				}
				else
				{
					CodeStuff.myTerminalObjects[randomObjectNum].CallFunctionFromTerminal();
				}
			}
		}

		private static IEnumerator HungryDoor(int randomObjectNum)
		{
			float intervalTime = Random.Range(0.2f, 0.7f);
			int numBites = Random.Range(3, 9);
			if (((Object)((Component)CodeStuff.myTerminalObjects[randomObjectNum]).gameObject).name.Contains("BigDoor"))
			{
				int j;
				for (j = 0; j < numBites; j++)
				{
					CodeStuff.myTerminalObjects[randomObjectNum].CallFunctionFromTerminal();
					yield return (object)new WaitForSeconds(intervalTime);
					j++;
				}
			}
		}
	}
	internal class Teleporters
	{
		internal static void InteractWithAnyTP(int tpNum)
		{
			if (tpNum == 0 && (Object)(object)Teleporter.NormalTP != (Object)null)
			{
				Plugin.MoreLogs("Messing with NormalTP");
				Teleporter.NormalTP.PressTeleportButtonServerRpc();
				Plugin.MoreLogs("NormalTP button pressed via ServerRpc");
			}
			else if (tpNum == 1 && (Object)(object)Teleporter.InverseTP != (Object)null)
			{
				Plugin.MoreLogs("Messing with InverseTP");
				Teleporter.InverseTP.PressTeleportButtonServerRpc();
				Plugin.MoreLogs("InverseTP button pressed via ServerRpc");
			}
		}
	}
	internal class TerminalAdditions
	{
		internal static TerminalNode rebootNode;

		internal static bool rebootCommandExpired = false;

		internal static int rebootCount;

		internal static int rebootTime;

		internal static int deathNoteStrikes = 0;

		public static bool isTerminalRebooting = false;

		internal static bool spookyColors = false;

		internal static bool credsCorrupted = false;

		internal static int OriginalCreds = 0;

		internal static Color OriginalColor;

		internal static string rebootConfirmName = "ghostCodes_confirm_reboot";

		internal static string rebootDenyName = "ghostCodes_deny_reboot";

		internal static AudioClip Shock;

		internal static AudioClip Reboot;

		internal static AudioClip Success;

		internal static void ResetBools()
		{
			isTerminalRebooting = false;
			rebootCommandExpired = false;
			spookyColors = false;
			rebootCount = 0;
			deathNoteStrikes = 0;
		}

		internal static IEnumerator RebootTerminalSpooky()
		{
			if (isTerminalRebooting)
			{
				yield break;
			}
			Plugin.MoreLogs("Start of spooky terminal reboot coroutine.");
			SoundSystem.PlayTerminalSound(Reboot);
			yield return (object)new WaitForSeconds(1f);
			SetTerminalText(StringStuff.reboot_3);
			yield return (object)new WaitForSeconds(1f);
			SetTerminalText(StringStuff.reboot_2);
			yield return (object)new WaitForSeconds(1f);
			SetTerminalText(StringStuff.reboot_1);
			Plugin.instance.Terminal.QuitTerminal(true);
			yield return (object)new WaitForEndOfFrame();
			IsTerminalUsable(state: false);
			float originalAlpha = ((TMP_Text)Plugin.instance.Terminal.topRightText).alpha;
			((TMP_Text)Plugin.instance.Terminal.topRightText).alpha = 0f;
			((Component)Plugin.instance.Terminal.terminalUIScreen).gameObject.SetActive(true);
			Plugin.instance.Terminal.screenText.caretPosition = Plugin.instance.Terminal.screenText.text.Length;
			Bools.endAllCodes = true;
			isTerminalRebooting = true;
			yield return (object)new WaitForSeconds(1f);
			SetTerminalText(StringStuff.reboot_progress_1);
			((MonoBehaviour)StartOfRound.Instance).StartCoroutine(RebootLoadingTextLoop());
			yield return (object)new WaitForSeconds((float)rebootTime);
			isTerminalRebooting = false;
			DressGirl.StopGirlFromChasing();
			Bools.endAllCodes = false;
			((TMP_Text)Plugin.instance.Terminal.topRightText).alpha = originalAlpha;
			Plugin.instance.Terminal.terminalAudio.Stop();
			SoundSystem.PlayTerminalSound(Success);
			SetTerminalText("\n\n\n\n\n\n\n\n\n\t\t>>Reboot <color=#ebe334>Complete.</color><<\n\n\n\n");
			IsTerminalUsable(state: true);
			InitPlugin.RestartPlugin();
			if (InteractionsConfig.TerminalRebootUses.Value > 0)
			{
				if (rebootCount >= InteractionsConfig.TerminalRebootUses.Value)
				{
					rebootCommandExpired = true;
				}
				else
				{
					rebootCount++;
				}
			}
		}

		internal static IEnumerator RebootLoadingTextLoop()
		{
			while (isTerminalRebooting)
			{
				int @int = NumberStuff.GetInt(0, StringStuff.rebootProgress.Count);
				SetTerminalText("<color=#b81b1b>" + StringStuff.rebootProgress[@int] + "</color>");
				yield return (object)new WaitForSeconds(0.1f);
			}
		}

		internal static void SetTerminalText(string newText)
		{
			Plugin.instance.Terminal.currentText = newText;
			Plugin.instance.Terminal.screenText.text = newText;
		}

		internal static void IsTerminalUsable(bool state)
		{
			Plugin.instance.Terminal.terminalTrigger.interactable = state;
			Plugin.MoreLogs($"terminal interactable set to {state}");
		}

		internal static string HandleRebootNode()
		{
			Plugin.MoreLogs("Handling reboot node");
			if (StartOfRound.Instance.inShipPhase)
			{
				return "\n\n\n\n\n\n\t\tTerminal reboot is not necessary... (in orbit)\r\n";
			}
			int @int = NumberStuff.GetInt(0, 100);
			if (InteractionsConfig.TerminalReboot.Value < @int || rebootCommandExpired)
			{
				string result = "\n\n\n\n\n\n\t\tTerminal reboot has failed...\r\n";
				rebootCommandExpired = true;
				return result;
			}
			((MonoBehaviour)StartOfRound.Instance).StartCoroutine(RebootTerminalSpooky());
			Plugin.MoreLogs("rebooting terminal");
			return "";
		}

		internal static string AskTerminalReboot()
		{
			rebootTime = NumberStuff.GetInt(30, 88);
			return $"You have requested to reboot the terminal.\nTotal time to reboot is {rebootTime} seconds...\n\nPlease CONFIRM or DENY.\n\n";
		}

		internal static void CreateAllNodes()
		{
			if (ModConfig.ModNetworking.Value)
			{
				CreateRebootNode();
				CreateDeathNoteNode();
			}
		}

		private static void CreateRebootNode()
		{
			if (InteractionsConfig.TerminalReboot.Value >= 1)
			{
				rebootNode = AddingThings.AddNodeManual("ghostCodes_reboot", "reboot", (Func<string>)AskTerminalReboot, true, 1, ConfigSetup.defaultListing, 0, (Func<string>)HandleRebootNode, (Func<string>)null, "", "Terminal Reboot has been cancelled.\r\n\r\n", false, 1, "", false, "");
			}
		}

		private static void CreateDeathNoteNode()
		{
			if (InteractionsConfig.DeathNote.Value >= 1 && StartOfRound.Instance.allPlayerScripts.Any((PlayerControllerB x) => x.isPlayerControlled && (Object)(object)x != (Object)(object)StartOfRound.Instance.localPlayerController))
			{
				Plugin.Spam("Adding deathnotemenu!");
				DeathNote.DeathNoteMenu = AddingThings.AddNodeManual("DeathNoteMenu", "leave me alone", (Func<string>)OpenDeathNote, true, 0, ConfigSetup.defaultListing, 0, (Func<string>)null, (Func<string>)null, "", "", false, 1, "", false, "");
			}
		}

		internal static string OpenDeathNote()
		{
			if (!CanUseDeathNote())
			{
				return "Chill out, no one is after you lol\r\n\r\n";
			}
			if (Plugin.instance.TerminalStuff)
			{
				TerminalStuff.StopShortCuts(stop: true);
			}
			DeathNote.currentPage = 1;
			((MonoBehaviour)Plugin.instance.Terminal).StartCoroutine(DeathNote.MenuStart());
			return DeathNote.GetPlayerList(0, 10, ref DeathNote.currentPage);
		}

		internal static bool CanUseDeathNote()
		{
			if ((Object)(object)Plugin.instance.DressGirl == (Object)null)
			{
				return false;
			}
			if (!Plugin.instance.DressGirl.hauntingLocalPlayer)
			{
				return false;
			}
			if (!StartOfRound.Instance.allPlayerScripts.Any((PlayerControllerB x) => x.isPlayerControlled && (Object)(object)x != (Object)(object)StartOfRound.Instance.localPlayerController))
			{
				return false;
			}
			if (StartOfRound.Instance.shipIsLeaving)
			{
				return false;
			}
			return true;
		}

		internal static void DeathNoteFail()
		{
			if (InteractionsConfig.DeathNoteFailChase.boolValue && !((Object)(object)Plugin.instance.DressGirl == (Object)null))
			{
				Plugin.MoreLogs("death note failed, beginning ghost girl chase");
				Plugin.instance.DressGirl.BeginChasing();
			}
		}

		internal static void CorruptedCredits(bool state)
		{
			//IL_00b5: 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_0035: 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)
			if (state)
			{
				Plugin.Spam("Credits corrupted!");
				OriginalCreds = Plugin.instance.Terminal.groupCredits;
				OriginalColor = ((Graphic)Plugin.instance.Terminal.topRightText).color;
				Plugin.instance.Terminal.SyncGroupCreditsServerRpc(0, Plugin.instance.Terminal.numberOfItemsInDropship);
				((Graphic)Plugin.instance.Terminal.topRightText).color = Color.red;
				credsCorrupted = true;
			}
			else
			{
				Plugin.Spam("Credits restored!");
				Plugin.instance.Terminal.SyncGroupCreditsServerRpc(OriginalCreds, Plugin.instance.Terminal.numberOfItemsInDropship);
				((Graphic)Plugin.instance.Terminal.topRightText).color = OriginalColor;
				credsCorrupted = false;
			}
		}

		internal static void RestoreCreds()
		{
			if (credsCorrupted)
			{
				CorruptedCredits(state: false);
			}
		}
	}
	internal class Bools
	{
		internal static bool lightsFlickering;

		internal static bool endFlicker;

		internal static bool appPullInvoked;

		public static bool endAllCodes;

		internal static bool IsCodeSent()
		{
			return Plugin.instance.CodeSent;
		}

		internal static bool IsInsideFactory()
		{
			return StartOfRound.Instance.localPlayerController.isInsideFactory;
		}

		internal static bool IsHourInRange(int hour, int startHour, int endHour)
		{
			if (hour > startHour)
			{
				return hour <= endHour;
			}
			return false;
		}

		internal static bool ShouldRunCodeLooper()
		{
			if (SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings")
			{
				return true;
			}
			if (!ModConfig.ModNetworking.Value)
			{
				return true;
			}
			if ((Object)(object)Plugin.instance.Terminal == (Object)null)
			{
				Plugin.MoreLogs("Terminal instance null");
				return false;
			}
			return false;
		}

		internal static bool ShouldInitPlugin()
		{
			if ((Object)(object)Plugin.instance.Terminal == (Object)null)
			{
				Plugin.MoreLogs("Terminal instance null");
				return false;
			}
			return true;
		}

		public static bool GhostCodesShouldNotBePresentEver()
		{
			if (((Object)StartOfRound.Instance.currentLevel).name == "CompanyBuildingLevel" || StartOfRound.Instance.currentLevel.riskLevel == "Safe")
			{
				return true;
			}
			if (StartOfRound.Instance.inShipPhase)
			{
				return true;
			}
			if (Plugin.instance.CodeCount > Plugin.instance.RandCodeAmount)
			{
				return true;
			}
			return false;
		}

		public static bool CanSendCodes()
		{
			if (endAllCodes || GhostCodesShouldNotBePresentEver())
			{
				return false;
			}
			if (SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings")
			{
				return GameNetworkManager.Instance.gameHasStarted;
			}
			if ((Object)(object)Plugin.instance.DressGirl == (Object)null)
			{
				Plugin.MoreLogs("dressgirl instance is null");
				return false;
			}
			if (GameNetworkManager.Instance.gameHasStarted)
			{
				return Plugin.instance.DressGirl.hauntingLocalPlayer == Object.op_Implicit((Object)(object)StartOfRound.Instance.localPlayerController);
			}
			return false;
		}

		internal static bool PlayerStillAliveAndControlled(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (!player.isPlayerControlled)
			{
				return false;
			}
			if (player.isPlayerDead)
			{
				return false;
			}
			return true;
		}

		internal static bool KeepSendingCodes()
		{
			if (endAllCodes || GhostCodesShouldNotBePresentEver())
			{
				return false;
			}
			if (StartOfRound.Instance.shipIsLeaving || StartOfRound.Instance.allPlayersDead)
			{
				return false;
			}
			if (SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings")
			{
				return true;
			}
			if ((Object)(object)Plugin.instance.DressGirl == (Object)null)
			{
				return false;
			}
			if (!Plugin.instance.DressGirl.hauntingLocalPlayer)
			{
				return false;
			}
			if (Plugin.instance.DressGirl.hauntingPlayer.isPlayerDead)
			{
				return false;
			}
			if (Coroutines.rapidFireStart && !DressGirl.girlIsChasing)
			{
				return false;
			}
			return true;
		}

		internal static bool DressGirlStartCodes()
		{
			if (endAllCodes || RapidFire.startRapidFire || GhostCodesShouldNotBePresentEver())
			{
				return false;
			}
			if (StartOfRound.Instance.shipIsLeaving || StartOfRound.Instance.allPlayersDead)
			{
				return false;
			}
			if (!Plugin.instance.DressGirl.staringInHaunt || Plugin.instance.DressGirl.hauntingPlayer.isPlayerDead)
			{
				return false;
			}
			return true;
		}

		internal static bool IsThisaBigDoor(int randomObjectNum)
		{
			if (randomObjectNum < 0)
			{
				return false;
			}
			if (CodeStuff.myTerminalObjects.Count == 0)
			{
				return false;
			}
			if ((Object)(object)CodeStuff.myTerminalObjects[randomObjectNum] == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)CodeStuff.myTerminalObjects[randomObjectNum]).gameObject == (Object)null)
			{
				return false;
			}
			if (((Object)((Component)CodeStuff.myTerminalObjects[randomObjectNum]).gameObject).name.Contains("BigDoor"))
			{
				return true;
			}
			return false;
		}

		internal static bool AreEnoughPlayersDancing(int totalPlayers, int playersDancing, int requiredPercentage)
		{
			if (playersDancing > totalPlayers * (requiredPercentage / 100))
			{
				return true;
			}
			return false;
		}

		internal static bool IsThisEffective(int percentChance)
		{
			int @int = NumberStuff.GetInt(0, 100);
			if (percentChance > @int)
			{
				return true;
			}
			return false;
		}

		internal static bool CheckForPlayerName(string playerName)
		{
			PlayerControllerB[] players = Plugin.instance.players;
			foreach (PlayerControllerB val in players)
			{
				if (playerName.Contains(val.playerUsername))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool AreAnyPlayersInShip()
		{
			PlayerControllerB[] players = Plugin.instance.players;
			foreach (PlayerControllerB val in players)
			{
				if (!val.isPlayerDead && val.isInHangarShipRoom)
				{
					return true;
				}
			}
			Plugin.MoreLogs("No players detected in ship");
			return false;
		}

		internal static bool AreAnyPlayersInFacility()
		{
			PlayerControllerB[] players = Plugin.instance.players;
			foreach (PlayerControllerB val in players)
			{
				if (!val.isPlayerDead && val.isInsideFactory)
				{
					return true;
				}
			}
			Plugin.MoreLogs("No players detected in facility");
			return false;
		}

		internal static bool IsAnyPlayerUsingTerminal(out PlayerControllerB terminalUser)
		{
			PlayerControllerB[] players = Plugin.instance.players;
			foreach (PlayerControllerB val in players)
			{
				if (!val.isPlayerDead && val.inTerminalMenu)
				{
					terminalUser = val;
					return true;
				}
			}
			terminalUser = null;
			return false;
		}
	}
	internal class CodeActions
	{
		internal static Random Rand = new Random();

		internal static void InitPossibleActions(StartOfRound instance, int randomObjectNum = -1)
		{
			CodeHandling.possibleActions.Clear();
			NetworkingRequiredActions();
			ExternalModCheck();
			CruiserStuff();
			ShipStuff();
			GhostGirlRequired();
			AddRegularDoorStuff();
			Maininteractions();
			if (randomObjectNum >= 0 && CodeStuff.myTerminalObjects.Count > randomObjectNum)
			{
				TerminalObjectActions(instance, randomObjectNum);
			}
		}

		private static void Maininteractions()
		{
			if (InteractionsConfig.AffectAllBatteries.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("AffectAllBatteries", delegate
				{
					Items.AdjustAllPlayersBattery();
				}, InteractionsConfig.AffectAllBatteries.Value));
			}
			if (InteractionsConfig.AffectRandomPlayerBatteries.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("AffectRandomPlayerBatteries", delegate
				{
					Items.AffectRandomPlayersBatteries();
				}, InteractionsConfig.AffectRandomPlayerBatteries.Value));
			}
			if (InteractionsConfig.HauntFactoryScrap.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("HauntFactoryScrap", delegate
				{
					Items.HauntItemUse(isHeld: false);
				}, InteractionsConfig.HauntFactoryScrap.Value));
			}
			if (InteractionsConfig.HauntHeldScrap.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("HauntHeldScrap", delegate
				{
					Items.HauntItemUse(isHeld: true);
				}, InteractionsConfig.HauntHeldScrap.Value));
			}
			if (InteractionsConfig.SignalTranslator.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("SignalTranslator", delegate
				{
					SignalTranslator.MessWithSignalTranslator();
				}, InteractionsConfig.SignalTranslator.Value));
			}
		}

		private static void MessWithWalkies()
		{
			if (WalkieTalkie.allWalkieTalkies.Count == 0 || !SetupConfig.GhostCodesSettings.HauntingsMode)
			{
				return;
			}
			Plugin.Spam("Adding enabled walkie stuff");
			if (InteractionsConfig.GarbleWalkies.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("GarbleWalkies", delegate
				{
					NetHandler.Instance.GarbleWalkiesServerRpc();
				}, InteractionsConfig.GarbleWalkies.Value));
			}
			if (InteractionsConfig.BreatheOnWalkies.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("BreatheOnWalkies", delegate
				{
					NetHandler.Instance.BreatheOnWalkiesServerRpc();
				}, InteractionsConfig.BreatheOnWalkies.Value));
			}
		}

		private static void GhostGirlRequired()
		{
			if (!SetupConfig.GhostCodesSettings.HauntingsMode)
			{
				return;
			}
			if (InteractionsConfig.PlayerLights.Value > 0 && !RapidFire.startRapidFire)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("ggFlashlight", delegate
				{
					Lights.GGFlashlight();
				}, InteractionsConfig.PlayerLights.Value));
			}
			if (InteractionsConfig.AffectHauntedPlayerBatteries.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("AffectHauntedPlayerBatteries", delegate
				{
					Items.AffectHauntedPlayersBatteries();
				}, InteractionsConfig.AffectHauntedPlayerBatteries.Value));
			}
			MessWithWalkies();
		}

		private static void ShipStuff()
		{
			if (!Bools.AreAnyPlayersInShip())
			{
				return;
			}
			Plugin.Spam("players detected on ship");
			if (InteractionsConfig.LightsOnShip.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("MessWithShipLights", delegate
				{
					ghostCodes.ShipStuff.MessWithShipLights();
				}, InteractionsConfig.LightsOnShip.Value));
			}
			if (InteractionsConfig.DoorsOnShip.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("MessWithShipDoors", delegate
				{
					ghostCodes.ShipStuff.MessWithShipDoors();
				}, InteractionsConfig.DoorsOnShip.Value));
			}
			if (ModConfig.ModNetworking.Value && InteractionsConfig.ShockTerminalUser.Value > 0 && Bools.IsAnyPlayerUsingTerminal(out var terminalUser))
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("Shock Terminal User", delegate
				{
					ghostCodes.ShipStuff.ShockTerminal();
				}, InteractionsConfig.ShockTerminalUser.Value));
				Plugin.MoreLogs(terminalUser.playerUsername + " detected using terminal");
			}
			if (InteractionsConfig.MonitorsOnShip.Value > 0 && ModConfig.ModNetworking.Value)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("MessWithMonitors", delegate
				{
					NetHandler.Instance.MessWithMonitorsServerRpc();
				}, InteractionsConfig.MonitorsOnShip.Value));
			}
			if (InteractionsConfig.TeleportPlayer.Value > 0 && (Object)(object)Teleporter.NormalTP != (Object)null)
			{
				Plugin.MoreLogs("Added MessWithNormalTP");
				CodeHandling.possibleActions.Add(new ActionPercentage("MessWithNormalTP", delegate
				{
					Teleporters.InteractWithAnyTP(0);
				}, InteractionsConfig.TeleportPlayer.Value));
			}
			if (InteractionsConfig.InverseTeleporter.Value > 0 && (Object)(object)Teleporter.InverseTP != (Object)null)
			{
				Plugin.MoreLogs("Added MessWithInverseTP");
				CodeHandling.possibleActions.Add(new ActionPercentage("MessWithInverseTP", delegate
				{
					Teleporters.InteractWithAnyTP(1);
				}, InteractionsConfig.InverseTeleporter.Value));
			}
			if (InteractionsConfig.CorruptedCredits.Value > 0 && !TerminalAdditions.credsCorrupted)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("CorruptedCredits", delegate
				{
					TerminalAdditions.CorruptedCredits(state: true);
				}, InteractionsConfig.CorruptedCredits.Value));
			}
			if (InteractionsConfig.HeavyLever.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("HeavyLever", delegate
				{
					ghostCodes.ShipStuff.HeavyLeverFunc();
				}, InteractionsConfig.HeavyLever.Value));
			}
			if (InteractionsConfig.HauntedOrder.Value > 0 && Plugin.instance.Terminal.orderedItemsFromTerminal.Count == 0 && Plugin.instance.Terminal.numberOfItemsInDropship == 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("HauntedOrder", delegate
				{
					ghostCodes.ShipStuff.HauntedOrderFunc();
				}, InteractionsConfig.HauntedOrder.Value));
			}
		}

		private static void AddRegularDoorStuff()
		{
			if (!Bools.AreAnyPlayersInFacility() || Doors.AllDoors.Count == 0)
			{
				return;
			}
			if (InteractionsConfig.ToggleAllRegularDoors.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("ToggleAllRegularDoors", delegate
				{
					Doors.OpenOrCloseALLDoors();
				}, InteractionsConfig.ToggleAllRegularDoors.Value));
			}
			if (InteractionsConfig.ToggleRegularDoor.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("ToggleRegularDoor", delegate
				{
					Doors.OpenorClose1RandomDoor();
				}, InteractionsConfig.ToggleRegularDoor.Value));
			}
			if (InteractionsConfig.LockSingleDoor.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("LockONEdoor", delegate
				{
					Doors.LockorUnlockARandomDoor(stateLocked: true);
				}, InteractionsConfig.LockSingleDoor.Value));
			}
			if (InteractionsConfig.UnlockSingleDoor.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("UnlockONEdoor", delegate
				{
					Doors.LockorUnlockARandomDoor(stateLocked: false);
				}, InteractionsConfig.UnlockSingleDoor.Value));
			}
			if (InteractionsConfig.TryHauntSingleDoor.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("TryHauntSingleDoor", delegate
				{
					Doors.HauntDoors(0);
				}, InteractionsConfig.TryHauntSingleDoor.Value));
			}
			if (InteractionsConfig.TryHauntHalfAllDoors.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("TryHauntHalfAllDoors", delegate
				{
					Doors.HauntDoors(50);
				}, InteractionsConfig.TryHauntHalfAllDoors.Value));
			}
			if (InteractionsConfig.TryHauntAllDoors.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("TryHauntAllDoors", delegate
				{
					Doors.HauntDoors(100);
				}, InteractionsConfig.TryHauntAllDoors.Value));
			}
		}

		private static void CruiserStuff()
		{
			if ((Object)(object)Plugin.instance.Cruiser == (Object)null || !Plugin.instance.Cruiser.ignitionStarted)
			{
				return;
			}
			Plugin.MoreLogs("Adding cruiser interactions!!");
			if (InteractionsConfig.ChangeCruiserRadio.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("ChangeCruiserRadio", delegate
				{
					Plugin.instance.Cruiser.ChangeRadioStation();
				}, InteractionsConfig.ChangeCruiserRadio.Value));
			}
			if (InteractionsConfig.CruiserEjectDriver.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("CruiserEjectDriver", delegate
				{
					Plugin.instance.Cruiser.SpringDriverSeatServerRpc();
				}, InteractionsConfig.CruiserEjectDriver.Value));
			}
			if (InteractionsConfig.CruiserUseBoost.Value > 0 && ((NetworkBehaviour)Plugin.instance.Cruiser).IsOwner)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("CruiserUseBoost", delegate
				{
					//IL_000c: 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)
					Plugin.instance.Cruiser.UseTurboBoostLocalClient(default(Vector2));
				}, InteractionsConfig.CruiserUseBoost.Value));
			}
			if (InteractionsConfig.CruiserPush.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("CruiserPush", delegate
				{
					Cruiser.Push();
				}, InteractionsConfig.CruiserPush.Value));
			}
			if (InteractionsConfig.ToggleCruiserDoors.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("CruiserDoors", delegate
				{
					Cruiser.Doors();
				}, InteractionsConfig.ToggleCruiserDoors.Value));
			}
			if (InteractionsConfig.ToggleCruiserLights.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("ToggleCruiserLights", delegate
				{
					Cruiser.Headlights(1);
				}, InteractionsConfig.ToggleCruiserLights.Value));
			}
			if (InteractionsConfig.FlickerCruiserLights.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("FlickerCruiserLights", delegate
				{
					Cruiser.Headlights(Rand.Next(11));
				}, InteractionsConfig.FlickerCruiserLights.Value));
			}
			if (InteractionsConfig.ToggleCruiserHood.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("ToggleCruiserHood", delegate
				{
					Plugin.instance.Cruiser.ToggleHoodOpenLocalClient();
				}, InteractionsConfig.ToggleCruiserHood.Value));
			}
			if (InteractionsConfig.CruiserWindshield.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("CruiserWindshield", delegate
				{
					Cruiser.Windshield();
				}, InteractionsConfig.CruiserWindshield.Value));
			}
			if (InteractionsConfig.CruiserShiftGears.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("CruiserShiftGears", delegate
				{
					Cruiser.GearShift();
				}, InteractionsConfig.CruiserShiftGears.Value));
			}
		}

		private static void ExternalModCheck()
		{
			Plugin.MoreLogs("Checking for any external mods to utilize ghost codes on");
			if (!Plugin.instance.ToilHead || !ToilHead.CheckForToilHeadObjects())
			{
				return;
			}
			Plugin.MoreLogs("Adding toilhead actions");
			if (InteractionsConfig.ToilHeadTurretDisable.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("toilHeadDisable", delegate
				{
					ToilHead.HandleToilHeadCodeAction();
				}, InteractionsConfig.ToilHeadTurretDisable.Value));
			}
			if (InteractionsConfig.ToilHeadTurretBerserk.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("toilHeadBerserk", delegate
				{
					ToilHead.HandleToilHeadBerserkAction();
				}, InteractionsConfig.ToilHeadTurretBerserk.Value));
			}
		}

		private static void NetworkingRequiredActions()
		{
			if (ModConfig.ModNetworking.Value && InteractionsConfig.FlipBreaker.Value > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("facilityLights", delegate
				{
					Lights.FlipLights();
				}, InteractionsConfig.FlipBreaker.Value));
			}
		}

		private static void TerminalObjectActions(StartOfRound instance, int randomObjectNum)
		{
			if (CodeStuff.myTerminalObjects.Count > 0)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("DefaultCodes", delegate
				{
					DefaultTerminalAction(randomObjectNum);
				}, 100f));
			}
			if (!SetupConfig.IgnoreDoors.Value && Bools.IsThisaBigDoor(randomObjectNum))
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("hungryDoor", delegate
				{
					Blastdoors.HandleHungryDoor(randomObjectNum, instance);
				}, InteractionsConfig.HungryBlastDoor.Value));
			}
			if (!SetupConfig.IgnoreTurrets.Value)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("TurretBerserk", delegate
				{
					Turrets.HandleTurretAction();
				}, InteractionsConfig.TurretBerserk.Value));
			}
			if (!SetupConfig.IgnoreLandmines.Value)
			{
				CodeHandling.possibleActions.Add(new ActionPercentage("MineBoom", delegate
				{
					Mines.HandleMineBoom();
				}, InteractionsConfig.MineBoom.Value));
			}
		}

		internal static void DefaultTerminalAction(int randomObjectNum)
		{
			if (randomObjectNum != -1 && CodeStuff.myTerminalObjects.Count > randomObjectNum)
			{
				CodeStuff.myTerminalObjects[randomObjectNum].CallFunctionFromTerminal();
			}
		}
	}
	public class ActionPercentage
	{
		public Action Action { get; }

		public float Percentage { get; }

		public string Name { get; set; }

		public ActionPercentage(string name, Action action, float percentage)
		{
			Action = action;
			Percentage = percentage;
			Name = name;
			base..ctor();
		}

		public static List<Action> ChooseActionsFromPercentages(List<ActionPercentage> actions)
		{
			Shuffle(actions);
			List<Action> list = new List<Action>();
			int num = 0;
			foreach (ActionPercentage action in actions)
			{
				Plugin.Spam("Checking " + action.Name + " against percentage");
				int num2 = NumberStuff.Rand.Next(101);
				float num3 = action.Percentage;
				if (RapidFire.startRapidFire)
				{
					num3 = NumberStuff.GetClampedInsanityPercent(num3, InsanityConfig.InsanityModeMultiplier.Value);
				}
				if (num < 3 && ((float)num2 <= num3 || Mathf.Approximately(num3, 100f)))
				{
					Plugin.Spam("Action " + action.Name + " was chosen!");
					list.Add(action.Action);
					num++;
				}
			}
			return list;
		}

		private static void Shuffle<T>(List<T> list)
		{
			int num = list.Count;
			while (num > 1)
			{
				num--;
				int index = NumberStuff.Rand.Next(num);
				T value = list[index];
				list[index] = list[num];
				list[num] = value;
			}
		}
	}
	internal class CodeHandling
	{
		internal static List<ActionPercentage> possibleActions = new List<ActionPercentage>();

		internal static List<Action> chosenActions = new List<Action>();

		internal static void HandleGhostCodeSending(StartOfRound instance)
		{
			Misc.LogTime();
			if (NumberStuff.TryGetObjectNum(out var randomObjectNum))
			{
				chosenActions.Clear();
				CodeActions.InitPossibleActions(instance, randomObjectNum);
			}
			else
			{
				Plugin.WARNING("Unable to get randomObjectNum!");
			}
			if (possibleActions.Count >= 1 && !Bools.endAllCodes)
			{
				chosenActions = ActionPercentage.ChooseActionsFromPercentages(possibleActions);
				HandleChosenActions(randomObjectNum);
				SoundSystem.InsanityAmbient();
				SoundSystem.HandleCodeEffects();
			}
		}

		internal static void HandleRapidFireCodeChoices(StartOfRound instance, int number)
		{
			Misc.LogTime();
			chosenActions.Clear();
			CodeActions.InitPossibleActions(instance, number);
			if (possibleActions.Count >= 1 && !Bools.endAllCodes)
			{
				chosenActions = ActionPercentage.ChooseActionsFromPercentages(possibleActions);
				HandleChosenActions(number);
				SoundSystem.InsanityAmbient();
				SoundSystem.HandleCodeEffects();
			}
		}

		private static void HandleChosenActions(int randomObjectNum)
		{
			if (chosenActions == null && CodeStuff.myTerminalObjects.Count == 0)
			{
				Bools.endAllCodes = true;
				return;
			}
			if (chosenActions.Count > 0)
			{
				foreach (Action chosenAction in chosenActions)
				{
					chosenAction();
				}
				return;
			}
			if (randomObjectNum != -1)
			{
				CodeStuff.myTerminalObjects[randomObjectNum].CallFunctionFromTerminal();
				Plugin.GC.LogInfo((object)"No Special action chosen, calling function from terminal");
			}
		}
	}
	internal class Coroutines
	{
		internal static bool rapidFireStart;

		internal static bool codeLooperStarted;

		internal static IEnumerator InitEnumerator(StartOfRound instance)
		{
			int wait = NumberStuff.GetWait(SetupConfig.RandomIntervals.Value, SetupConfig.FirstRandIntervalMin.Value, SetupConfig.FirstRandIntervalMax.Value, SetupConfig.FirstSetInterval.Value);
			InitPlugin.CodesInit();
			Plugin.MoreLogs($"Codes Amount: {Plugin.instance.RandCodeAmount}");
			if (SetupConfig.GhostCodesSettings.HauntingsMode && ModConfig.ModNetworking.Value)
			{
				Plugin.MoreLogs("The ghost girl has been enhanced, prepare for your next haunting! >:)");
				TerminalAdditions.CreateAllNodes();
			}
			else if (((NetworkBehaviour)GameNetworkManager.Instance.localPlayerController).IsHost)
			{
				yield return (object)new WaitForSeconds((float)wait);
				((MonoBehaviour)StartOfRound.Instance).StartCoroutine(CodeLooper(instance));
				Plugin.MoreLogs("The ghost is in the machine...");
				TerminalAdditions.CreateAllNodes();
			}
			else
			{
				Plugin.MoreLogs("Ghost Girl Enhanced is disabled and you are not the host.");
				TerminalAdditions.CreateAllNodes();
			}
		}

		internal static IEnumerator RestartEnum(StartOfRound instance)
		{
			int @int = NumberStuff.GetInt(20, 100);
			yield return (object)new WaitForSeconds((float)@int);
			int wait = NumberStuff.GetWait(SetupConfig.RandomIntervals.Value, SetupConfig.FirstRandIntervalMin.Value, SetupConfig.FirstRandIntervalMax.Value, SetupConfig.FirstSetInterval.Value);
			Plugin.MoreLogs($"Codes: {Plugin.instance.CodeCount} / {Plugin.instance.RandCodeAmount}");
			if (SetupConfig.GhostCodesSettings.HauntingsMode && ModConfig.ModNetworking.Value)
			{
				Plugin.MoreLogs("The ghost girl has been enhanced, prepare for your next haunting! >:)");
			}
			else if (((NetworkBehaviour)GameNetworkManager.Instance.localPlayerController).IsHost)
			{
				yield return (object)new WaitForSeconds((float)wait);
				Bools.endAllCodes = false;
				rapidFireStart = false;
				RapidFire.startRapidFire = false;
				((MonoBehaviour)instance).StartCoroutine(CodeLooper(instance));
				Plugin.MoreLogs("The ghost is in the machine...");
			}
			else
			{
				Plugin.MoreLogs("Ghost Girl Enhanced is disabled and you are not the host.");
			}
		}

		internal static IEnumerator CodeLooper(StartOfRound instance)
		{
			if (codeLooperStarted)
			{
				yield break;
			}
			Plugin.MoreLogs("CodeLooper coroutine initiated...");
			codeLooperStarted = true;
			if (Bools.CanSendCodes())
			{
				while (Bools.KeepSendingCodes())
				{
					yield return (object)new WaitForSeconds(1f);
					if (!Bools.IsCodeSent())
					{
						float randomWaitNum = NumberStuff.GetWait(SetupConfig.RandomIntervals.Value, SetupConfig.SecondRandIntervalMin.Value, SetupConfig.SecondRandIntervalMax.Value, SetupConfig.SecondSetInterval.Value);
						if (SetupConfig.GhostCodesSettings.InsanityMode)
						{
							InsanityStuff.ApplyInsanityMode(instance, ref randomWaitNum);
							if (RapidFire.startRapidFire)
							{
								Plugin.MoreLogs("startRapidFire detected from codeLooper");
								codeLooperStarted = false;
								yield break;
							}
						}
						yield return (object)new WaitForSeconds(randomWaitNum);
						CodeHandling.HandleGhostCodeSending(instance);
						Plugin.instance.CodeCount++;
						Plugin.instance.CodeSent = true;
						Plugin.MoreLogs($"Code Sent, count: {Plugin.instance.CodeCount}");
					}
					else
					{
						float randomWaitNum2 = NumberStuff.GetWait(SetupConfig.RandomIntervals.Value, SetupConfig.RandIntervalACMin.Value, SetupConfig.RandIntervalACMax.Value, SetupConfig.SetIntervalAC.Value);
						Plugin.MoreLogs($"ghostCode was just sent, waiting {randomWaitNum2}");
						if (SetupConfig.GhostCodesSettings.InsanityMode)
						{
							InsanityStuff.ApplyInsanityMode(instance, ref randomWaitNum2);
						}
						yield return (object)new WaitForSeconds(randomWaitNum2);
						Plugin.instance.CodeSent = false;
					}
					if (StartOfRound.Instance.shipIsLeaving)
					{
						Plugin.MoreLogs($"Ship is leaving, {Plugin.instance.CodeCount} codes were sent.");
						codeLooperStarted = false;
						yield break;
					}
				}
				Plugin.MoreLogs($"the ghost is bored of sending codes, {Plugin.instance.CodeCount} codes were sent.");
				codeLooperStarted = false;
			}
			else
			{
				Plugin.MoreLogs("No codes can be sent at this time.");
				codeLooperStarted = false;
			}
		}

		private static void RapidFireStoppers(int startTime, int currentTime)
		{
			DressGirl.GGrapidFireChecks();
			RapidFire.TimeCheck(startTime, currentTime);
		}

		internal static IEnumerator RapidFireStart(StartOfRound instance)
		{
			if (rapidFireStart)
			{
				yield break;
			}
			Plugin.MoreLogs("start of rapidFire");
			int startTime = TimeOfDay.Instance.hour;
			rapidFireStart = true;
			if (Bools.CanSendCodes())
			{
				while (Bools.KeepSendingCodes() && RapidFire.startRapidFire && !Bools.endAllCodes)
				{
					RapidFire.CheckInsanityToContinue();
					RapidFire.HandleLights();
					if (!Bools.IsCodeSent())
					{
						if (CodeStuff.myTerminalObjects.Count == 0)
						{
							for (int j = 0; j < CodeHandling.possibleActions.Count; j++)
							{
								if (!Bools.KeepSendingCodes())
								{
									break;
								}
								RapidFireStoppers(startTime, TimeOfDay.Instance.hour);
								CodeHandling.HandleRapidFireCodeChoices(instance, -1);
								yield return (object)new WaitForSeconds(Random.Range(0.5f, 3f));
							}
						}
						else
						{
							for (int j = 0; j < CodeStuff.myTerminalObjects.Count; j++)
							{
								if (!Bools.KeepSendingCodes())
								{
									break;
								}
								RapidFireStoppers(startTime, TimeOfDay.Instance.hour);
								CodeHandling.HandleRapidFireCodeChoices(instance, j);
								yield return (object)new WaitForSeconds(Random.Range(0.5f, 3f));
							}
						}
						RapidFire.CountSentCodes();
						Plugin.instance.CodeSent = true;
					}
					else
					{
						RapidFireStoppers(startTime, TimeOfDay.Instance.hour);
						float num = Random.Range(1f, 4f);
						RapidFireStoppers(startTime, TimeOfDay.Instance.hour);
						yield return (object)new WaitForSeconds(num);
						Plugin.instance.CodeSent = false;
					}
					if (RapidFire.LoopBreakers())
					{
						yield break;
					}
				}
				if (!Bools.KeepSendingCodes())
				{
					Plugin.GC.LogInfo((object)"end of rapidFire....");
				}
				if (!RapidFire.startRapidFire && Bools.KeepSendingCodes() && !Bools.endAllCodes)
				{
					RapidFire.ReturnFromRapidFire();
					RapidFire.startRapidFire = false;
					rapidFireStart = false;
				}
				else
				{
					_ = Bools.endAllCodes;
					RapidFire.startRapidFire = false;
					rapidFireStart = false;
				}
			}
			else
			{
				RapidFire.startRapidFire = false;
				rapidFireStart = false;
			}
		}

		internal static IEnumerator EmptyShip()
		{
			Plugin.MoreLogs("Emptying the ship of any players!");
			PlayerControllerB localPlayer = StartOfRound.Instance.localPlayerController;
			Vector3 playerPosition = ((Component)localPlayer).transform.position;
			Vector3 shipDoorPosition = StartOfRound.Instance.shipDoorNode.position;
			float oldfriction = localPlayer.slideFriction;
			localPlayer.isPlayerSliding = true;
			localPlayer.slideFriction = localPlayer.maxSlideFriction * 2f;
			while (localPlayer.isInHangarShipRoom)
			{
				if (Physics.Linecast(playerPosition, shipDoorPosition, StartOfRound.Instance.collidersAndRoomMask))
				{
					Vector3 val = Vector3.Normalize(shipDoorPosition - playerPosition);
					localPlayer.externalForces = val * 350f;
					Plugin.MoreLogs("applying external forces");
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
			localPlayer.isPlayerSliding = false;
			localPlayer.slideFriction = oldfriction;
		}

		internal static IEnumerator GhostGirlEnhanced(StartOfRound instance)
		{
			Plugin.MoreLogs("GhostGirl is being enhanced");
			if (RapidFire.startRapidFire)
			{
				yield break;
			}
			while (Plugin.instance.DressGirl.staringInHaunt)
			{
				float num = Random.Range(1f, 4f);
				if (!Plugin.instance.CodeSent && !DressGirl.girlIsChasing)
				{
					CodeHandling.HandleGhostCodeSending(instance);
					Plugin.instance.CodeSent = true;
				}
				else
				{
					Plugin.GC.LogInfo((object)$"ghostCode was just sent, waiting {num}");
					yield return (object)new WaitForSeconds(num);
					Plugin.instance.CodeSent = false;
				}
				if (RapidFire.LoopBreakers())
				{
					yield break;
				}
			}
			Plugin.MoreLogs("End of GhostGirlEnhanced Coroutine...");
		}
	}
	internal class Doors
	{
		internal static List<DoorLock> AllDoors = new List<DoorLock>();

		internal static bool CustomHauntRunning = false;

		internal static Random Rand = new Random();

		internal static void UpdateCacheDoorsList()
		{
			AllDoors = Object.FindObjectsOfType<DoorLock>().ToList();
		}

		internal static void OpenOrCloseALLDoors()
		{
			Plugin.MoreLogs("All doors changing state");
			for (int i = 0; i < AllDoors.Count; i++)
			{
				if (!((Object)(object)AllDoors[i] == (Object)null))
				{
					AllDoors[i].OpenOrCloseDoor(StartOfRound.Instance.localPlayerController);
				}
			}
			Plugin.MoreLogs($"All {AllDoors.Count} doors have been opened or closed");
		}

		internal static void OpenorClose1RandomDoor()
		{
			if (AllDoors.Count != 0)
			{
				int @int = NumberStuff.GetInt(0, AllDoors.Count);
				if (!((Object)(object)AllDoors[@int] == (Object)null))
				{
					AllDoors[@int].OpenOrCloseDoor(StartOfRound.Instance.localPlayerController);
					Plugin.MoreLogs("Opened or Closed one door");
				}
			}
		}

		internal static void LockorUnlockARandomDoor(bool stateLocked)
		{
			if (AllDoors.Count == 0)
			{
				return;
			}
			for (int i = 0; i < AllDoors.Count; i++)
			{
				int @int = NumberStuff.GetInt(0, AllDoors.Count);
				if (!((Object)(object)AllDoors[@int] == (Object)null))
				{
					if (AllDoors[@int].isLocked && stateLocked)
					{
						AllDoors[@int].UnlockDoorServerRpc();
						Plugin.MoreLogs("Unlocked random door");
						break;
					}
					if (!AllDoors[@int].isLocked && !stateLocked)
					{
						AllDoors[@int].LockDoor(30f);
						Plugin.MoreLogs("Locked random door");
						break;
					}
				}
			}
		}

		internal static void HauntDoors(int value)
		{
			if (AllDoors.Count == 0)
			{
				return;
			}
			float num = (float)value / 100f;
			Plugin.MoreLogs($"Attempting to Haunt {value}% of doors!");
			float num2 = ((value != 0) ? ((float)AllDoors.Count * num) : 1f);
			for (int i = 0; i < (int)num2; i++)
			{
				if (!((Object)(object)AllDoors[i] == (Object)null))
				{
					MonoBehaviour component = ((Component)AllDoors[i]).gameObject.GetComponent<MonoBehaviour>();
					component.StopAllCoroutines();
					component.StartCoroutine(CustomDoorHaunt(AllDoors[i]));
				}
			}
			Plugin.MoreLogs($"Attempted to haunt {(int)num2} doors!");
		}

		internal static IEnumerator CustomDoorHaunt(DoorLock thisDoor)
		{
			int times = Rand.Next(9);
			for (int i = 0; i < times; i++)
			{
				float num = ((!thisDoor.isDoorOpened && Rand.Next(100) >= 92) ? Random.Range(2f, 7f) : ((!thisDoor.isDoorOpened) ? Random.Range(0.2f, 1.7f) : Random.Range(0.15f, 0.3f)));
				yield return (object)new WaitForSeconds(num);
				thisDoor.OpenOrCloseDoor(StartOfRound.Instance.localPlayerController);
			}
			yield return (object)new WaitForSeconds(0.2f);
			if (thisDoor.isDoorOpened)
			{
				thisDoor.OpenOrCloseDoor(StartOfRound.Instance.localPlayerController);
			}
		}
	}
	public class GamePatchStuff
	{
		[HarmonyPatch(typeof(StartOfRound), "PassTimeToNextDay")]
		public class NextDayPatch
		{
			private static void Postfix()
			{
				Plugin.Spam("Next day detected!");
				OpenLibEvents.GhostCodesReset.Invoke();
			}
		}

		[HarmonyPatch(typeof(TerminalAccessibleObject), "Start")]
		public class TerminalAccessibleObject_StartPatch
		{
			private static void Postfix(TerminalAccessibleObject __instance)
			{
				CodeStuff.NewUsableCode(__instance);
			}
		}

		[HarmonyPatch(typeof(TerminalAccessibleObject), "OnDestroy")]
		public class TerminalAccessibleObject_DestroyPatch
		{
			private static void Postfix(TerminalAccessibleObject __instance)
			{
				CodeStuff.RemoveUsableCode(__instance);
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public class ApparatusPullPatch
		{
			private static bool instructionAdded;

			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> ApparatusPullPatch_Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				CodeInstruction myMethod = CodeInstruction.Call("ghostCodes.Patches.OpenLibEvents:GetInvoke", (Type[])null, (Type[])null);
				foreach (CodeInstruction instruction in instructions)
				{
					if (!instructionAdded)
					{
						Plugin.GC.LogInfo((object)"Custom Instruction added in DisconnectFromMachinery enumerator");
						yield return myMethod;
						yield return instruction;
						instructionAdded = true;
					}
					else
					{
						yield return instruction;
					}
				}
				Plugin.GC.LogInfo((object)"Transpiler Success! - Added ApparatusPull Invoke Event");
			}
		}

		[HarmonyPatch(typeof(DressGirlAI), "Start")]
		public class DressGirlExists : DressGirlAI
		{
			private static void Postfix(DressGirlAI __instance)
			{
				Plugin.instance.DressGirl = __instance;
				Plugin.MoreLogs("Dressgirl instance detected.");
			}

			protected override void __initializeVariables()
			{
				((DressGirlAI)this).__initializeVariables();
			}

			protected internal override string __getTypeName()
			{
				return "DressGirlExists";
			}
		}

		[HarmonyPatch(typeof(DressGirlAI), "SetHauntStarePosition")]
		public class StaringInHauntPatch : DressGirlAI
		{
			private static void Postfix(DressGirlAI __instance)
			{
				if (!(SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings"))
				{
					if ((Object)(object)__instance == (Object)null)
					{
						Plugin.GC.LogError((object)"Failed to grab dressgirl instance");
					}
					else if (__instance.staringInHaunt && Bools.CanSendCodes() && Bools.DressGirlStartCodes())
					{
						Plugin.instance.DressGirl = __instance;
						Plugin.GC.LogInfo((object)"The ghostGirl wants to play!");
						((MonoBehaviour)Plugin.instance.DressGirl).StartCoroutine(Coroutines.GhostGirlEnhanced(StartOfRound.Instance));
					}
				}
			}

			protected override void __initializeVariables()
			{
				((DressGirlAI)this).__initializeVariables();
			}

			protected internal override string __getTypeName()
			{
				return "StaringInHauntPatch";
			}
		}

		[HarmonyPatch(typeof(DressGirlAI), "FlipLightsBreakerServerRpc")]
		public class DressGirlRPCFix : DressGirlAI
		{
			private static void Postfix(DressGirlAI __instance)
			{
				if (SetupConfig.FixGhostGirlBreakers.Value)
				{
					Plugin.MoreLogs("Fixing lightbreaker Rpc");
					__instance.FlipLightsBreakerClientRpc();
				}
			}

			protected override void __initializeVariables()
			{
				((DressGirlAI)this).__initializeVariables();
			}

			protected internal override string __getTypeName()
			{
				return "DressGirlRPCFix";
			}
		}

		[HarmonyPatch(typeof(DressGirlAI), "BeginChasing")]
		public class TheChaseBegins
		{
			private static void Postfix(DressGirlAI __instance)
			{
				DressGirl.BreakersFix(__instance);
				if (!(SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings"))
				{
					RapidFire.startRapidFire = true;
					DressGirl.girlIsChasing = true;
					Plugin.MoreLogs("Girl has begun chasing, setting rapidFire to TRUE");
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Coroutines.RapidFireStart(StartOfRound.Instance));
				}
			}
		}

		[HarmonyPatch(typeof(DressGirlAI), "StopChasing")]
		public class TheChaseEnds : DressGirlAI
		{
			private static void Postfix()
			{
				if (!(SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings"))
				{
					RapidFire.startRapidFire = false;
					DressGirl.girlIsChasing = false;
					Plugin.MoreLogs("Chase sequence has ended.");
				}
			}

			protected override void __initializeVariables()
			{
				((DressGirlAI)this).__initializeVariables();
			}

			protected internal override string __getTypeName()
			{
				return "TheChaseEnds";
			}
		}

		[HarmonyPatch(typeof(VehicleController), "Awake")]
		public class GetVehicleController
		{
			private static void Postfix(VehicleController __instance)
			{
				Plugin.instance.Cruiser = __instance;
				Plugin.MoreLogs("Cruiser instance detected.");
			}
		}
	}
	internal class DressGirl : EnemyAI
	{
		internal static bool girlIsChasing;

		internal static void InitDressGirl()
		{
			Plugin.MoreLogs("Resetting DressGirl Variables...");
			girlIsChasing = false;
			Plugin.instance.DressGirl = null;
		}

		internal static void ChangeHauntedPlayer(PlayerControllerB player)
		{
			Plugin.instance.DressGirl.hauntingPlayer = player;
			((EnemyAI)Plugin.instance.DressGirl).ChangeOwnershipOfEnemy(Plugin.instance.DressGirl.hauntingPlayer.actualClientId);
			Plugin.instance.DressGirl.hauntingLocalPlayer = (Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)Plugin.instance.DressGirl.hauntingPlayer;
		}

		internal static void GGrapidFireChecks()
		{
			if (!((Object)(object)Plugin.instance.DressGirl == (Object)null) && SetupConfig.GhostCodesSettings.HauntingsMode)
			{
				Plugin.MoreLogs("Checking for rapidFire ending events");
				DancingCheck();
				ShowerStuff.CheckForHauntedPlayerInShower();
			}
		}

		private static void DancingCheck()
		{
			if (InteractionsConfig.EmoteStopChasing.Value > 1 || !girlIsChasing)
			{
				return;
			}
			if (!Bools.IsThisEffective(InteractionsConfig.EmoteStopChasing.Value))
			{
				Plugin.MoreLogs("Ghost girl doesn't want to see you dance!");
				return;
			}
			int numberPlayersEmoting = NumberStuff.GetNumberPlayersEmoting();
			int alivePlayers = NumberStuff.GetAlivePlayers();
			if (Bools.AreEnoughPlayersDancing(alivePlayers, numberPlayersEmoting, InteractionsConfig.EmoteStopChaseRequiredPlayers.Value))
			{
				Plugin.MoreLogs("Enough players emoting, stopping chase");
				StopGirlFromChasing();
			}
			else
			{
				Plugin.MoreLogs("You might wanna keep running...");
			}
		}

		internal static void StopGirlFromChasing()
		{
			if (!((Object)(object)Plugin.instance.DressGirl == (Object)null) && Plugin.instance.DressGirl.hauntingLocalPlayer)
			{
				Plugin.instance.DressGirl.StopChasing();
				Plugin.MoreLogs("initiating stop chase.");
			}
		}

		internal static void GirlDisappear()
		{
			if (!((Object)(object)Plugin.instance.DressGirl == (Object)null) && Plugin.instance.DressGirl.hauntingLocalPlayer)
			{
				Plugin.instance.DressGirl.DisappearDuringHaunt();
			}
		}

		internal static void EndAllGirlStuff()
		{
			if (girlIsChasing)
			{
				StopGirlFromChasing();
			}
			if (Plugin.instance.DressGirl.staringInHaunt)
			{
				GirlDisappear();
			}
		}

		internal static void BreakersFix(DressGirlAI instance)
		{
			if (SetupConfig.FixGhostGirlBreakers.Value && ((EnemyAI)instance).currentBehaviourStateIndex != 1 && instance.timesChased == 1 && Random.Range(0, 100) < SetupConfig.VanillaBreakersChance.Value)
			{
				instance.FlipLightsBreakerServerRpc();
				Plugin.GC.LogInfo((object)"patched updated breaker chance for vanilla");
			}
		}

		protected override void __initializeVariables()
		{
			((EnemyAI)this).__initializeVariables();
		}

		protected internal override string __getTypeName()
		{
			return "DressGirl";
		}
	}
	internal class InitPlugin
	{
		internal static void StartTheRound()
		{
			if (!(((Object)StartOfRound.Instance.currentLevel).name == "CompanyBuildingLevel") && !(StartOfRound.Instance.currentLevel.riskLevel == "Safe"))
			{
				InitMode();
				BaseReset();
				DressGirl.InitDressGirl();
				StartPlugin();
				Lights.InitLights();
			}
		}

		private static void StartPlugin()
		{
			if (Bools.ShouldInitPlugin())
			{
				((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Coroutines.InitEnumerator(StartOfRound.Instance));
			}
		}

		internal static void RestartPlugin()
		{
			if (Bools.ShouldInitPlugin())
			{
				((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Coroutines.RestartEnum(StartOfRound.Instance));
			}
		}

		internal static void InitMode()
		{
			Plugin.MoreLogs("Initializing ghostCodes mode settings");
			SetupConfig.GhostCodesSettings.UpdateSettings(StartOfRound.Instance.currentLevel);
		}

		internal static void BaseReset()
		{
			Bools.appPullInvoked = false;
			Plugin.instance.CodeSent = false;
			RapidFire.startRapidFire = false;
			Coroutines.rapidFireStart = false;
			Coroutines.codeLooperStarted = false;
			Plugin.instance.MaxSanity = 0f;
			Plugin.instance.GroupSanity = 0f;
			GetPlayersAtStart();
			Plugin.instance.CodeCount = 0;
			Plugin.instance.RandCodeAmount = 0;
			ShipStuff.ResetLever();
			TerminalAdditions.RestoreCreds();
		}

		internal static void CodesInit()
		{
			Plugin.MoreLogs("Initializing GhostCode core variables");
			Bools.endAllCodes = false;
			TerminalAdditions.ResetBools();
			Doors.UpdateCacheDoorsList();
			Plugin.instance.RandCodeAmount = NumberStuff.GetInt(SetupConfig.MinCodes.Value, SetupConfig.MaxCodes.Value);
			if (SetupConfig.SoloAssist.Value)
			{
				InsanityStuff.InitsoloAssist();
			}
		}

		internal static void GetPlayersAtStart()
		{
			Plugin.instance.playersAtStart = 0;
			Plugin.instance.players = StartOfRound.Instance.allPlayerScripts;
			for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Count(); i++)
			{
				if (StartOfRound.Instance.allPlayerScripts[i].isPlayerControlled)
				{
					Plugin.instance.playersAtStart++;
				}
			}
			Plugin.MoreLogs($"Players at Start: {Plugin.instance.playersAtStart}");
			if (Plugin.instance.playersAtStart > 1)
			{
				Plugin.MoreLogs("SoloAssist Buff disabled, more than one player detected.");
			}
		}
	}
	internal class InsanityStuff
	{
		internal static Dictionary<string, ConfigEntry<int>> stageKeyVal = new Dictionary<string, ConfigEntry<int>>();

		internal static Stages stage1 = SetStageInfo("Stage 1", 0, 6, SoloAssistConfig.S1percent, SoloAssistConfig.S1inside, SoloAssistConfig.S1outside);

		internal static Stages stage2 = SetStageInfo("Stage 2", 7, 10, SoloAssistConfig.S2percent, SoloAssistConfig.S2inside, SoloAssistConfig.S2outside);

		internal static Stages stage3 = SetStageInfo("Stage 3", 11, 15, SoloAssistConfig.S3percent, SoloAssistConfig.S3inside, SoloAssistConfig.S3outside);

		internal static List<Stages> allStages = new List<Stages>();

		public static void ApplyInsanityMode(StartOfRound instance, ref float randomWaitNum)
		{
			GetAllSanity();
			float groupSanity = Plugin.instance.GroupSanity;
			float maxSanity = Plugin.instance.MaxSanity;
			if (RapidFire.startRapidFire && SetupConfig.RapidFireMaxHours.Value > 0)
			{
				Plugin.GC.LogInfo((object)"max insanity level reached!!! startRapidFire TRUE");
				((MonoBehaviour)instance).StartCoroutine(Coroutines.RapidFireStart(instance));
			}
			else
			{
				AdjustWaitNum(groupSanity, maxSanity, ref randomWaitNum);
				Plugin.MoreLogs($"waiting {randomWaitNum}");
			}
		}

		internal static void InitsoloAssist()
		{
			allStages.Clear();
			allStages.Add(stage1);
			allStages.Add(stage2);
			allStages.Add(stage3);
		}

		internal static void GetAllSanity()
		{
			Plugin.instance.GroupSanity = 0f;
			Plugin.instance.MaxSanity = 0f;
			for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Count(); i++)
			{
				if (!StartOfRound.Instance.allPlayerScripts[i].isPlayerDead && StartOfRound.Instance.allPlayerScripts[i].isPlayerControlled)
				{
					Plugin.instance.GroupSanity += StartOfRound.Instance.allPlayerScripts[i].insanityLevel;
					Plugin.instance.MaxSanity += StartOfRound.Instance.allPlayerScripts[i].maxInsanityLevel;
				}
			}
			float groupSanity = Plugin.instance.GroupSanity;
			ApplyBonuses(ref groupSanity, Plugin.instance.MaxSanity);
			Plugin.instance.GroupSanity = groupSanity;
			CheckSanityRapidFire();
		}

		private static void CheckSanityRapidFire()
		{
			if (SetupConfig.RapidFireMaxHours.Value >= 1)
			{
				if (Mathf.Round(Plugin.instance.GroupSanity) >= Mathf.Round(Plugin.instance.MaxSanity) * ((float)InsanityConfig.SanityMaxLevel.Value / 100f))
				{
					RapidFire.startRapidFire = true;
					Plugin.MoreLogs("max sanity hit, CheckSanityRapidFire()");
					Plugin.MoreLogs($"Group Sanity Level: {Mathf.Round(Plugin.instance.GroupSanity)}");
					Plugin.MoreLogs($"Group Max Insanity level: {Mathf.Round(Plugin.instance.MaxSanity)}");
				}
				else
				{
					RapidFire.startRapidFire = false;
					Plugin.MoreLogs($"Group Sanity Level: {Mathf.Round(Plugin.instance.GroupSanity)}");
					Plugin.MoreLogs($"Group Max Insanity level: {Mathf.Round(Plugin.instance.MaxSanity)}");
				}
			}
		}

		private static float AdjustWaitNum(float groupSanity, float maxSanity, ref float randomWaitNum)
		{
			if (SetupConfig.RapidFireMaxHours.Value < 1 && Mathf.Round(groupSanity) >= Mathf.Round(maxSanity) * ((float)InsanityConfig.SanityMaxLevel.Value / 100f))
			{
				randomWaitNum *= (float)InsanityConfig.WaitMaxLevel.Value / 100f;
				Plugin.MoreLogs("Max Insanity Level reached (rapidFire disabled)");
				return randomWaitNum;
			}
			if (Mathf.Round(groupSanity) >= Mathf.Round(maxSanity) * ((float)InsanityConfig.SanityLevel3.Value / 100f))
			{
				randomWaitNum *= (float)InsanityConfig.WaitLevel3.Value / 100f;
				Plugin.MoreLogs("insanity level 3 reached");
				return randomWaitNum;
			}
			if (Mathf.Round(groupSanity) >= Mathf.Round(maxSanity) * ((float)InsanityConfig.SanityLevel2.Value / 100f))
			{
				randomWaitNum *= (float)InsanityConfig.WaitLevel2.Value / 100f;
				Plugin.MoreLogs("insanity level 2 reached");
				return randomWaitNum;
			}
			if (Mathf.Round(groupSanity) >= Mathf.Round(maxSanity) * ((float)InsanityConfig.SanityLevel1.Value / 100f))
			{
				randomWaitNum *= (float)InsanityConfig.WaitLevel1.Value / 100f;
				Plugin.MoreLogs("insanity level 1 reached");
				return randomWaitNum;
			}
			Plugin.MoreLogs("insanity levels low");
			return randomWaitNum;
		}

		private static Tuple<float, float> ApplyBonuses(ref float groupSanity, float maxSanity)
		{
			Plugin.MoreLogs($"Applying bonuses & debuffs\nplayersAtStart = {Plugin.instance.playersAtStart}");
			if (SetupConfig.SoloAssist.Value && Plugin.instance.playersAtStart == 1)
			{
				Plugin.MoreLogs("SoloAssist Activated");
				groupSanity = SoloAssist(ref groupSanity, maxSanity);
			}
			if (InsanityConfig.DeathBonus.Value > 0)
			{
				Plugin.MoreLogs("Death Bonus Activated");
				groupSanity = ApplyDeathBonus(ref groupSanity, maxSanity);
			}
			if (InsanityConfig.GhostGirlBonus.Value > 0 && (Object)(object)Plugin.instance.DressGirl != (Object)null)
			{
				Plugin.MoreLogs("Ghost Girl Bonus Activated");
				groupSanity = ApplyGirlBonus(ref groupSanity, maxSanity);
			}
			if (InsanityConfig.EmoteBuff.Value > 1)
			{
				Plugin.MoreLogs("Emote Buff Activated");
				groupSanity = EmoteBuff(ref groupSanity);
			}
			return Tuple.Create(groupSanity, maxSanity);
		}

		private static float ApplyDeathBonus(ref float groupSanity, float maxSanity)
		{
			int num = Plugin.instance.players.Count((PlayerControllerB player) => player.isPlayerDead && player.isPlayerControlled);
			for (int i = 0; i < num; i++)
			{
				float num2 = groupSanity * ((float)InsanityConfig.DeathBonus.Value / 100f);
				Plugin.MoreLogs($"Dead Player detected. Adding {num2} to group sanity");
				groupSanity = ApplyBonus(groupSanity, maxSanity, num2, (float _) => true);
			}
			Plugin.MoreLogs("Death bonus applied to insanity values");
			return groupSanity;
		}

		private static float ApplyGirlBonus(ref float groupSanity, float maxSanity)
		{
			Plugin.MoreLogs("Ghost Girl Bonus applied to insanity values");
			float num = groupSanity * ((float)InsanityConfig.GhostGirlBonus.Value / 100f);
			Plugin.MoreLogs($"Ghost Girl Bonus adding {num} to group sanity");
			groupSanity = ApplyBonus(groupSanity, maxSanity, num, (float _) => true);
			return groupSanity;
		}

		private static float ApplyBonus(float groupSanity, float maxSanity, float bonusValue, Func<float, bool> condition)
		{
			if (condition(groupSanity) && maxSanity >= groupSanity + bonusValue)
			{
				groupSanity += bonusValue;
			}
			return groupSanity;
		}

		private static Stages SetStageInfo(string name, int startHour, int endHour, ConfigEntry<int> percentKey, ConfigEntry<int> insideKey, ConfigEntry<int> outsideKey)
		{
			return new Stages
			{
				Name = name,
				StartHour = startHour,
				EndHour = endHour,
				PercentKey = percentKey,
				InsideKey = insideKey,
				OutsideKey = outsideKey
			};
		}

		private static float EmoteBuff(ref float groupSanity)
		{
			if (InsanityConfig.EmoteBuff.Value > 0)
			{
				PlayerControllerB[] players = Plugin.instance.players;
				foreach (PlayerControllerB val in players)
				{
					if (!val.isPlayerDead && val.performingEmote)
					{
						float num = groupSanity * ((float)InsanityConfig.EmoteBuff.Value / 100f);
						Plugin.MoreLogs($"Emote buff removing {num} from group sanity");
						ApplySanityDebuff(ref groupSanity, num);
					}
				}
			}
			return groupSanity;
		}

		private static float SoloAssist(ref float groupSanity, float maxSanity)
		{
			if (SetupConfig.SoloAssist.Value && Plugin.instance.playersAtStart == 1)
			{
				int hour = TimeOfDay.Instance.hour;
				Plugin.GC.LogInfo((object)$"Hour: {hour}");
				foreach (Stages allStage in allStages)
				{
					if (Bools.IsHourInRange(hour, allStage.StartHour, allStage.EndHour))
					{
						float num = maxSanity * ((float)allStage.PercentKey.Value / 100f);
						float num2 = (Bools.IsInsideFactory() ? allStage.InsideKey.Value : allStage.OutsideKey.Value);
						Plugin.MoreLogs($"threshold: {num}, debuffAmount: {num2}, GroupSanity: {groupSanity}");
						if (groupSanity >= num)
						{
							ApplySanityDebuff(ref groupSanity, num2);
							Plugin.MoreLogs(allStage.Name + " detected and debuffs applied");
						}
						else
						{
							Plugin.MoreLogs("No solo assist buff added.");
						}
						break;
					}
				}
			}
			return groupSanity;
		}

		private static void ApplySanityDebuff(ref float groupSanity, float debuffAmount)
		{
			if (groupSanity > debuffAmount)
			{
				groupSanity -= debuffAmount;
				Plugin.GC.LogInfo((object)$"Subtracted {debuffAmount} from Group Sanity Level.");
			}
			else
			{
				groupSanity = 0f;
				Plugin.GC.LogInfo((object)$"Subtracted {debuffAmount} from Group Sanity Level which set value to 0.");
			}
		}
	}
	internal class Stages
	{
		internal string Name { get; set; }

		internal int StartHour { get; set; }

		internal int EndHour { get; set; }

		internal ConfigEntry<int> PercentKey { get; set; }

		internal ConfigEntry<int> InsideKey { get; set; }

		internal ConfigEntry<int> OutsideKey { get; set; }
	}
	internal class Lights
	{
		internal static bool activeLightsColor = false;

		internal static bool warningLights = false;

		internal static List<Light> allLightsFixed = new List<Light>();

		internal static List<Animator> allPoweredLights = new List<Animator>();

		internal static bool activeFlicker = false;

		internal static void InitLights()
		{
			activeLightsColor = false;
			warningLights = false;
			activeFlicker = false;
			allLightsFixed = new List<Light>();
			allPoweredLights = new List<Animator>();
			if (RoundManager.Instance.allPoweredLightsAnimators.Count == 0)
			{
				Plugin.WARNING("INTERIOR HAS NO POWERED LIGHT ANIMATORS!!!");
				Plugin.WARNING("INTERIOR HAS NO POWERED LIGHT ANIMATORS!!!");
				Plugin.WARNING("INTERIOR HAS NO POWERED LIGHT ANIMATORS!!!");
				Plugin.WARNING("INTERIOR HAS NO POWERED LIGHT ANIMATORS!!!");
				GameObject val = GameObject.Find("Systems/LevelGeneration");
				if ((Object)(object)val != (Object)null)
				{
					allLightsFixed = val.GetComponentsInChildren<Light>(true).ToList();
					Plugin.Spam($"Got [ {allLightsFixed.Count} ] lights from dungeon root!");
				}
				else
				{
					Plugin.WARNING("Unable to get dungeonRoot lights!");
				}
			}
			foreach (Animator allPoweredLightsAnimator in RoundManager.Instance.allPoweredLightsAnimators)
			{
				if ((Object)(object)((Component)allPoweredLightsAnimator).GetComponentInChildren<Light>(true) != (Object)null)
				{
					allPoweredLights.Add(allPoweredLightsAnimator);
				}
				List<Light> collection = ((Component)allPoweredLightsAnimator).GetComponentsInChildren<Light>(true).ToList();
				allLightsFixed.AddRange(collection);
			}
		}

		internal static void GGFlashlight()
		{
			NetHandler.Instance.FlickerLightsServerRpc(flickerFlash: true, disableFlash: false);
			Plugin.MoreLogs("nosfaratu is that you??");
		}

		internal static void FlipLights()
		{
			Plugin.MoreLogs("who turned out the lights??");
			NetHandler.Instance.FacilityBreakerServerRpc();
		}

		internal static IEnumerator ColorTransition(Light light, Color newColor, float duration)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Color init = light.color;
			float counter = 0f;
			while (counter < duration)
			{
				counter += Time.deltaTime;
				float num = Mathf.Clamp01(counter / duration);
				light.color = Color.Lerp(init, newColor, num);
				yield return null;
			}
		}

		internal static IEnumerator PoweredLightsColor(PlayerControllerB HauntedPlayer)
		{
			if (activeLightsColor || SetupConfig.RapidLightsColorValue.Value.ToLower() == "nochange" || SetupConfig.RapidLightsColorValue.Value.ToLower() == "default" || SetupConfig.RapidLightsColorValue.Value.Length == 0)
			{
				yield break;
			}
			if (allLightsFixed.Count == 0)
			{
				Plugin.WARNING("NO LIGHTS DETECTED!");
				Plugin.WARNING("NO LIGHTS DETECTED!");
				Plugin.WARNING("NO LIGHTS DETECTED!");
				yield break;
			}
			activeLightsColor = true;
			Plugin.Spam($"allLightsFixed Count: {allLightsFixed.Count}");
			Dictionary<Light, Color> allLightsColors = new Dictionary<Light, Color>();
			Color32 val = Color32.op_Implicit(Misc.HexToColor(SetupConfig.RapidLightsColorValue.Value));
			for (int i = 0; i < allLightsFixed.Count; i++)
			{
				if (!allLightsColors.ContainsKey(allLightsFixed[i]))
				{
					allLightsColors.Add(allLightsFixed[i], allLightsFixed[i].color);
				}
				((MonoBehaviour)StartOfRound.Instance).StartCoroutine(ColorTransition(allLightsFixed[i], Color32.op_Implicit(val), 5f));
			}
			warningLights = true;
			Plugin.MoreLogs("Alarm lights set");
			while (warningLights && Bools.PlayerStillAliveAndControlled(HauntedPlayer))
			{
				yield return (object)new WaitForEndOfFrame();
			}
			if (warningLights)
			{
				warningLights = false;
			}
			yield return (object)new WaitForSeconds(1f);
			for (int j = 0; j < allLightsFixed.Count; j++)
			{
				if (allLightsColors.TryGetValue(allLightsFixed[j], out var value))
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(ColorTransition(allLightsFixed[j], value, 3f));
				}
				else
				{
					Plugin.WARNING("Unable to get original light color!");
				}
			}
			Plugin.MoreLogs("Lights set back to normal");
			activeLightsColor = false;
		}

		internal static IEnumerator WhileLightsFlicker()
		{
			if (Bools.lightsFlickering || warningLights)
			{
				while (RapidFire.startRapidFire && !StartOfRound.Instance.localPlayerController.isPlayerDead && !Bools.endAllCodes)
				{
					yield return (object)new WaitForEndOfFrame();
				}
				Plugin.Spam("End of LightsFlicker Coroutine!");
				NetHandler.Instance.EndRapidFireLightsServerRpc();
			}
		}

		internal static IEnumerator FlickerPoweredLights(PlayerControllerB HauntedPlayer)
		{
			if (Bools.lightsFlickering)
			{
				yield break;
			}
			if (allPoweredLights.Count == 0)
			{
				Plugin.WARNING("No powered lights!");
				Plugin.WARNING("No powered lights!");
				Plugin.WARNING("No powered lights!");
				yield break;
			}
			Bools.lightsFlickering = true;
			Plugin.Spam("FlickerPoweredLights");
			while (Bools.lightsFlickering && Bools.PlayerStillAliveAndControlled(HauntedPlayer))
			{
				int num = 0;
				int maxLights = ((allPoweredLights.Count > 200) ? 85 : ((allPoweredLights.Count > 100) ? 50 : ((allPoweredLights.Count <= 50) ? 9 : 15)));
				foreach (Animator allPoweredLight in allPoweredLights)
				{
					if (num < maxLights)
					{
						allPoweredLight.SetTrigger("Flicker");
						num++;
					}
					else
					{
						yield return (object)new WaitForSeconds(0.05f);
						num = 0;
					}
				}
				yield return (object)new WaitForSeconds(Random.Range(SetupConfig.RapidLightsMin.Value, SetupConfig.RapidLightsMax.Value));
			}
			if (Bools.lightsFlickering)
			{
				Bools.lightsFlickering = false;
			}
			Plugin.Spam("EndAlarmLights");
			yield return (object)new WaitForSeconds(0.3f);
			RoundManager.Instance.SwitchPower(true);
			Bools.lightsFlickering = false;
		}
	}
	internal class Mines
	{
		internal static void HandleMineBoom()
		{
			if (CodeStuff.myTerminalObjects.Count == 0)
			{
				return;
			}
			List<TerminalAccessibleObject> list = CodeStuff.myTerminalObjects.FindAll((TerminalAccessibleObject m) => (Object)(object)((Component)m).gameObject.GetComponent<Landmine>() != (Object)null && !((Component)m).gameObject.GetComponent<Landmine>().hasExploded);
			if (list.Count > 0)
			{
				int index = NumberStuff.Rand.Next(list.Count);
				Landmine component = ((Component)list[index]).gameObject.GetComponent<Landmine>();
				if (!component.hasExploded)
				{
					component.ExplodeMineClientRpc();
					component.ExplodeMineServerRpc();
					Plugin.MoreLogs("WHAT THE FUUUUUU-");
				}
			}
			else
			{
				Plugin.Spam("No landmines to go kaboom");
			}
		}
	}
	internal class Misc
	{
		internal static List<PlayerControllerB> GetAllLivingPlayers()
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			Plugin.MoreLogs("Getting alive players");
			PlayerControllerB[] players = Plugin.instance.players;
			foreach (PlayerControllerB val in players)
			{
				if (!val.isPlayerDead && val.isPlayerControlled)
				{
					list.Add(val);
				}
			}
			return list;
		}

		internal static void LogTime()
		{
			string text = ((TMP_Text)HUDManager.Instance.clockNumber).text;
			string text2 = text.Replace("\n", "").Replace("\r", "");
			Plugin.MoreLogs("TIME: " + text2);
		}

		internal static bool TryGetPlayerFromID(ulong playerID, out PlayerControllerB thePlayer)
		{
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.actualClientId == playerID)
				{
					thePlayer = val;
					return true;
				}
			}
			thePlayer = null;
			return false;
		}
	}
	public class NetHandler : NetworkBehaviour
	{
		public static NetHandler Instance { get; private set; }

		[ServerRpc(RequireOwnership = false)]
		public void BreatheOnWalkiesServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2364017171u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2364017171u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !((Object)(object)Plugin.instance.DressGirl == (Object)null))
				{
					Plugin.MoreLogs("SERVER: ghost breathing on all walkies");
					BreatheOnWalkiesClientRpc();
				}
			}
		}

		[ClientRpc]
		public void BreatheOnWalkiesClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3488792323u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3488792323u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					WalkieStuff.BreatheOnWalkiesFunc();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void GarbleWalkiesServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1741569032u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1741569032u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					Plugin.MoreLogs("SERVER: garbling all walkies");
					GarbleWalkiesClientRpc();
				}
			}
		}

		[ClientRpc]
		public void GarbleWalkiesClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1040546466u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1040546466u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					WalkieStuff.GarbleAllWalkiesFunc();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ChangeDressGirlToPlayerServerRpc(ulong playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3358268268u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3358268268u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !((Object)(object)Plugin.instance.DressGirl == (Object)null))
				{
					Plugin.MoreLogs($"SERVER: Changing dressgirl to {playerID}");
					ChangeDressGirlToPlayerClientRpc(playerID);
				}
			}
		}

		[ClientRpc]
		public void ChangeDressGirlToPlayerClientRpc(ulong playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2732348508u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2732348508u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				PlayerControllerB thePlayer;
				if ((Object)(object)Plugin.instance.DressGirl == (Object)null)
				{
					Plugin.MoreLogs("DressGirl instance is null");
				}
				else if (Misc.TryGetPlayerFromID(playerID, out thePlayer))
				{
					Plugin.instance.DressGirl.switchedHauntingPlayer = true;
					((MonoBehaviour)Plugin.instance.DressGirl).StartCoroutine(Plugin.instance.DressGirl.setSwitchingHauntingPlayer());
					DressGirl.ChangeHauntedPlayer(thePlayer);
					Plugin.MoreLogs($"Changing haunted player to {playerID}");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void FlickerLightsServerRpc(bool flickerFlash, bool disableFlash)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1489712227u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flickerFlash, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref disableFlash, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1489712227u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					FlickerLightsClientRpc(flickerFlash, disableFlash);
				}
			}
		}

		[ClientRpc]
		public void FlickerLightsClientRpc(bool flickerFlash, bool disableFlash)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(976836047u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flickerFlash, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref disableFlash, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 976836047u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					RoundManager.Instance.FlickerLights(flickerFlash, disableFlash);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void StartRapidFireLightsServerRpc(ulong clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2243429670u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2243429670u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					StartRapidFireLightsClientRpc(clientID);
				}
			}
		}

		[ClientRpc]
		public void StartRapidFireLightsClientRpc(ulong clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3441652457u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientID);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3441652457u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && Misc.TryGetPlayerFromID(clientID, out var thePlayer))
				{
					Plugin.Spam("Starting RapidFireLight sequence from - " + thePlayer.playerUsername);
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Lights.PoweredLightsColor(thePlayer));
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Lights.FlickerPoweredLights(thePlayer));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EndRapidFireLightsServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(801715303u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 801715303u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					EndRapidFireLightsClientRpc();
				}
			}
		}

		[ClientRpc]
		public void EndRapidFireLightsClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1901599655u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1901599655u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					Bools.lightsFlickering = false;
					Lights.warningLights = false;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void FacilityBreakerServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1805593341u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1805593341u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					FacilityBreakerClientRpc();
				}
			}
		}

		[ClientRpc]
		public void FacilityBreakerClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1895890339u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1895890339u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			BreakerBox val3 = Object.FindObjectOfType<BreakerBox>();
			if ((Object)(object)val3 != (Object)null)
			{
				Plugin.GC.LogInfo((object)"flipping facility breaker for this client");
				if (val3.isPowerOn)
				{
					val3.SetSwitchesOff();
					RoundManager.Instance.TurnOnAllLights(false);
					GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(0.2f, true);
				}
				else
				{
					val3.SwitchBreaker(true);
					RoundManager.Instance.TurnOnAllLights(true);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ShockTerminalSoundServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1506833215u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1506833215u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ShockTerminalSoundClientRpc();
				}
			}
		}

		[ClientRpc]
		public void ShockTerminalSoundClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(711897171u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 711897171u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					SoundSystem.PlayTerminalSound(TerminalAdditions.Shock);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BatteryAdjustSoundServerRpc(int clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1275206633u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1275206633u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					BatteryAdjustSoundClientRpc(clientID);
				}
			}
		}

		[ClientRpc]
		public void BatteryAdjustSoundClientRpc(int clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(224827583u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 224827583u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				int clientID2 = clientID;
				PlayerControllerB val3 = Misc.GetAllLivingPlayers().Find((PlayerControllerB x) => (int)x.actualClientId == clientID2);
				val3.itemAudio.PlayOneShot(Items.Adjuster, 0.8f);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BatteryAdjustServerRpc(int clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (mi

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.InteropServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using System.Text; using BepInEx; using BepInEx.Configuration; using BepInEx.Logging; using GameNetcodeStuff; using HarmonyLib; using LethalConfig; using Microsoft.CodeAnalysis; using OpenLib; using OpenLib.Common; using OpenLib.Compat; using OpenLib.ConfigManager; using OpenLib.CoreMethods; using OpenLib.Events; using TMPro; using TerminalStuff; using Unity.Netcode; using UnityEngine; using UnityEngine.Events; using UnityEngine.InputSystem; using UnityEngine.InputSystem.Controls; using UnityEngine.UI; using com.github.zehsteam.ToilHead.MonoBehaviours; using ghostCodes.Compatibility; using ghostCodes.Configs; using ghostCodes.Interactions; using ghostCodes.NetcodePatcher; using ghostCodes.Patches; using ghostCodes.PluginStuff; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: AssemblyTitle("ghostcodes")] [assembly: AssemblyDescription("https://github.com/darmuh/ghostcodes")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("ghostcodes")] [assembly: AssemblyCopyright("")] [assembly: AssemblyTrademark("")] [assembly: ComVisible(false)] [assembly: Guid("d54996ea-9c7b-47cf-b5cb-fdfe2c657f71")] [assembly: AssemblyFileVersion("2.5.2")] [assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("2.5.2.0")] [module: UnverifiableCode] [module: RefSafetyRules(11)] [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.Module, AllowMultiple = false, Inherited = false)] internal sealed class RefSafetyRulesAttribute : Attribute { public readonly int Version; public RefSafetyRulesAttribute(int P_0) { Version = P_0; } } [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] internal sealed class IgnoresAccessChecksToAttribute : Attribute { public IgnoresAccessChecksToAttribute(string assemblyName) { } } } namespace ghostCodes { internal class Blastdoors { internal static void HandleHungryDoor(int randomObjectNum, StartOfRound instance) { if (CodeStuff.myTerminalObjects.Count != 0) { if (((Object)((Component)CodeStuff.myTerminalObjects[randomObjectNum]).gameObject).name.Contains("BigDoor")) { Plugin.MoreLogs("The door is hungy"); ((MonoBehaviour)instance).StartCoroutine(HungryDoor(randomObjectNum)); } else { CodeStuff.myTerminalObjects[randomObjectNum].CallFunctionFromTerminal(); } } } private static IEnumerator HungryDoor(int randomObjectNum) { float intervalTime = Random.Range(0.2f, 0.7f); int numBites = Random.Range(3, 9); if (((Object)((Component)CodeStuff.myTerminalObjects[randomObjectNum]).gameObject).name.Contains("BigDoor")) { int j; for (j = 0; j < numBites; j++) { CodeStuff.myTerminalObjects[randomObjectNum].CallFunctionFromTerminal(); yield return (object)new WaitForSeconds(intervalTime); j++; } } } } internal class Teleporters { internal static void InteractWithAnyTP(int tpNum) { if (tpNum == 0 && (Object)(object)Teleporter.NormalTP != (Object)null) { Plugin.MoreLogs("Messing with NormalTP"); Teleporter.NormalTP.PressTeleportButtonServerRpc(); Plugin.MoreLogs("NormalTP button pressed via ServerRpc"); } else if (tpNum == 1 && (Object)(object)Teleporter.InverseTP != (Object)null) { Plugin.MoreLogs("Messing with InverseTP"); Teleporter.InverseTP.PressTeleportButtonServerRpc(); Plugin.MoreLogs("InverseTP button pressed via ServerRpc"); } } } internal class TerminalAdditions { internal static TerminalNode rebootNode; internal static bool rebootCommandExpired = false; internal static int rebootCount; internal static int rebootTime; internal static int deathNoteStrikes = 0; public static bool isTerminalRebooting = false; internal static bool spookyColors = false; internal static bool credsCorrupted = false; internal static int OriginalCreds = 0; internal static Color OriginalColor; internal static string rebootConfirmName = "ghostCodes_confirm_reboot"; internal static string rebootDenyName = "ghostCodes_deny_reboot"; internal static AudioClip Shock; internal static AudioClip Reboot; internal static AudioClip Success; internal static void ResetBools() { isTerminalRebooting = false; rebootCommandExpired = false; spookyColors = false; rebootCount = 0; deathNoteStrikes = 0; } internal static IEnumerator RebootTerminalSpooky() { if (isTerminalRebooting) { yield break; } Plugin.MoreLogs("Start of spooky terminal reboot coroutine."); SoundSystem.PlayTerminalSound(Reboot); yield return (object)new WaitForSeconds(1f); SetTerminalText(StringStuff.reboot_3); yield return (object)new WaitForSeconds(1f); SetTerminalText(StringStuff.reboot_2); yield return (object)new WaitForSeconds(1f); SetTerminalText(StringStuff.reboot_1); Plugin.instance.Terminal.QuitTerminal(true); yield return (object)new WaitForEndOfFrame(); IsTerminalUsable(state: false); float originalAlpha = ((TMP_Text)Plugin.instance.Terminal.topRightText).alpha; ((TMP_Text)Plugin.instance.Terminal.topRightText).alpha = 0f; ((Component)Plugin.instance.Terminal.terminalUIScreen).gameObject.SetActive(true); Plugin.instance.Terminal.screenText.caretPosition = Plugin.instance.Terminal.screenText.text.Length; Bools.endAllCodes = true; isTerminalRebooting = true; yield return (object)new WaitForSeconds(1f); SetTerminalText(StringStuff.reboot_progress_1); ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(RebootLoadingTextLoop()); yield return (object)new WaitForSeconds((float)rebootTime); isTerminalRebooting = false; DressGirl.StopGirlFromChasing(); Bools.endAllCodes = false; ((TMP_Text)Plugin.instance.Terminal.topRightText).alpha = originalAlpha; Plugin.instance.Terminal.terminalAudio.Stop(); SoundSystem.PlayTerminalSound(Success); SetTerminalText("\n\n\n\n\n\n\n\n\n\t\t>>Reboot <color=#ebe334>Complete.</color><<\n\n\n\n"); IsTerminalUsable(state: true); InitPlugin.RestartPlugin(); if (InteractionsConfig.TerminalRebootUses.Value > 0) { if (rebootCount >= InteractionsConfig.TerminalRebootUses.Value) { rebootCommandExpired = true; } else { rebootCount++; } } } internal static IEnumerator RebootLoadingTextLoop() { while (isTerminalRebooting) { int @int = NumberStuff.GetInt(0, StringStuff.rebootProgress.Count); SetTerminalText("<color=#b81b1b>" + StringStuff.rebootProgress[@int] + "</color>"); yield return (object)new WaitForSeconds(0.1f); } } internal static void SetTerminalText(string newText) { Plugin.instance.Terminal.currentText = newText; Plugin.instance.Terminal.screenText.text = newText; } internal static void IsTerminalUsable(bool state) { Plugin.instance.Terminal.terminalTrigger.interactable = state; Plugin.MoreLogs($"terminal interactable set to {state}"); } internal static string HandleRebootNode() { Plugin.MoreLogs("Handling reboot node"); if (StartOfRound.Instance.inShipPhase) { return "\n\n\n\n\n\n\t\tTerminal reboot is not necessary... (in orbit)\r\n"; } int @int = NumberStuff.GetInt(0, 100); if (InteractionsConfig.TerminalReboot.Value < @int || rebootCommandExpired) { string result = "\n\n\n\n\n\n\t\tTerminal reboot has failed...\r\n"; rebootCommandExpired = true; return result; } ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(RebootTerminalSpooky()); Plugin.MoreLogs("rebooting terminal"); return ""; } internal static string AskTerminalReboot() { rebootTime = NumberStuff.GetInt(30, 88); return $"You have requested to reboot the terminal.\nTotal time to reboot is {rebootTime} seconds...\n\nPlease CONFIRM or DENY.\n\n"; } internal static void CreateAllNodes() { if (ModConfig.ModNetworking.Value) { CreateRebootNode(); CreateDeathNoteNode(); } } private static void CreateRebootNode() { if (InteractionsConfig.TerminalReboot.Value >= 1) { rebootNode = AddingThings.AddNodeManual("ghostCodes_reboot", "reboot", (Func<string>)AskTerminalReboot, true, 1, ConfigSetup.defaultListing, 0, (Func<string>)HandleRebootNode, (Func<string>)null, "", "Terminal Reboot has been cancelled.\r\n\r\n", false, 1, "", false, ""); } } private static void CreateDeathNoteNode() { if (InteractionsConfig.DeathNote.Value >= 1 && StartOfRound.Instance.allPlayerScripts.Any((PlayerControllerB x) => x.isPlayerControlled && (Object)(object)x != (Object)(object)StartOfRound.Instance.localPlayerController)) { Plugin.Spam("Adding deathnotemenu!"); DeathNote.DeathNoteMenu = AddingThings.AddNodeManual("DeathNoteMenu", "leave me alone", (Func<string>)OpenDeathNote, true, 0, ConfigSetup.defaultListing, 0, (Func<string>)null, (Func<string>)null, "", "", false, 1, "", false, ""); } } internal static string OpenDeathNote() { if (!CanUseDeathNote()) { return "Chill out, no one is after you lol\r\n\r\n"; } if (Plugin.instance.TerminalStuff) { TerminalStuff.StopShortCuts(stop: true); } DeathNote.currentPage = 1; ((MonoBehaviour)Plugin.instance.Terminal).StartCoroutine(DeathNote.MenuStart()); return DeathNote.GetPlayerList(0, 10, ref DeathNote.currentPage); } internal static bool CanUseDeathNote() { if ((Object)(object)Plugin.instance.DressGirl == (Object)null) { return false; } if (!Plugin.instance.DressGirl.hauntingLocalPlayer) { return false; } if (!StartOfRound.Instance.allPlayerScripts.Any((PlayerControllerB x) => x.isPlayerControlled && (Object)(object)x != (Object)(object)StartOfRound.Instance.localPlayerController)) { return false; } if (StartOfRound.Instance.shipIsLeaving) { return false; } return true; } internal static void DeathNoteFail() { if (InteractionsConfig.DeathNoteFailChase.boolValue && !((Object)(object)Plugin.instance.DressGirl == (Object)null)) { Plugin.MoreLogs("death note failed, beginning ghost girl chase"); Plugin.instance.DressGirl.BeginChasing(); } } internal static void CorruptedCredits(bool state) { //IL_00b5: 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_0035: 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) if (state) { Plugin.Spam("Credits corrupted!"); OriginalCreds = Plugin.instance.Terminal.groupCredits; OriginalColor = ((Graphic)Plugin.instance.Terminal.topRightText).color; Plugin.instance.Terminal.SyncGroupCreditsServerRpc(0, Plugin.instance.Terminal.numberOfItemsInDropship); ((Graphic)Plugin.instance.Terminal.topRightText).color = Color.red; credsCorrupted = true; } else { Plugin.Spam("Credits restored!"); Plugin.instance.Terminal.SyncGroupCreditsServerRpc(OriginalCreds, Plugin.instance.Terminal.numberOfItemsInDropship); ((Graphic)Plugin.instance.Terminal.topRightText).color = OriginalColor; credsCorrupted = false; } } internal static void RestoreCreds() { if (credsCorrupted) { CorruptedCredits(state: false); } } } internal class Bools { internal static bool lightsFlickering; internal static bool endFlicker; internal static bool appPullInvoked; public static bool endAllCodes; internal static bool IsCodeSent() { return Plugin.instance.CodeSent; } internal static bool IsInsideFactory() { return StartOfRound.Instance.localPlayerController.isInsideFactory; } internal static bool IsHourInRange(int hour, int startHour, int endHour) { if (hour > startHour) { return hour <= endHour; } return false; } internal static bool ShouldRunCodeLooper() { if (SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings") { return true; } if (!ModConfig.ModNetworking.Value) { return true; } if ((Object)(object)Plugin.instance.Terminal == (Object)null) { Plugin.MoreLogs("Terminal instance null"); return false; } return false; } internal static bool ShouldInitPlugin() { if ((Object)(object)Plugin.instance.Terminal == (Object)null) { Plugin.MoreLogs("Terminal instance null"); return false; } return true; } public static bool GhostCodesShouldNotBePresentEver() { if (((Object)StartOfRound.Instance.currentLevel).name == "CompanyBuildingLevel" || StartOfRound.Instance.currentLevel.riskLevel == "Safe") { return true; } if (StartOfRound.Instance.inShipPhase) { return true; } if (Plugin.instance.CodeCount > Plugin.instance.RandCodeAmount) { return true; } return false; } public static bool CanSendCodes() { if (endAllCodes || GhostCodesShouldNotBePresentEver()) { return false; } if (SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings") { return GameNetworkManager.Instance.gameHasStarted; } if ((Object)(object)Plugin.instance.DressGirl == (Object)null) { Plugin.MoreLogs("dressgirl instance is null"); return false; } if (GameNetworkManager.Instance.gameHasStarted) { return Plugin.instance.DressGirl.hauntingLocalPlayer == Object.op_Implicit((Object)(object)StartOfRound.Instance.localPlayerController); } return false; } internal static bool PlayerStillAliveAndControlled(PlayerControllerB player) { if ((Object)(object)player == (Object)null) { return false; } if (!player.isPlayerControlled) { return false; } if (player.isPlayerDead) { return false; } return true; } internal static bool KeepSendingCodes() { if (endAllCodes || GhostCodesShouldNotBePresentEver()) { return false; } if (StartOfRound.Instance.shipIsLeaving || StartOfRound.Instance.allPlayersDead) { return false; } if (SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings") { return true; } if ((Object)(object)Plugin.instance.DressGirl == (Object)null) { return false; } if (!Plugin.instance.DressGirl.hauntingLocalPlayer) { return false; } if (Plugin.instance.DressGirl.hauntingPlayer.isPlayerDead) { return false; } if (Coroutines.rapidFireStart && !DressGirl.girlIsChasing) { return false; } return true; } internal static bool DressGirlStartCodes() { if (endAllCodes || RapidFire.startRapidFire || GhostCodesShouldNotBePresentEver()) { return false; } if (StartOfRound.Instance.shipIsLeaving || StartOfRound.Instance.allPlayersDead) { return false; } if (!Plugin.instance.DressGirl.staringInHaunt || Plugin.instance.DressGirl.hauntingPlayer.isPlayerDead) { return false; } return true; } internal static bool IsThisaBigDoor(int randomObjectNum) { if (randomObjectNum < 0) { return false; } if (CodeStuff.myTerminalObjects.Count == 0) { return false; } if ((Object)(object)CodeStuff.myTerminalObjects[randomObjectNum] == (Object)null) { return false; } if ((Object)(object)((Component)CodeStuff.myTerminalObjects[randomObjectNum]).gameObject == (Object)null) { return false; } if (((Object)((Component)CodeStuff.myTerminalObjects[randomObjectNum]).gameObject).name.Contains("BigDoor")) { return true; } return false; } internal static bool AreEnoughPlayersDancing(int totalPlayers, int playersDancing, int requiredPercentage) { if (playersDancing > totalPlayers * (requiredPercentage / 100)) { return true; } return false; } internal static bool IsThisEffective(int percentChance) { int @int = NumberStuff.GetInt(0, 100); if (percentChance > @int) { return true; } return false; } internal static bool CheckForPlayerName(string playerName) { PlayerControllerB[] players = Plugin.instance.players; foreach (PlayerControllerB val in players) { if (playerName.Contains(val.playerUsername)) { return true; } } return false; } internal static bool AreAnyPlayersInShip() { PlayerControllerB[] players = Plugin.instance.players; foreach (PlayerControllerB val in players) { if (!val.isPlayerDead && val.isInHangarShipRoom) { return true; } } Plugin.MoreLogs("No players detected in ship"); return false; } internal static bool AreAnyPlayersInFacility() { PlayerControllerB[] players = Plugin.instance.players; foreach (PlayerControllerB val in players) { if (!val.isPlayerDead && val.isInsideFactory) { return true; } } Plugin.MoreLogs("No players detected in facility"); return false; } internal static bool IsAnyPlayerUsingTerminal(out PlayerControllerB terminalUser) { PlayerControllerB[] players = Plugin.instance.players; foreach (PlayerControllerB val in players) { if (!val.isPlayerDead && val.inTerminalMenu) { terminalUser = val; return true; } } terminalUser = null; return false; } } internal class CodeActions { internal static Random Rand = new Random(); internal static void InitPossibleActions(StartOfRound instance, int randomObjectNum = -1) { CodeHandling.possibleActions.Clear(); NetworkingRequiredActions(); ExternalModCheck(); CruiserStuff(); ShipStuff(); GhostGirlRequired(); AddRegularDoorStuff(); Maininteractions(); if (randomObjectNum >= 0 && CodeStuff.myTerminalObjects.Count > randomObjectNum) { TerminalObjectActions(instance, randomObjectNum); } } private static void Maininteractions() { if (InteractionsConfig.AffectAllBatteries.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("AffectAllBatteries", delegate { Items.AdjustAllPlayersBattery(); }, InteractionsConfig.AffectAllBatteries.Value)); } if (InteractionsConfig.AffectRandomPlayerBatteries.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("AffectRandomPlayerBatteries", delegate { Items.AffectRandomPlayersBatteries(); }, InteractionsConfig.AffectRandomPlayerBatteries.Value)); } if (InteractionsConfig.HauntFactoryScrap.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("HauntFactoryScrap", delegate { Items.HauntItemUse(isHeld: false); }, InteractionsConfig.HauntFactoryScrap.Value)); } if (InteractionsConfig.HauntHeldScrap.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("HauntHeldScrap", delegate { Items.HauntItemUse(isHeld: true); }, InteractionsConfig.HauntHeldScrap.Value)); } if (InteractionsConfig.SignalTranslator.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("SignalTranslator", delegate { SignalTranslator.MessWithSignalTranslator(); }, InteractionsConfig.SignalTranslator.Value)); } } private static void MessWithWalkies() { if (WalkieTalkie.allWalkieTalkies.Count == 0 || !SetupConfig.GhostCodesSettings.HauntingsMode) { return; } Plugin.Spam("Adding enabled walkie stuff"); if (InteractionsConfig.GarbleWalkies.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("GarbleWalkies", delegate { NetHandler.Instance.GarbleWalkiesServerRpc(); }, InteractionsConfig.GarbleWalkies.Value)); } if (InteractionsConfig.BreatheOnWalkies.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("BreatheOnWalkies", delegate { NetHandler.Instance.BreatheOnWalkiesServerRpc(); }, InteractionsConfig.BreatheOnWalkies.Value)); } } private static void GhostGirlRequired() { if (!SetupConfig.GhostCodesSettings.HauntingsMode) { return; } if (InteractionsConfig.PlayerLights.Value > 0 && !RapidFire.startRapidFire) { CodeHandling.possibleActions.Add(new ActionPercentage("ggFlashlight", delegate { Lights.GGFlashlight(); }, InteractionsConfig.PlayerLights.Value)); } if (InteractionsConfig.AffectHauntedPlayerBatteries.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("AffectHauntedPlayerBatteries", delegate { Items.AffectHauntedPlayersBatteries(); }, InteractionsConfig.AffectHauntedPlayerBatteries.Value)); } MessWithWalkies(); } private static void ShipStuff() { if (!Bools.AreAnyPlayersInShip()) { return; } Plugin.Spam("players detected on ship"); if (InteractionsConfig.LightsOnShip.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("MessWithShipLights", delegate { ghostCodes.ShipStuff.MessWithShipLights(); }, InteractionsConfig.LightsOnShip.Value)); } if (InteractionsConfig.DoorsOnShip.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("MessWithShipDoors", delegate { ghostCodes.ShipStuff.MessWithShipDoors(); }, InteractionsConfig.DoorsOnShip.Value)); } if (ModConfig.ModNetworking.Value && InteractionsConfig.ShockTerminalUser.Value > 0 && Bools.IsAnyPlayerUsingTerminal(out var terminalUser)) { CodeHandling.possibleActions.Add(new ActionPercentage("Shock Terminal User", delegate { ghostCodes.ShipStuff.ShockTerminal(); }, InteractionsConfig.ShockTerminalUser.Value)); Plugin.MoreLogs(terminalUser.playerUsername + " detected using terminal"); } if (InteractionsConfig.MonitorsOnShip.Value > 0 && ModConfig.ModNetworking.Value) { CodeHandling.possibleActions.Add(new ActionPercentage("MessWithMonitors", delegate { NetHandler.Instance.MessWithMonitorsServerRpc(); }, InteractionsConfig.MonitorsOnShip.Value)); } if (InteractionsConfig.TeleportPlayer.Value > 0 && (Object)(object)Teleporter.NormalTP != (Object)null) { Plugin.MoreLogs("Added MessWithNormalTP"); CodeHandling.possibleActions.Add(new ActionPercentage("MessWithNormalTP", delegate { Teleporters.InteractWithAnyTP(0); }, InteractionsConfig.TeleportPlayer.Value)); } if (InteractionsConfig.InverseTeleporter.Value > 0 && (Object)(object)Teleporter.InverseTP != (Object)null) { Plugin.MoreLogs("Added MessWithInverseTP"); CodeHandling.possibleActions.Add(new ActionPercentage("MessWithInverseTP", delegate { Teleporters.InteractWithAnyTP(1); }, InteractionsConfig.InverseTeleporter.Value)); } if (InteractionsConfig.CorruptedCredits.Value > 0 && !TerminalAdditions.credsCorrupted) { CodeHandling.possibleActions.Add(new ActionPercentage("CorruptedCredits", delegate { TerminalAdditions.CorruptedCredits(state: true); }, InteractionsConfig.CorruptedCredits.Value)); } if (InteractionsConfig.HeavyLever.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("HeavyLever", delegate { ghostCodes.ShipStuff.HeavyLeverFunc(); }, InteractionsConfig.HeavyLever.Value)); } if (InteractionsConfig.HauntedOrder.Value > 0 && Plugin.instance.Terminal.orderedItemsFromTerminal.Count == 0 && Plugin.instance.Terminal.numberOfItemsInDropship == 0) { CodeHandling.possibleActions.Add(new ActionPercentage("HauntedOrder", delegate { ghostCodes.ShipStuff.HauntedOrderFunc(); }, InteractionsConfig.HauntedOrder.Value)); } } private static void AddRegularDoorStuff() { if (!Bools.AreAnyPlayersInFacility() || Doors.AllDoors.Count == 0) { return; } if (InteractionsConfig.ToggleAllRegularDoors.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("ToggleAllRegularDoors", delegate { Doors.OpenOrCloseALLDoors(); }, InteractionsConfig.ToggleAllRegularDoors.Value)); } if (InteractionsConfig.ToggleRegularDoor.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("ToggleRegularDoor", delegate { Doors.OpenorClose1RandomDoor(); }, InteractionsConfig.ToggleRegularDoor.Value)); } if (InteractionsConfig.LockSingleDoor.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("LockONEdoor", delegate { Doors.LockorUnlockARandomDoor(stateLocked: true); }, InteractionsConfig.LockSingleDoor.Value)); } if (InteractionsConfig.UnlockSingleDoor.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("UnlockONEdoor", delegate { Doors.LockorUnlockARandomDoor(stateLocked: false); }, InteractionsConfig.UnlockSingleDoor.Value)); } if (InteractionsConfig.TryHauntSingleDoor.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("TryHauntSingleDoor", delegate { Doors.HauntDoors(0); }, InteractionsConfig.TryHauntSingleDoor.Value)); } if (InteractionsConfig.TryHauntHalfAllDoors.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("TryHauntHalfAllDoors", delegate { Doors.HauntDoors(50); }, InteractionsConfig.TryHauntHalfAllDoors.Value)); } if (InteractionsConfig.TryHauntAllDoors.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("TryHauntAllDoors", delegate { Doors.HauntDoors(100); }, InteractionsConfig.TryHauntAllDoors.Value)); } } private static void CruiserStuff() { if ((Object)(object)Plugin.instance.Cruiser == (Object)null || !Plugin.instance.Cruiser.ignitionStarted) { return; } Plugin.MoreLogs("Adding cruiser interactions!!"); if (InteractionsConfig.ChangeCruiserRadio.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("ChangeCruiserRadio", delegate { Plugin.instance.Cruiser.ChangeRadioStation(); }, InteractionsConfig.ChangeCruiserRadio.Value)); } if (InteractionsConfig.CruiserEjectDriver.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("CruiserEjectDriver", delegate { Plugin.instance.Cruiser.SpringDriverSeatServerRpc(); }, InteractionsConfig.CruiserEjectDriver.Value)); } if (InteractionsConfig.CruiserUseBoost.Value > 0 && ((NetworkBehaviour)Plugin.instance.Cruiser).IsOwner) { CodeHandling.possibleActions.Add(new ActionPercentage("CruiserUseBoost", delegate { //IL_000c: 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) Plugin.instance.Cruiser.UseTurboBoostLocalClient(default(Vector2)); }, InteractionsConfig.CruiserUseBoost.Value)); } if (InteractionsConfig.CruiserPush.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("CruiserPush", delegate { Cruiser.Push(); }, InteractionsConfig.CruiserPush.Value)); } if (InteractionsConfig.ToggleCruiserDoors.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("CruiserDoors", delegate { Cruiser.Doors(); }, InteractionsConfig.ToggleCruiserDoors.Value)); } if (InteractionsConfig.ToggleCruiserLights.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("ToggleCruiserLights", delegate { Cruiser.Headlights(1); }, InteractionsConfig.ToggleCruiserLights.Value)); } if (InteractionsConfig.FlickerCruiserLights.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("FlickerCruiserLights", delegate { Cruiser.Headlights(Rand.Next(11)); }, InteractionsConfig.FlickerCruiserLights.Value)); } if (InteractionsConfig.ToggleCruiserHood.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("ToggleCruiserHood", delegate { Plugin.instance.Cruiser.ToggleHoodOpenLocalClient(); }, InteractionsConfig.ToggleCruiserHood.Value)); } if (InteractionsConfig.CruiserWindshield.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("CruiserWindshield", delegate { Cruiser.Windshield(); }, InteractionsConfig.CruiserWindshield.Value)); } if (InteractionsConfig.CruiserShiftGears.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("CruiserShiftGears", delegate { Cruiser.GearShift(); }, InteractionsConfig.CruiserShiftGears.Value)); } } private static void ExternalModCheck() { Plugin.MoreLogs("Checking for any external mods to utilize ghost codes on"); if (!Plugin.instance.ToilHead || !ToilHead.CheckForToilHeadObjects()) { return; } Plugin.MoreLogs("Adding toilhead actions"); if (InteractionsConfig.ToilHeadTurretDisable.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("toilHeadDisable", delegate { ToilHead.HandleToilHeadCodeAction(); }, InteractionsConfig.ToilHeadTurretDisable.Value)); } if (InteractionsConfig.ToilHeadTurretBerserk.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("toilHeadBerserk", delegate { ToilHead.HandleToilHeadBerserkAction(); }, InteractionsConfig.ToilHeadTurretBerserk.Value)); } } private static void NetworkingRequiredActions() { if (ModConfig.ModNetworking.Value && InteractionsConfig.FlipBreaker.Value > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("facilityLights", delegate { Lights.FlipLights(); }, InteractionsConfig.FlipBreaker.Value)); } } private static void TerminalObjectActions(StartOfRound instance, int randomObjectNum) { if (CodeStuff.myTerminalObjects.Count > 0) { CodeHandling.possibleActions.Add(new ActionPercentage("DefaultCodes", delegate { DefaultTerminalAction(randomObjectNum); }, 100f)); } if (!SetupConfig.IgnoreDoors.Value && Bools.IsThisaBigDoor(randomObjectNum)) { CodeHandling.possibleActions.Add(new ActionPercentage("hungryDoor", delegate { Blastdoors.HandleHungryDoor(randomObjectNum, instance); }, InteractionsConfig.HungryBlastDoor.Value)); } if (!SetupConfig.IgnoreTurrets.Value) { CodeHandling.possibleActions.Add(new ActionPercentage("TurretBerserk", delegate { Turrets.HandleTurretAction(); }, InteractionsConfig.TurretBerserk.Value)); } if (!SetupConfig.IgnoreLandmines.Value) { CodeHandling.possibleActions.Add(new ActionPercentage("MineBoom", delegate { Mines.HandleMineBoom(); }, InteractionsConfig.MineBoom.Value)); } } internal static void DefaultTerminalAction(int randomObjectNum) { if (randomObjectNum != -1 && CodeStuff.myTerminalObjects.Count > randomObjectNum) { CodeStuff.myTerminalObjects[randomObjectNum].CallFunctionFromTerminal(); } } } public class ActionPercentage { public Action Action { get; } public float Percentage { get; } public string Name { get; set; } public ActionPercentage(string name, Action action, float percentage) { Action = action; Percentage = percentage; Name = name; base..ctor(); } public static List<Action> ChooseActionsFromPercentages(List<ActionPercentage> actions) { Shuffle(actions); List<Action> list = new List<Action>(); int num = 0; foreach (ActionPercentage action in actions) { Plugin.Spam("Checking " + action.Name + " against percentage"); int num2 = NumberStuff.Rand.Next(101); float num3 = action.Percentage; if (RapidFire.startRapidFire) { num3 = NumberStuff.GetClampedInsanityPercent(num3, InsanityConfig.InsanityModeMultiplier.Value); } if (num < 3 && ((float)num2 <= num3 || Mathf.Approximately(num3, 100f))) { Plugin.Spam("Action " + action.Name + " was chosen!"); list.Add(action.Action); num++; } } return list; } private static void Shuffle<T>(List<T> list) { int num = list.Count; while (num > 1) { num--; int index = NumberStuff.Rand.Next(num); T value = list[index]; list[index] = list[num]; list[num] = value; } } } internal class CodeHandling { internal static List<ActionPercentage> possibleActions = new List<ActionPercentage>(); internal static List<Action> chosenActions = new List<Action>(); internal static void HandleGhostCodeSending(StartOfRound instance) { Misc.LogTime(); if (NumberStuff.TryGetObjectNum(out var randomObjectNum)) { chosenActions.Clear(); CodeActions.InitPossibleActions(instance, randomObjectNum); } else { Plugin.WARNING("Unable to get randomObjectNum!"); } if (possibleActions.Count >= 1 && !Bools.endAllCodes) { chosenActions = ActionPercentage.ChooseActionsFromPercentages(possibleActions); HandleChosenActions(randomObjectNum); SoundSystem.InsanityAmbient(); SoundSystem.HandleCodeEffects(); } } internal static void HandleRapidFireCodeChoices(StartOfRound instance, int number) { Misc.LogTime(); chosenActions.Clear(); CodeActions.InitPossibleActions(instance, number); if (possibleActions.Count >= 1 && !Bools.endAllCodes) { chosenActions = ActionPercentage.ChooseActionsFromPercentages(possibleActions); HandleChosenActions(number); SoundSystem.InsanityAmbient(); SoundSystem.HandleCodeEffects(); } } private static void HandleChosenActions(int randomObjectNum) { if (chosenActions == null && CodeStuff.myTerminalObjects.Count == 0) { Bools.endAllCodes = true; return; } if (chosenActions.Count > 0) { foreach (Action chosenAction in chosenActions) { chosenAction(); } return; } if (randomObjectNum != -1) { CodeStuff.myTerminalObjects[randomObjectNum].CallFunctionFromTerminal(); Plugin.GC.LogInfo((object)"No Special action chosen, calling function from terminal"); } } } internal class Coroutines { internal static bool rapidFireStart; internal static bool codeLooperStarted; internal static IEnumerator InitEnumerator(StartOfRound instance) { int wait = NumberStuff.GetWait(SetupConfig.RandomIntervals.Value, SetupConfig.FirstRandIntervalMin.Value, SetupConfig.FirstRandIntervalMax.Value, SetupConfig.FirstSetInterval.Value); InitPlugin.CodesInit(); Plugin.MoreLogs($"Codes Amount: {Plugin.instance.RandCodeAmount}"); if (SetupConfig.GhostCodesSettings.HauntingsMode && ModConfig.ModNetworking.Value) { Plugin.MoreLogs("The ghost girl has been enhanced, prepare for your next haunting! >:)"); TerminalAdditions.CreateAllNodes(); } else if (((NetworkBehaviour)GameNetworkManager.Instance.localPlayerController).IsHost) { yield return (object)new WaitForSeconds((float)wait); ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(CodeLooper(instance)); Plugin.MoreLogs("The ghost is in the machine..."); TerminalAdditions.CreateAllNodes(); } else { Plugin.MoreLogs("Ghost Girl Enhanced is disabled and you are not the host."); TerminalAdditions.CreateAllNodes(); } } internal static IEnumerator RestartEnum(StartOfRound instance) { int @int = NumberStuff.GetInt(20, 100); yield return (object)new WaitForSeconds((float)@int); int wait = NumberStuff.GetWait(SetupConfig.RandomIntervals.Value, SetupConfig.FirstRandIntervalMin.Value, SetupConfig.FirstRandIntervalMax.Value, SetupConfig.FirstSetInterval.Value); Plugin.MoreLogs($"Codes: {Plugin.instance.CodeCount} / {Plugin.instance.RandCodeAmount}"); if (SetupConfig.GhostCodesSettings.HauntingsMode && ModConfig.ModNetworking.Value) { Plugin.MoreLogs("The ghost girl has been enhanced, prepare for your next haunting! >:)"); } else if (((NetworkBehaviour)GameNetworkManager.Instance.localPlayerController).IsHost) { yield return (object)new WaitForSeconds((float)wait); Bools.endAllCodes = false; rapidFireStart = false; RapidFire.startRapidFire = false; ((MonoBehaviour)instance).StartCoroutine(CodeLooper(instance)); Plugin.MoreLogs("The ghost is in the machine..."); } else { Plugin.MoreLogs("Ghost Girl Enhanced is disabled and you are not the host."); } } internal static IEnumerator CodeLooper(StartOfRound instance) { if (codeLooperStarted) { yield break; } Plugin.MoreLogs("CodeLooper coroutine initiated..."); codeLooperStarted = true; if (Bools.CanSendCodes()) { while (Bools.KeepSendingCodes()) { yield return (object)new WaitForSeconds(1f); if (!Bools.IsCodeSent()) { float randomWaitNum = NumberStuff.GetWait(SetupConfig.RandomIntervals.Value, SetupConfig.SecondRandIntervalMin.Value, SetupConfig.SecondRandIntervalMax.Value, SetupConfig.SecondSetInterval.Value); if (SetupConfig.GhostCodesSettings.InsanityMode) { InsanityStuff.ApplyInsanityMode(instance, ref randomWaitNum); if (RapidFire.startRapidFire) { Plugin.MoreLogs("startRapidFire detected from codeLooper"); codeLooperStarted = false; yield break; } } yield return (object)new WaitForSeconds(randomWaitNum); CodeHandling.HandleGhostCodeSending(instance); Plugin.instance.CodeCount++; Plugin.instance.CodeSent = true; Plugin.MoreLogs($"Code Sent, count: {Plugin.instance.CodeCount}"); } else { float randomWaitNum2 = NumberStuff.GetWait(SetupConfig.RandomIntervals.Value, SetupConfig.RandIntervalACMin.Value, SetupConfig.RandIntervalACMax.Value, SetupConfig.SetIntervalAC.Value); Plugin.MoreLogs($"ghostCode was just sent, waiting {randomWaitNum2}"); if (SetupConfig.GhostCodesSettings.InsanityMode) { InsanityStuff.ApplyInsanityMode(instance, ref randomWaitNum2); } yield return (object)new WaitForSeconds(randomWaitNum2); Plugin.instance.CodeSent = false; } if (StartOfRound.Instance.shipIsLeaving) { Plugin.MoreLogs($"Ship is leaving, {Plugin.instance.CodeCount} codes were sent."); codeLooperStarted = false; yield break; } } Plugin.MoreLogs($"the ghost is bored of sending codes, {Plugin.instance.CodeCount} codes were sent."); codeLooperStarted = false; } else { Plugin.MoreLogs("No codes can be sent at this time."); codeLooperStarted = false; } } private static void RapidFireStoppers(int startTime, int currentTime) { DressGirl.GGrapidFireChecks(); RapidFire.TimeCheck(startTime, currentTime); } internal static IEnumerator RapidFireStart(StartOfRound instance) { if (rapidFireStart) { yield break; } Plugin.MoreLogs("start of rapidFire"); int startTime = TimeOfDay.Instance.hour; rapidFireStart = true; if (Bools.CanSendCodes()) { while (Bools.KeepSendingCodes() && RapidFire.startRapidFire && !Bools.endAllCodes) { RapidFire.CheckInsanityToContinue(); RapidFire.HandleLights(); if (!Bools.IsCodeSent()) { if (CodeStuff.myTerminalObjects.Count == 0) { for (int j = 0; j < CodeHandling.possibleActions.Count; j++) { if (!Bools.KeepSendingCodes()) { break; } RapidFireStoppers(startTime, TimeOfDay.Instance.hour); CodeHandling.HandleRapidFireCodeChoices(instance, -1); yield return (object)new WaitForSeconds(Random.Range(0.5f, 3f)); } } else { for (int j = 0; j < CodeStuff.myTerminalObjects.Count; j++) { if (!Bools.KeepSendingCodes()) { break; } RapidFireStoppers(startTime, TimeOfDay.Instance.hour); CodeHandling.HandleRapidFireCodeChoices(instance, j); yield return (object)new WaitForSeconds(Random.Range(0.5f, 3f)); } } RapidFire.CountSentCodes(); Plugin.instance.CodeSent = true; } else { RapidFireStoppers(startTime, TimeOfDay.Instance.hour); float num = Random.Range(1f, 4f); RapidFireStoppers(startTime, TimeOfDay.Instance.hour); yield return (object)new WaitForSeconds(num); Plugin.instance.CodeSent = false; } if (RapidFire.LoopBreakers()) { yield break; } } if (!Bools.KeepSendingCodes()) { Plugin.GC.LogInfo((object)"end of rapidFire...."); } if (!RapidFire.startRapidFire && Bools.KeepSendingCodes() && !Bools.endAllCodes) { RapidFire.ReturnFromRapidFire(); RapidFire.startRapidFire = false; rapidFireStart = false; } else { _ = Bools.endAllCodes; RapidFire.startRapidFire = false; rapidFireStart = false; } } else { RapidFire.startRapidFire = false; rapidFireStart = false; } } internal static IEnumerator EmptyShip() { Plugin.MoreLogs("Emptying the ship of any players!"); PlayerControllerB localPlayer = StartOfRound.Instance.localPlayerController; Vector3 playerPosition = ((Component)localPlayer).transform.position; Vector3 shipDoorPosition = StartOfRound.Instance.shipDoorNode.position; float oldfriction = localPlayer.slideFriction; localPlayer.isPlayerSliding = true; localPlayer.slideFriction = localPlayer.maxSlideFriction * 2f; while (localPlayer.isInHangarShipRoom) { if (Physics.Linecast(playerPosition, shipDoorPosition, StartOfRound.Instance.collidersAndRoomMask)) { Vector3 val = Vector3.Normalize(shipDoorPosition - playerPosition); localPlayer.externalForces = val * 350f; Plugin.MoreLogs("applying external forces"); } yield return (object)new WaitForSeconds(0.1f); } localPlayer.isPlayerSliding = false; localPlayer.slideFriction = oldfriction; } internal static IEnumerator GhostGirlEnhanced(StartOfRound instance) { Plugin.MoreLogs("GhostGirl is being enhanced"); if (RapidFire.startRapidFire) { yield break; } while (Plugin.instance.DressGirl.staringInHaunt) { float num = Random.Range(1f, 4f); if (!Plugin.instance.CodeSent && !DressGirl.girlIsChasing) { CodeHandling.HandleGhostCodeSending(instance); Plugin.instance.CodeSent = true; } else { Plugin.GC.LogInfo((object)$"ghostCode was just sent, waiting {num}"); yield return (object)new WaitForSeconds(num); Plugin.instance.CodeSent = false; } if (RapidFire.LoopBreakers()) { yield break; } } Plugin.MoreLogs("End of GhostGirlEnhanced Coroutine..."); } } internal class Doors { internal static List<DoorLock> AllDoors = new List<DoorLock>(); internal static bool CustomHauntRunning = false; internal static Random Rand = new Random(); internal static void UpdateCacheDoorsList() { AllDoors = Object.FindObjectsOfType<DoorLock>().ToList(); } internal static void OpenOrCloseALLDoors() { Plugin.MoreLogs("All doors changing state"); for (int i = 0; i < AllDoors.Count; i++) { if (!((Object)(object)AllDoors[i] == (Object)null)) { AllDoors[i].OpenOrCloseDoor(StartOfRound.Instance.localPlayerController); } } Plugin.MoreLogs($"All {AllDoors.Count} doors have been opened or closed"); } internal static void OpenorClose1RandomDoor() { if (AllDoors.Count != 0) { int @int = NumberStuff.GetInt(0, AllDoors.Count); if (!((Object)(object)AllDoors[@int] == (Object)null)) { AllDoors[@int].OpenOrCloseDoor(StartOfRound.Instance.localPlayerController); Plugin.MoreLogs("Opened or Closed one door"); } } } internal static void LockorUnlockARandomDoor(bool stateLocked) { if (AllDoors.Count == 0) { return; } for (int i = 0; i < AllDoors.Count; i++) { int @int = NumberStuff.GetInt(0, AllDoors.Count); if (!((Object)(object)AllDoors[@int] == (Object)null)) { if (AllDoors[@int].isLocked && stateLocked) { AllDoors[@int].UnlockDoorServerRpc(); Plugin.MoreLogs("Unlocked random door"); break; } if (!AllDoors[@int].isLocked && !stateLocked) { AllDoors[@int].LockDoor(30f); Plugin.MoreLogs("Locked random door"); break; } } } } internal static void HauntDoors(int value) { if (AllDoors.Count == 0) { return; } float num = (float)value / 100f; Plugin.MoreLogs($"Attempting to Haunt {value}% of doors!"); float num2 = ((value != 0) ? ((float)AllDoors.Count * num) : 1f); for (int i = 0; i < (int)num2; i++) { if (!((Object)(object)AllDoors[i] == (Object)null)) { MonoBehaviour component = ((Component)AllDoors[i]).gameObject.GetComponent<MonoBehaviour>(); component.StopAllCoroutines(); component.StartCoroutine(CustomDoorHaunt(AllDoors[i])); } } Plugin.MoreLogs($"Attempted to haunt {(int)num2} doors!"); } internal static IEnumerator CustomDoorHaunt(DoorLock thisDoor) { int times = Rand.Next(9); for (int i = 0; i < times; i++) { float num = ((!thisDoor.isDoorOpened && Rand.Next(100) >= 92) ? Random.Range(2f, 7f) : ((!thisDoor.isDoorOpened) ? Random.Range(0.2f, 1.7f) : Random.Range(0.15f, 0.3f))); yield return (object)new WaitForSeconds(num); thisDoor.OpenOrCloseDoor(StartOfRound.Instance.localPlayerController); } yield return (object)new WaitForSeconds(0.2f); if (thisDoor.isDoorOpened) { thisDoor.OpenOrCloseDoor(StartOfRound.Instance.localPlayerController); } } } public class GamePatchStuff { [HarmonyPatch(typeof(StartOfRound), "PassTimeToNextDay")] public class NextDayPatch { private static void Postfix() { Plugin.Spam("Next day detected!"); OpenLibEvents.GhostCodesReset.Invoke(); } } [HarmonyPatch(typeof(TerminalAccessibleObject), "Start")] public class TerminalAccessibleObject_StartPatch { private static void Postfix(TerminalAccessibleObject __instance) { CodeStuff.NewUsableCode(__instance); } } [HarmonyPatch(typeof(TerminalAccessibleObject), "OnDestroy")] public class TerminalAccessibleObject_DestroyPatch { private static void Postfix(TerminalAccessibleObject __instance) { CodeStuff.RemoveUsableCode(__instance); } } [HarmonyPatch(/*Could not decode attribute arguments.*/)] public class ApparatusPullPatch { private static bool instructionAdded; [HarmonyTranspiler] private static IEnumerable<CodeInstruction> ApparatusPullPatch_Transpiler(IEnumerable<CodeInstruction> instructions) { CodeInstruction myMethod = CodeInstruction.Call("ghostCodes.Patches.OpenLibEvents:GetInvoke", (Type[])null, (Type[])null); foreach (CodeInstruction instruction in instructions) { if (!instructionAdded) { Plugin.GC.LogInfo((object)"Custom Instruction added in DisconnectFromMachinery enumerator"); yield return myMethod; yield return instruction; instructionAdded = true; } else { yield return instruction; } } Plugin.GC.LogInfo((object)"Transpiler Success! - Added ApparatusPull Invoke Event"); } } [HarmonyPatch(typeof(DressGirlAI), "Start")] public class DressGirlExists : DressGirlAI { private static void Postfix(DressGirlAI __instance) { Plugin.instance.DressGirl = __instance; Plugin.MoreLogs("Dressgirl instance detected."); } protected override void __initializeVariables() { ((DressGirlAI)this).__initializeVariables(); } protected internal override string __getTypeName() { return "DressGirlExists"; } } [HarmonyPatch(typeof(DressGirlAI), "SetHauntStarePosition")] public class StaringInHauntPatch : DressGirlAI { private static void Postfix(DressGirlAI __instance) { if (!(SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings")) { if ((Object)(object)__instance == (Object)null) { Plugin.GC.LogError((object)"Failed to grab dressgirl instance"); } else if (__instance.staringInHaunt && Bools.CanSendCodes() && Bools.DressGirlStartCodes()) { Plugin.instance.DressGirl = __instance; Plugin.GC.LogInfo((object)"The ghostGirl wants to play!"); ((MonoBehaviour)Plugin.instance.DressGirl).StartCoroutine(Coroutines.GhostGirlEnhanced(StartOfRound.Instance)); } } } protected override void __initializeVariables() { ((DressGirlAI)this).__initializeVariables(); } protected internal override string __getTypeName() { return "StaringInHauntPatch"; } } [HarmonyPatch(typeof(DressGirlAI), "FlipLightsBreakerServerRpc")] public class DressGirlRPCFix : DressGirlAI { private static void Postfix(DressGirlAI __instance) { if (SetupConfig.FixGhostGirlBreakers.Value) { Plugin.MoreLogs("Fixing lightbreaker Rpc"); __instance.FlipLightsBreakerClientRpc(); } } protected override void __initializeVariables() { ((DressGirlAI)this).__initializeVariables(); } protected internal override string __getTypeName() { return "DressGirlRPCFix"; } } [HarmonyPatch(typeof(DressGirlAI), "BeginChasing")] public class TheChaseBegins { private static void Postfix(DressGirlAI __instance) { DressGirl.BreakersFix(__instance); if (!(SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings")) { RapidFire.startRapidFire = true; DressGirl.girlIsChasing = true; Plugin.MoreLogs("Girl has begun chasing, setting rapidFire to TRUE"); ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Coroutines.RapidFireStart(StartOfRound.Instance)); } } } [HarmonyPatch(typeof(DressGirlAI), "StopChasing")] public class TheChaseEnds : DressGirlAI { private static void Postfix() { if (!(SetupConfig.GhostCodesSettings.CurrentMode.ToLower() != "hauntings")) { RapidFire.startRapidFire = false; DressGirl.girlIsChasing = false; Plugin.MoreLogs("Chase sequence has ended."); } } protected override void __initializeVariables() { ((DressGirlAI)this).__initializeVariables(); } protected internal override string __getTypeName() { return "TheChaseEnds"; } } [HarmonyPatch(typeof(VehicleController), "Awake")] public class GetVehicleController { private static void Postfix(VehicleController __instance) { Plugin.instance.Cruiser = __instance; Plugin.MoreLogs("Cruiser instance detected."); } } } internal class DressGirl : EnemyAI { internal static bool girlIsChasing; internal static void InitDressGirl() { Plugin.MoreLogs("Resetting DressGirl Variables..."); girlIsChasing = false; Plugin.instance.DressGirl = null; } internal static void ChangeHauntedPlayer(PlayerControllerB player) { Plugin.instance.DressGirl.hauntingPlayer = player; ((EnemyAI)Plugin.instance.DressGirl).ChangeOwnershipOfEnemy(Plugin.instance.DressGirl.hauntingPlayer.actualClientId); Plugin.instance.DressGirl.hauntingLocalPlayer = (Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)Plugin.instance.DressGirl.hauntingPlayer; } internal static void GGrapidFireChecks() { if (!((Object)(object)Plugin.instance.DressGirl == (Object)null) && SetupConfig.GhostCodesSettings.HauntingsMode) { Plugin.MoreLogs("Checking for rapidFire ending events"); DancingCheck(); ShowerStuff.CheckForHauntedPlayerInShower(); } } private static void DancingCheck() { if (InteractionsConfig.EmoteStopChasing.Value > 1 || !girlIsChasing) { return; } if (!Bools.IsThisEffective(InteractionsConfig.EmoteStopChasing.Value)) { Plugin.MoreLogs("Ghost girl doesn't want to see you dance!"); return; } int numberPlayersEmoting = NumberStuff.GetNumberPlayersEmoting(); int alivePlayers = NumberStuff.GetAlivePlayers(); if (Bools.AreEnoughPlayersDancing(alivePlayers, numberPlayersEmoting, InteractionsConfig.EmoteStopChaseRequiredPlayers.Value)) { Plugin.MoreLogs("Enough players emoting, stopping chase"); StopGirlFromChasing(); } else { Plugin.MoreLogs("You might wanna keep running..."); } } internal static void StopGirlFromChasing() { if (!((Object)(object)Plugin.instance.DressGirl == (Object)null) && Plugin.instance.DressGirl.hauntingLocalPlayer) { Plugin.instance.DressGirl.StopChasing(); Plugin.MoreLogs("initiating stop chase."); } } internal static void GirlDisappear() { if (!((Object)(object)Plugin.instance.DressGirl == (Object)null) && Plugin.instance.DressGirl.hauntingLocalPlayer) { Plugin.instance.DressGirl.DisappearDuringHaunt(); } } internal static void EndAllGirlStuff() { if (girlIsChasing) { StopGirlFromChasing(); } if (Plugin.instance.DressGirl.staringInHaunt) { GirlDisappear(); } } internal static void BreakersFix(DressGirlAI instance) { if (SetupConfig.FixGhostGirlBreakers.Value && ((EnemyAI)instance).currentBehaviourStateIndex != 1 && instance.timesChased == 1 && Random.Range(0, 100) < SetupConfig.VanillaBreakersChance.Value) { instance.FlipLightsBreakerServerRpc(); Plugin.GC.LogInfo((object)"patched updated breaker chance for vanilla"); } } protected override void __initializeVariables() { ((EnemyAI)this).__initializeVariables(); } protected internal override string __getTypeName() { return "DressGirl"; } } internal class InitPlugin { internal static void StartTheRound() { if (!(((Object)StartOfRound.Instance.currentLevel).name == "CompanyBuildingLevel") && !(StartOfRound.Instance.currentLevel.riskLevel == "Safe")) { InitMode(); BaseReset(); DressGirl.InitDressGirl(); StartPlugin(); Lights.InitLights(); } } private static void StartPlugin() { if (Bools.ShouldInitPlugin()) { ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Coroutines.InitEnumerator(StartOfRound.Instance)); } } internal static void RestartPlugin() { if (Bools.ShouldInitPlugin()) { ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Coroutines.RestartEnum(StartOfRound.Instance)); } } internal static void InitMode() { Plugin.MoreLogs("Initializing ghostCodes mode settings"); SetupConfig.GhostCodesSettings.UpdateSettings(StartOfRound.Instance.currentLevel); } internal static void BaseReset() { Bools.appPullInvoked = false; Plugin.instance.CodeSent = false; RapidFire.startRapidFire = false; Coroutines.rapidFireStart = false; Coroutines.codeLooperStarted = false; Plugin.instance.MaxSanity = 0f; Plugin.instance.GroupSanity = 0f; GetPlayersAtStart(); Plugin.instance.CodeCount = 0; Plugin.instance.RandCodeAmount = 0; ShipStuff.ResetLever(); TerminalAdditions.RestoreCreds(); } internal static void CodesInit() { Plugin.MoreLogs("Initializing GhostCode core variables"); Bools.endAllCodes = false; TerminalAdditions.ResetBools(); Doors.UpdateCacheDoorsList(); Plugin.instance.RandCodeAmount = NumberStuff.GetInt(SetupConfig.MinCodes.Value, SetupConfig.MaxCodes.Value); if (SetupConfig.SoloAssist.Value) { InsanityStuff.InitsoloAssist(); } } internal static void GetPlayersAtStart() { Plugin.instance.playersAtStart = 0; Plugin.instance.players = StartOfRound.Instance.allPlayerScripts; for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Count(); i++) { if (StartOfRound.Instance.allPlayerScripts[i].isPlayerControlled) { Plugin.instance.playersAtStart++; } } Plugin.MoreLogs($"Players at Start: {Plugin.instance.playersAtStart}"); if (Plugin.instance.playersAtStart > 1) { Plugin.MoreLogs("SoloAssist Buff disabled, more than one player detected."); } } } internal class InsanityStuff { internal static Dictionary<string, ConfigEntry<int>> stageKeyVal = new Dictionary<string, ConfigEntry<int>>(); internal static Stages stage1 = SetStageInfo("Stage 1", 0, 6, SoloAssistConfig.S1percent, SoloAssistConfig.S1inside, SoloAssistConfig.S1outside); internal static Stages stage2 = SetStageInfo("Stage 2", 7, 10, SoloAssistConfig.S2percent, SoloAssistConfig.S2inside, SoloAssistConfig.S2outside); internal static Stages stage3 = SetStageInfo("Stage 3", 11, 15, SoloAssistConfig.S3percent, SoloAssistConfig.S3inside, SoloAssistConfig.S3outside); internal static List<Stages> allStages = new List<Stages>(); public static void ApplyInsanityMode(StartOfRound instance, ref float randomWaitNum) { GetAllSanity(); float groupSanity = Plugin.instance.GroupSanity; float maxSanity = Plugin.instance.MaxSanity; if (RapidFire.startRapidFire && SetupConfig.RapidFireMaxHours.Value > 0) { Plugin.GC.LogInfo((object)"max insanity level reached!!! startRapidFire TRUE"); ((MonoBehaviour)instance).StartCoroutine(Coroutines.RapidFireStart(instance)); } else { AdjustWaitNum(groupSanity, maxSanity, ref randomWaitNum); Plugin.MoreLogs($"waiting {randomWaitNum}"); } } internal static void InitsoloAssist() { allStages.Clear(); allStages.Add(stage1); allStages.Add(stage2); allStages.Add(stage3); } internal static void GetAllSanity() { Plugin.instance.GroupSanity = 0f; Plugin.instance.MaxSanity = 0f; for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Count(); i++) { if (!StartOfRound.Instance.allPlayerScripts[i].isPlayerDead && StartOfRound.Instance.allPlayerScripts[i].isPlayerControlled) { Plugin.instance.GroupSanity += StartOfRound.Instance.allPlayerScripts[i].insanityLevel; Plugin.instance.MaxSanity += StartOfRound.Instance.allPlayerScripts[i].maxInsanityLevel; } } float groupSanity = Plugin.instance.GroupSanity; ApplyBonuses(ref groupSanity, Plugin.instance.MaxSanity); Plugin.instance.GroupSanity = groupSanity; CheckSanityRapidFire(); } private static void CheckSanityRapidFire() { if (SetupConfig.RapidFireMaxHours.Value >= 1) { if (Mathf.Round(Plugin.instance.GroupSanity) >= Mathf.Round(Plugin.instance.MaxSanity) * ((float)InsanityConfig.SanityMaxLevel.Value / 100f)) { RapidFire.startRapidFire = true; Plugin.MoreLogs("max sanity hit, CheckSanityRapidFire()"); Plugin.MoreLogs($"Group Sanity Level: {Mathf.Round(Plugin.instance.GroupSanity)}"); Plugin.MoreLogs($"Group Max Insanity level: {Mathf.Round(Plugin.instance.MaxSanity)}"); } else { RapidFire.startRapidFire = false; Plugin.MoreLogs($"Group Sanity Level: {Mathf.Round(Plugin.instance.GroupSanity)}"); Plugin.MoreLogs($"Group Max Insanity level: {Mathf.Round(Plugin.instance.MaxSanity)}"); } } } private static float AdjustWaitNum(float groupSanity, float maxSanity, ref float randomWaitNum) { if (SetupConfig.RapidFireMaxHours.Value < 1 && Mathf.Round(groupSanity) >= Mathf.Round(maxSanity) * ((float)InsanityConfig.SanityMaxLevel.Value / 100f)) { randomWaitNum *= (float)InsanityConfig.WaitMaxLevel.Value / 100f; Plugin.MoreLogs("Max Insanity Level reached (rapidFire disabled)"); return randomWaitNum; } if (Mathf.Round(groupSanity) >= Mathf.Round(maxSanity) * ((float)InsanityConfig.SanityLevel3.Value / 100f)) { randomWaitNum *= (float)InsanityConfig.WaitLevel3.Value / 100f; Plugin.MoreLogs("insanity level 3 reached"); return randomWaitNum; } if (Mathf.Round(groupSanity) >= Mathf.Round(maxSanity) * ((float)InsanityConfig.SanityLevel2.Value / 100f)) { randomWaitNum *= (float)InsanityConfig.WaitLevel2.Value / 100f; Plugin.MoreLogs("insanity level 2 reached"); return randomWaitNum; } if (Mathf.Round(groupSanity) >= Mathf.Round(maxSanity) * ((float)InsanityConfig.SanityLevel1.Value / 100f)) { randomWaitNum *= (float)InsanityConfig.WaitLevel1.Value / 100f; Plugin.MoreLogs("insanity level 1 reached"); return randomWaitNum; } Plugin.MoreLogs("insanity levels low"); return randomWaitNum; } private static Tuple<float, float> ApplyBonuses(ref float groupSanity, float maxSanity) { Plugin.MoreLogs($"Applying bonuses & debuffs\nplayersAtStart = {Plugin.instance.playersAtStart}"); if (SetupConfig.SoloAssist.Value && Plugin.instance.playersAtStart == 1) { Plugin.MoreLogs("SoloAssist Activated"); groupSanity = SoloAssist(ref groupSanity, maxSanity); } if (InsanityConfig.DeathBonus.Value > 0) { Plugin.MoreLogs("Death Bonus Activated"); groupSanity = ApplyDeathBonus(ref groupSanity, maxSanity); } if (InsanityConfig.GhostGirlBonus.Value > 0 && (Object)(object)Plugin.instance.DressGirl != (Object)null) { Plugin.MoreLogs("Ghost Girl Bonus Activated"); groupSanity = ApplyGirlBonus(ref groupSanity, maxSanity); } if (InsanityConfig.EmoteBuff.Value > 1) { Plugin.MoreLogs("Emote Buff Activated"); groupSanity = EmoteBuff(ref groupSanity); } return Tuple.Create(groupSanity, maxSanity); } private static float ApplyDeathBonus(ref float groupSanity, float maxSanity) { int num = Plugin.instance.players.Count((PlayerControllerB player) => player.isPlayerDead && player.isPlayerControlled); for (int i = 0; i < num; i++) { float num2 = groupSanity * ((float)InsanityConfig.DeathBonus.Value / 100f); Plugin.MoreLogs($"Dead Player detected. Adding {num2} to group sanity"); groupSanity = ApplyBonus(groupSanity, maxSanity, num2, (float _) => true); } Plugin.MoreLogs("Death bonus applied to insanity values"); return groupSanity; } private static float ApplyGirlBonus(ref float groupSanity, float maxSanity) { Plugin.MoreLogs("Ghost Girl Bonus applied to insanity values"); float num = groupSanity * ((float)InsanityConfig.GhostGirlBonus.Value / 100f); Plugin.MoreLogs($"Ghost Girl Bonus adding {num} to group sanity"); groupSanity = ApplyBonus(groupSanity, maxSanity, num, (float _) => true); return groupSanity; } private static float ApplyBonus(float groupSanity, float maxSanity, float bonusValue, Func<float, bool> condition) { if (condition(groupSanity) && maxSanity >= groupSanity + bonusValue) { groupSanity += bonusValue; } return groupSanity; } private static Stages SetStageInfo(string name, int startHour, int endHour, ConfigEntry<int> percentKey, ConfigEntry<int> insideKey, ConfigEntry<int> outsideKey) { return new Stages { Name = name, StartHour = startHour, EndHour = endHour, PercentKey = percentKey, InsideKey = insideKey, OutsideKey = outsideKey }; } private static float EmoteBuff(ref float groupSanity) { if (InsanityConfig.EmoteBuff.Value > 0) { PlayerControllerB[] players = Plugin.instance.players; foreach (PlayerControllerB val in players) { if (!val.isPlayerDead && val.performingEmote) { float num = groupSanity * ((float)InsanityConfig.EmoteBuff.Value / 100f); Plugin.MoreLogs($"Emote buff removing {num} from group sanity"); ApplySanityDebuff(ref groupSanity, num); } } } return groupSanity; } private static float SoloAssist(ref float groupSanity, float maxSanity) { if (SetupConfig.SoloAssist.Value && Plugin.instance.playersAtStart == 1) { int hour = TimeOfDay.Instance.hour; Plugin.GC.LogInfo((object)$"Hour: {hour}"); foreach (Stages allStage in allStages) { if (Bools.IsHourInRange(hour, allStage.StartHour, allStage.EndHour)) { float num = maxSanity * ((float)allStage.PercentKey.Value / 100f); float num2 = (Bools.IsInsideFactory() ? allStage.InsideKey.Value : allStage.OutsideKey.Value); Plugin.MoreLogs($"threshold: {num}, debuffAmount: {num2}, GroupSanity: {groupSanity}"); if (groupSanity >= num) { ApplySanityDebuff(ref groupSanity, num2); Plugin.MoreLogs(allStage.Name + " detected and debuffs applied"); } else { Plugin.MoreLogs("No solo assist buff added."); } break; } } } return groupSanity; } private static void ApplySanityDebuff(ref float groupSanity, float debuffAmount) { if (groupSanity > debuffAmount) { groupSanity -= debuffAmount; Plugin.GC.LogInfo((object)$"Subtracted {debuffAmount} from Group Sanity Level."); } else { groupSanity = 0f; Plugin.GC.LogInfo((object)$"Subtracted {debuffAmount} from Group Sanity Level which set value to 0."); } } } internal class Stages { internal string Name { get; set; } internal int StartHour { get; set; } internal int EndHour { get; set; } internal ConfigEntry<int> PercentKey { get; set; } internal ConfigEntry<int> InsideKey { get; set; } internal ConfigEntry<int> OutsideKey { get; set; } } internal class Lights { internal static bool activeLightsColor = false; internal static bool warningLights = false; internal static List<Light> allLightsFixed = new List<Light>(); internal static List<Animator> allPoweredLights = new List<Animator>(); internal static bool activeFlicker = false; internal static void InitLights() { activeLightsColor = false; warningLights = false; activeFlicker = false; allLightsFixed = new List<Light>(); allPoweredLights = new List<Animator>(); if (RoundManager.Instance.allPoweredLightsAnimators.Count == 0) { Plugin.WARNING("INTERIOR HAS NO POWERED LIGHT ANIMATORS!!!"); Plugin.WARNING("INTERIOR HAS NO POWERED LIGHT ANIMATORS!!!"); Plugin.WARNING("INTERIOR HAS NO POWERED LIGHT ANIMATORS!!!"); Plugin.WARNING("INTERIOR HAS NO POWERED LIGHT ANIMATORS!!!"); GameObject val = GameObject.Find("Systems/LevelGeneration"); if ((Object)(object)val != (Object)null) { allLightsFixed = val.GetComponentsInChildren<Light>(true).ToList(); Plugin.Spam($"Got [ {allLightsFixed.Count} ] lights from dungeon root!"); } else { Plugin.WARNING("Unable to get dungeonRoot lights!"); } } foreach (Animator allPoweredLightsAnimator in RoundManager.Instance.allPoweredLightsAnimators) { if ((Object)(object)((Component)allPoweredLightsAnimator).GetComponentInChildren<Light>(true) != (Object)null) { allPoweredLights.Add(allPoweredLightsAnimator); } List<Light> collection = ((Component)allPoweredLightsAnimator).GetComponentsInChildren<Light>(true).ToList(); allLightsFixed.AddRange(collection); } } internal static void GGFlashlight() { NetHandler.Instance.FlickerLightsServerRpc(flickerFlash: true, disableFlash: false); Plugin.MoreLogs("nosfaratu is that you??"); } internal static void FlipLights() { Plugin.MoreLogs("who turned out the lights??"); NetHandler.Instance.FacilityBreakerServerRpc(); } internal static IEnumerator ColorTransition(Light light, Color newColor, float duration) { //IL_000e: Unknown result type (might be due to invalid IL or missing references) //IL_000f: Unknown result type (might be due to invalid IL or missing references) Color init = light.color; float counter = 0f; while (counter < duration) { counter += Time.deltaTime; float num = Mathf.Clamp01(counter / duration); light.color = Color.Lerp(init, newColor, num); yield return null; } } internal static IEnumerator PoweredLightsColor(PlayerControllerB HauntedPlayer) { if (activeLightsColor || SetupConfig.RapidLightsColorValue.Value.ToLower() == "nochange" || SetupConfig.RapidLightsColorValue.Value.ToLower() == "default" || SetupConfig.RapidLightsColorValue.Value.Length == 0) { yield break; } if (allLightsFixed.Count == 0) { Plugin.WARNING("NO LIGHTS DETECTED!"); Plugin.WARNING("NO LIGHTS DETECTED!"); Plugin.WARNING("NO LIGHTS DETECTED!"); yield break; } activeLightsColor = true; Plugin.Spam($"allLightsFixed Count: {allLightsFixed.Count}"); Dictionary<Light, Color> allLightsColors = new Dictionary<Light, Color>(); Color32 val = Color32.op_Implicit(Misc.HexToColor(SetupConfig.RapidLightsColorValue.Value)); for (int i = 0; i < allLightsFixed.Count; i++) { if (!allLightsColors.ContainsKey(allLightsFixed[i])) { allLightsColors.Add(allLightsFixed[i], allLightsFixed[i].color); } ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(ColorTransition(allLightsFixed[i], Color32.op_Implicit(val), 5f)); } warningLights = true; Plugin.MoreLogs("Alarm lights set"); while (warningLights && Bools.PlayerStillAliveAndControlled(HauntedPlayer)) { yield return (object)new WaitForEndOfFrame(); } if (warningLights) { warningLights = false; } yield return (object)new WaitForSeconds(1f); for (int j = 0; j < allLightsFixed.Count; j++) { if (allLightsColors.TryGetValue(allLightsFixed[j], out var value)) { ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(ColorTransition(allLightsFixed[j], value, 3f)); } else { Plugin.WARNING("Unable to get original light color!"); } } Plugin.MoreLogs("Lights set back to normal"); activeLightsColor = false; } internal static IEnumerator WhileLightsFlicker() { if (Bools.lightsFlickering || warningLights) { while (RapidFire.startRapidFire && !StartOfRound.Instance.localPlayerController.isPlayerDead && !Bools.endAllCodes) { yield return (object)new WaitForEndOfFrame(); } Plugin.Spam("End of LightsFlicker Coroutine!"); NetHandler.Instance.EndRapidFireLightsServerRpc(); } } internal static IEnumerator FlickerPoweredLights(PlayerControllerB HauntedPlayer) { if (Bools.lightsFlickering) { yield break; } if (allPoweredLights.Count == 0) { Plugin.WARNING("No powered lights!"); Plugin.WARNING("No powered lights!"); Plugin.WARNING("No powered lights!"); yield break; } Bools.lightsFlickering = true; Plugin.Spam("FlickerPoweredLights"); while (Bools.lightsFlickering && Bools.PlayerStillAliveAndControlled(HauntedPlayer)) { int num = 0; int maxLights = ((allPoweredLights.Count > 200) ? 85 : ((allPoweredLights.Count > 100) ? 50 : ((allPoweredLights.Count <= 50) ? 9 : 15))); foreach (Animator allPoweredLight in allPoweredLights) { if (num < maxLights) { allPoweredLight.SetTrigger("Flicker"); num++; } else { yield return (object)new WaitForSeconds(0.05f); num = 0; } } yield return (object)new WaitForSeconds(Random.Range(SetupConfig.RapidLightsMin.Value, SetupConfig.RapidLightsMax.Value)); } if (Bools.lightsFlickering) { Bools.lightsFlickering = false; } Plugin.Spam("EndAlarmLights"); yield return (object)new WaitForSeconds(0.3f); RoundManager.Instance.SwitchPower(true); Bools.lightsFlickering = false; } } internal class Mines { internal static void HandleMineBoom() { if (CodeStuff.myTerminalObjects.Count == 0) { return; } List<TerminalAccessibleObject> list = CodeStuff.myTerminalObjects.FindAll((TerminalAccessibleObject m) => (Object)(object)((Component)m).gameObject.GetComponent<Landmine>() != (Object)null && !((Component)m).gameObject.GetComponent<Landmine>().hasExploded); if (list.Count > 0) { int index = NumberStuff.Rand.Next(list.Count); Landmine component = ((Component)list[index]).gameObject.GetComponent<Landmine>(); if (!component.hasExploded) { component.ExplodeMineClientRpc(); component.ExplodeMineServerRpc(); Plugin.MoreLogs("WHAT THE FUUUUUU-"); } } else { Plugin.Spam("No landmines to go kaboom"); } } } internal class Misc { internal static List<PlayerControllerB> GetAllLivingPlayers() { List<PlayerControllerB> list = new List<PlayerControllerB>(); Plugin.MoreLogs("Getting alive players"); PlayerControllerB[] players = Plugin.instance.players; foreach (PlayerControllerB val in players) { if (!val.isPlayerDead && val.isPlayerControlled) { list.Add(val); } } return list; } internal static void LogTime() { string text = ((TMP_Text)HUDManager.Instance.clockNumber).text; string text2 = text.Replace("\n", "").Replace("\r", ""); Plugin.MoreLogs("TIME: " + text2); } internal static bool TryGetPlayerFromID(ulong playerID, out PlayerControllerB thePlayer) { PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts; foreach (PlayerControllerB val in allPlayerScripts) { if (val.actualClientId == playerID) { thePlayer = val; return true; } } thePlayer = null; return false; } } public class NetHandler : NetworkBehaviour { public static NetHandler Instance { get; private set; } [ServerRpc(RequireOwnership = false)] public void BreatheOnWalkiesServerRpc() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost)) { ServerRpcParams val = default(ServerRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2364017171u, val, (RpcDelivery)0); ((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2364017171u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !((Object)(object)Plugin.instance.DressGirl == (Object)null)) { Plugin.MoreLogs("SERVER: ghost breathing on all walkies"); BreatheOnWalkiesClientRpc(); } } } [ClientRpc] public void BreatheOnWalkiesClientRpc() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost)) { ClientRpcParams val = default(ClientRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3488792323u, val, (RpcDelivery)0); ((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3488792323u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost)) { WalkieStuff.BreatheOnWalkiesFunc(); } } } [ServerRpc(RequireOwnership = false)] public void GarbleWalkiesServerRpc() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost)) { ServerRpcParams val = default(ServerRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1741569032u, val, (RpcDelivery)0); ((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1741569032u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost)) { Plugin.MoreLogs("SERVER: garbling all walkies"); GarbleWalkiesClientRpc(); } } } [ClientRpc] public void GarbleWalkiesClientRpc() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost)) { ClientRpcParams val = default(ClientRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1040546466u, val, (RpcDelivery)0); ((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1040546466u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost)) { WalkieStuff.GarbleAllWalkiesFunc(); } } } [ServerRpc(RequireOwnership = false)] public void ChangeDressGirlToPlayerServerRpc(ulong playerID) { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_0099: Unknown result type (might be due to invalid IL or missing references) //IL_00a3: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_0071: Unknown result type (might be due to invalid IL or missing references) //IL_0089: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost)) { ServerRpcParams val = default(ServerRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3358268268u, val, (RpcDelivery)0); BytePacker.WriteValueBitPacked(val2, playerID); ((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3358268268u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !((Object)(object)Plugin.instance.DressGirl == (Object)null)) { Plugin.MoreLogs($"SERVER: Changing dressgirl to {playerID}"); ChangeDressGirlToPlayerClientRpc(playerID); } } } [ClientRpc] public void ChangeDressGirlToPlayerClientRpc(ulong playerID) { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_0099: Unknown result type (might be due to invalid IL or missing references) //IL_00a3: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_0071: Unknown result type (might be due to invalid IL or missing references) //IL_0089: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager == null || !networkManager.IsListening) { return; } if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost)) { ClientRpcParams val = default(ClientRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2732348508u, val, (RpcDelivery)0); BytePacker.WriteValueBitPacked(val2, playerID); ((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2732348508u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost)) { PlayerControllerB thePlayer; if ((Object)(object)Plugin.instance.DressGirl == (Object)null) { Plugin.MoreLogs("DressGirl instance is null"); } else if (Misc.TryGetPlayerFromID(playerID, out thePlayer)) { Plugin.instance.DressGirl.switchedHauntingPlayer = true; ((MonoBehaviour)Plugin.instance.DressGirl).StartCoroutine(Plugin.instance.DressGirl.setSwitchingHauntingPlayer()); DressGirl.ChangeHauntedPlayer(thePlayer); Plugin.MoreLogs($"Changing haunted player to {playerID}"); } } } [ServerRpc(RequireOwnership = false)] public void FlickerLightsServerRpc(bool flickerFlash, bool disableFlash) { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_00c2: Unknown result type (might be due to invalid IL or missing references) //IL_00cc: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007d: Unknown result type (might be due to invalid IL or missing references) //IL_0083: 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_009e: Unknown result type (might be due to invalid IL or missing references) //IL_00b2: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost)) { ServerRpcParams val = default(ServerRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1489712227u, val, (RpcDelivery)0); ((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flickerFlash, default(ForPrimitives)); ((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref disableFlash, default(ForPrimitives)); ((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1489712227u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost)) { FlickerLightsClientRpc(flickerFlash, disableFlash); } } } [ClientRpc] public void FlickerLightsClientRpc(bool flickerFlash, bool disableFlash) { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_00c2: Unknown result type (might be due to invalid IL or missing references) //IL_00cc: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007d: Unknown result type (might be due to invalid IL or missing references) //IL_0083: 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_009e: Unknown result type (might be due to invalid IL or missing references) //IL_00b2: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost)) { ClientRpcParams val = default(ClientRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(976836047u, val, (RpcDelivery)0); ((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flickerFlash, default(ForPrimitives)); ((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref disableFlash, default(ForPrimitives)); ((NetworkBehaviour)this).__endSendClientRpc(ref val2, 976836047u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost)) { RoundManager.Instance.FlickerLights(flickerFlash, disableFlash); } } } [ServerRpc(RequireOwnership = false)] public void StartRapidFireLightsServerRpc(ulong clientID) { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_0099: Unknown result type (might be due to invalid IL or missing references) //IL_00a3: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_0071: Unknown result type (might be due to invalid IL or missing references) //IL_0089: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost)) { ServerRpcParams val = default(ServerRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2243429670u, val, (RpcDelivery)0); BytePacker.WriteValueBitPacked(val2, clientID); ((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2243429670u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost)) { StartRapidFireLightsClientRpc(clientID); } } } [ClientRpc] public void StartRapidFireLightsClientRpc(ulong clientID) { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_0099: Unknown result type (might be due to invalid IL or missing references) //IL_00a3: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_0071: Unknown result type (might be due to invalid IL or missing references) //IL_0089: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost)) { ClientRpcParams val = default(ClientRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3441652457u, val, (RpcDelivery)0); BytePacker.WriteValueBitPacked(val2, clientID); ((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3441652457u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && Misc.TryGetPlayerFromID(clientID, out var thePlayer)) { Plugin.Spam("Starting RapidFireLight sequence from - " + thePlayer.playerUsername); ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Lights.PoweredLightsColor(thePlayer)); ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Lights.FlickerPoweredLights(thePlayer)); } } } [ServerRpc(RequireOwnership = false)] public void EndRapidFireLightsServerRpc() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost)) { ServerRpcParams val = default(ServerRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(801715303u, val, (RpcDelivery)0); ((NetworkBehaviour)this).__endSendServerRpc(ref val2, 801715303u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost)) { EndRapidFireLightsClientRpc(); } } } [ClientRpc] public void EndRapidFireLightsClientRpc() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost)) { ClientRpcParams val = default(ClientRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1901599655u, val, (RpcDelivery)0); ((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1901599655u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost)) { Bools.lightsFlickering = false; Lights.warningLights = false; } } } [ServerRpc(RequireOwnership = false)] public void FacilityBreakerServerRpc() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost)) { ServerRpcParams val = default(ServerRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1805593341u, val, (RpcDelivery)0); ((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1805593341u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost)) { FacilityBreakerClientRpc(); } } } [ClientRpc] public void FacilityBreakerClientRpc() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager == null || !networkManager.IsListening) { return; } if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost)) { ClientRpcParams val = default(ClientRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1895890339u, val, (RpcDelivery)0); ((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1895890339u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost)) { return; } BreakerBox val3 = Object.FindObjectOfType<BreakerBox>(); if ((Object)(object)val3 != (Object)null) { Plugin.GC.LogInfo((object)"flipping facility breaker for this client"); if (val3.isPowerOn) { val3.SetSwitchesOff(); RoundManager.Instance.TurnOnAllLights(false); GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(0.2f, true); } else { val3.SwitchBreaker(true); RoundManager.Instance.TurnOnAllLights(true); } } } [ServerRpc(RequireOwnership = false)] public void ShockTerminalSoundServerRpc() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost)) { ServerRpcParams val = default(ServerRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1506833215u, val, (RpcDelivery)0); ((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1506833215u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost)) { ShockTerminalSoundClientRpc(); } } } [ClientRpc] public void ShockTerminalSoundClientRpc() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost)) { ClientRpcParams val = default(ClientRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(711897171u, val, (RpcDelivery)0); ((NetworkBehaviour)this).__endSendClientRpc(ref val2, 711897171u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost)) { SoundSystem.PlayTerminalSound(TerminalAdditions.Shock); } } } [ServerRpc(RequireOwnership = false)] public void BatteryAdjustSoundServerRpc(int clientID) { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_0099: Unknown result type (might be due to invalid IL or missing references) //IL_00a3: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_0071: Unknown result type (might be due to invalid IL or missing references) //IL_0089: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager != null && networkManager.IsListening) { if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost)) { ServerRpcParams val = default(ServerRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1275206633u, val, (RpcDelivery)0); BytePacker.WriteValueBitPacked(val2, clientID); ((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1275206633u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost)) { BatteryAdjustSoundClientRpc(clientID); } } } [ClientRpc] public void BatteryAdjustSoundClientRpc(int clientID) { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_0099: Unknown result type (might be due to invalid IL or missing references) //IL_00a3: Invalid comparison between Unknown and I4 //IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references) //IL_0071: Unknown result type (might be due to invalid IL or missing references) //IL_0089: Unknown result type (might be due to invalid IL or missing references) NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager; if (networkManager == null || !networkManager.IsListening) { return; } if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost)) { ClientRpcParams val = default(ClientRpcParams); FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(224827583u, val, (RpcDelivery)0); BytePacker.WriteValueBitPacked(val2, clientID); ((NetworkBehaviour)this).__endSendClientRpc(ref val2, 224827583u, val, (RpcDelivery)0); } if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost)) { int clientID2 = clientID; PlayerControllerB val3 = Misc.GetAllLivingPlayers().Find((PlayerControllerB x) => (int)x.actualClientId == clientID2); val3.itemAudio.PlayOneShot(Items.Adjuster, 0.8f); } } [ServerRpc(RequireOwnership = false)] public void BatteryAdjustServerRpc(int clientID) { //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Invalid comparison between Unknown and I4 //IL_0099: Unknown result type (might be due to invalid IL or missing references) //IL_00a3: Invalid comparison between Unknown and I4 //IL_005f: Unknown result type (mi

Lethal Company

ghostCodes

Details

Categories

ghostCodes.dll

Categories

ghostCodes.dll

Categories