using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using HarmonyLib;
using JetBrains.Annotations;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using NewSafetyHelp;
using NewSafetyHelp.ARG;
using NewSafetyHelp.Audio;
using NewSafetyHelp.Audio.AudioPatches;
using NewSafetyHelp.Audio.Music.Data;
using NewSafetyHelp.Audio.Music.Intermission;
using NewSafetyHelp.Callers.CallerHelpers;
using NewSafetyHelp.Callers.CallerModel;
using NewSafetyHelp.Callers.UI.AnimatedEntry;
using NewSafetyHelp.CustomCampaignSystem;
using NewSafetyHelp.CustomCampaignSystem.Abstract;
using NewSafetyHelp.CustomCampaignSystem.CustomCampaignModel;
using NewSafetyHelp.CustomCampaignSystem.CustomComputer3DScreen;
using NewSafetyHelp.CustomCampaignSystem.CustomRingtone;
using NewSafetyHelp.CustomCampaignSystem.CustomTextFiles;
using NewSafetyHelp.CustomCampaignSystem.CutsceneLogic;
using NewSafetyHelp.CustomCampaignSystem.Helper;
using NewSafetyHelp.CustomCampaignSystem.Helper.AccuracyHelpers;
using NewSafetyHelp.CustomCampaignSystem.Helper.AccuracyModel;
using NewSafetyHelp.CustomCampaignSystem.Helper.CallerRequirementHelper;
using NewSafetyHelp.CustomCampaignSystem.LinkApps;
using NewSafetyHelp.CustomCampaignSystem.Modifier.Data;
using NewSafetyHelp.CustomCampaignSystem.Saving;
using NewSafetyHelp.CustomCampaignSystem.Themes;
using NewSafetyHelp.CustomCampaignSystem.TimedCaller;
using NewSafetyHelp.CustomDesktop;
using NewSafetyHelp.CustomDesktop.CustomDoubleClickButton;
using NewSafetyHelp.CustomDesktop.Utils;
using NewSafetyHelp.CustomThemes;
using NewSafetyHelp.CustomVideos;
using NewSafetyHelp.Emails;
using NewSafetyHelp.EntryManager;
using NewSafetyHelp.EntryManager.EntryData;
using NewSafetyHelp.EntryManager.EntryUnlocker;
using NewSafetyHelp.ErrorDebugging;
using NewSafetyHelp.HelperFunctions;
using NewSafetyHelp.ImportFiles;
using NewSafetyHelp.InGameSettings;
using NewSafetyHelp.JSONParsing;
using NewSafetyHelp.JSONParsing.CCParsing;
using NewSafetyHelp.JSONParsing.EntryParsing;
using NewSafetyHelp.JSONParsing.ParsingHelpers;
using NewSafetyHelp.LoggingSystem;
using NewSafetyHelp.VersionChecker;
using Newtonsoft.Json.Linq;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Profiling;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("NewSafetyHelp")]
[assembly: AssemblyDescription("A mod for Home Safety Hotline, which allows adding new features and campaigns.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("NewSafetyHelp")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9e2a6c17-9bee-4db1-a42f-f7c09a8601d6")]
[assembly: AssemblyFileVersion("2.6.0")]
[assembly: MelonInfo(typeof(NewSafetyHelpMainClass), "NewSafetyHelp", "2.6.0", "Gasterbuzzer", "https://github.com/Gasterbuzzer/NewSafetyHelp/releases/")]
[assembly: MelonAuthorColor(1, 208, 12, 252)]
[assembly: MelonGame("Night Signal Entertainment", "Home Safety Hotline")]
[assembly: MelonPriority(99)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("2.6.0.0")]
namespace NewSafetyHelp
{
	public class NewSafetyHelpMainClass : MelonMod
	{
		public override void OnInitializeMelon()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			GlobalPreferences.InitializeMelonPreferences();
			Application.logMessageReceived += new LogCallback(UnityLogHook.HandleUnityLog);
			AsyncVersionChecker.CheckForUpdates();
		}

		public override void OnLateInitializeMelon()
		{
			EmbedHelpers.DeleteTempFiles();
			if (GlobalPreferences.SkipComputerScene.Value)
			{
				SceneManager.LoadScene("MainMenuScene");
			}
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			LoggingHelper.DebugLog(() => $"Scene {sceneName} with build index {buildIndex} has been loaded!");
			MelonPreferences.Save();
		}
	}
	[HarmonyPatch(typeof(EntryUnlockController), "Awake")]
	public static class MainClassForMonsterEntries
	{
		public static bool ShowUpdateMessage = false;

		private static bool isInitializedMainOnce = false;

		public static bool AddedEntriesToCustomCampaign = false;

		public static MonsterProfile[] CopyMonsterProfiles;

		private static int monsterProfileSize = 0;

		public static readonly List<MonsterProfile[]> CopyTierUnlocks = new List<MonsterProfile[]>();

		public static readonly List<MonsterProfile[]> CopyXmasTier = new List<MonsterProfile[]>();

		private static MonsterProfile[] copyMonsterProfilesAfterAdding;

		private static int monsterProfileSizeAfterAdding = 0;

		private static void Postfix(EntryUnlockController __instance)
		{
			if (!CustomCampaignGlobal.InCustomCampaign)
			{
				if (AddedEntriesToCustomCampaign)
				{
					AddedEntriesToCustomCampaign = false;
					__instance.allEntries.monsterProfiles = copyMonsterProfilesAfterAdding;
				}
				if (isInitializedMainOnce)
				{
					LoggingHelper.DebugLog("Custom Entries were already added. Skipping adding them again. (This happens on scene reload).");
					return;
				}
				CopyMonsterProfiles = __instance.allEntries.monsterProfiles;
				monsterProfileSize = CopyMonsterProfiles.Length;
				CopyTierUnlocks.Add(__instance.firstTierUnlocks.monsterProfiles);
				CopyTierUnlocks.Add(__instance.secondTierUnlocks.monsterProfiles);
				CopyTierUnlocks.Add(__instance.thirdTierUnlocks.monsterProfiles);
				CopyTierUnlocks.Add(__instance.fourthTierUnlocks.monsterProfiles);
				CopyTierUnlocks.Add(__instance.fifthTierUnlocks.monsterProfiles);
				CopyTierUnlocks.Add(__instance.sixthTierUnlocks.monsterProfiles);
				CopyXmasTier.Add(__instance.xmastFirstTier.monsterProfiles);
				CopyXmasTier.Add(__instance.xmasSecondTier.monsterProfiles);
				CopyXmasTier.Add(__instance.xmasThirdTier.monsterProfiles);
				CopyXmasTier.Add(__instance.xmasFourthTier.monsterProfiles);
				StartingJSONParsing(__instance);
			}
			else
			{
				CustomCampaignInitialization(__instance);
			}
		}

		private static void CustomCampaignInitialization(EntryUnlockController __instance)
		{
			if (AddedEntriesToCustomCampaign)
			{
				return;
			}
			if (CopyMonsterProfiles.Length == 0 || monsterProfileSize <= 0)
			{
				LoggingHelper.CriticalErrorLog("Loading of old values to add the entries to failed! (Count == 0)");
				return;
			}
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign != null)
			{
				if (activeCustomCampaign.RemoveExistingEntries)
				{
					__instance.allEntries.monsterProfiles = Array.Empty<MonsterProfile>();
				}
				else if (activeCustomCampaign.UseDLCEntries)
				{
					LoggingHelper.DebugLog("Using DLC monster profiles.");
					__instance.allEntries.monsterProfiles = __instance.allXmasEntries.monsterProfiles;
				}
				else
				{
					__instance.allEntries.monsterProfiles = CopyMonsterProfiles;
				}
				LoggingHelper.InfoLog("Entries are now being added... (Custom Campaign)", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Green);
				CustomCampaignGlobal.ReplaceAllProvidedCampaignEntries(ref __instance.allEntries);
				CustomCampaignGlobal.AddAllCustomCampaignEntriesToArray(ref __instance.allEntries);
				AddedEntriesToCustomCampaign = true;
				LoggingHelper.InfoLog("Added/Modified all custom entries successfully! (Custom Campaign)", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Green);
			}
		}

		public static void StartingJSONParsing(EntryUnlockController __instance)
		{
			LoggingHelper.InfoLog("Now parsing all '.json' files...", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Green);
			ParseJSONFiles.LoadAllJSON(__instance);
			copyMonsterProfilesAfterAdding = __instance.allEntries.monsterProfiles;
			monsterProfileSizeAfterAdding = copyMonsterProfilesAfterAdding.Length;
			isInitializedMainOnce = true;
			LoggingHelper.InfoLog("Loaded all '.json' files successfully!", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Green);
		}
	}
}
namespace NewSafetyHelp.VersionChecker
{
	public static class AsyncVersionChecker
	{
		private static Version GetCurrentVersion()
		{
			return Assembly.GetExecutingAssembly().GetName().Version;
		}

		private static bool IsOutDatedVersion(Version currentVersion, Version newVersion)
		{
			LoggingHelper.DebugLog($"Checking for outdated version with current version '{currentVersion}' and the new version '{newVersion}'. " + $"(Equal?: {currentVersion == newVersion}) " + $"(Newer available? {currentVersion < newVersion}) " + $"(Current version newer?: {currentVersion > newVersion})");
			return currentVersion < newVersion;
		}

		[CanBeNull]
		private static Version ParseVersionTag(string tag)
		{
			if (string.IsNullOrEmpty(tag) || string.IsNullOrWhiteSpace(tag) || tag == "NO_VERSION_FOUND")
			{
				return null;
			}
			tag = tag.Trim();
			if (tag.StartsWith("v", StringComparison.OrdinalIgnoreCase))
			{
				tag = tag.Substring(1);
			}
			Version.TryParse(tag, out Version result);
			return result;
		}

		private static async Task<Version> GetLatestReleaseVersionAsync()
		{
			HttpClient http = new HttpClient();
			try
			{
				http.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("NewSafetyHelp-Mod", GetCurrentVersion().ToString()));
				http.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.github+json"));
				HttpResponseMessage resp = await http.GetAsync("https://api.github.com/repos/Gasterbuzzer/NewSafetyHelp/releases/latest");
				if (!resp.IsSuccessStatusCode)
				{
					LoggingHelper.WarningLog($"GitHub API returned error code {resp.StatusCode}. " + "Could not check for updates.");
					return null;
				}
				JObject jsonObjectParsed = JObject.Parse(await resp.Content.ReadAsStringAsync());
				string tag = "NO_VERSION_FOUND";
				if (jsonObjectParsed["tag_name"] != null)
				{
					tag = (string)jsonObjectParsed["tag_name"];
				}
				else if (jsonObjectParsed["name"] != null)
				{
					tag = (string)jsonObjectParsed["name"];
				}
				Version parsedVersion = ParseVersionTag(tag);
				if (parsedVersion == null)
				{
					LoggingHelper.WarningLog("Was unable of parsing version number. Failed check.");
					return null;
				}
				return parsedVersion;
			}
			finally
			{
				((IDisposable)http)?.Dispose();
			}
		}

		public static void ShowUpdateMessage()
		{
			string text = "NEW VERSION AVAILABLE! Download through your preferred method.";
			MelonLogger.Msg(ConsoleColor.White, "------------------------");
			MelonLogger.Msg(ConsoleColor.Blue, "------------------------");
			MelonLogger.Msg(ConsoleColor.Yellow, "------------------------");
			MelonLogger.Msg(ConsoleColor.Magenta, "\n\n\n");
			MelonLogger.Msg(ConsoleColor.Magenta, text);
			MelonLogger.Msg(ConsoleColor.Red, text);
			MelonLogger.Msg(ConsoleColor.Magenta, text);
			MelonLogger.Msg(ConsoleColor.Magenta, "\n\n\n");
			MelonLogger.Msg(ConsoleColor.Yellow, "------------------------");
			MelonLogger.Msg(ConsoleColor.Blue, "------------------------");
			MelonLogger.Msg(ConsoleColor.White, "------------------------");
		}

		public static async Task CheckForUpdates()
		{
			Version newestVersion = await GetLatestReleaseVersionAsync();
			if (newestVersion == null)
			{
				LoggingHelper.WarningLog("Unable of checking if there is a new version available. Check your internet connection.");
			}
			else if (IsOutDatedVersion(GetCurrentVersion(), newestVersion))
			{
				MainClassForMonsterEntries.ShowUpdateMessage = true;
				ShowUpdateMessage();
			}
		}
	}
}
namespace NewSafetyHelp.MainGameBugFixes
{
	public static class CloseErrorPopupFix
	{
		[HarmonyPatch(typeof(GenericErrorPopupBehavior), "ExitButton")]
		public static class ExitButtonFix
		{
			private static bool Prefix(GenericErrorPopupBehavior __instance)
			{
				__instance.ConfirmButton();
				return false;
			}
		}

		[HarmonyPatch(typeof(GenericErrorPopupBehavior), "OnEnable")]
		public static class OnEnableFix
		{
			private static void Prefix(GenericErrorPopupBehavior __instance)
			{
				GameObject gameObject = ((Component)((Component)__instance).transform.Find("WindowsBar").Find("CloseButton")).gameObject;
				if ((Object)(object)gameObject != (Object)null && gameObject.GetComponents<Button>().Length >= 2)
				{
					Object.Destroy((Object)(object)gameObject.GetComponent<Button>());
				}
			}
		}

		[HarmonyPatch(typeof(SubmitWindowBehavior), "OnEnable")]
		public static class SubmitAnswerCloseButtonFix
		{
			private static readonly MethodInfo PopulateDropdownList = typeof(SubmitWindowBehavior).GetMethod("PopulateDropdownList", BindingFlags.Instance | BindingFlags.NonPublic);

			private static bool Prefix(SubmitWindowBehavior __instance)
			{
				GameObject gameObject = ((Component)((Component)__instance).transform.Find("WindowsBar").Find("CloseButton")).gameObject;
				if ((Object)(object)gameObject != (Object)null && gameObject.GetComponents<Button>().Length >= 2)
				{
					Object.Destroy((Object)(object)gameObject.GetComponent<Button>());
				}
				__instance.answerToSubmit = null;
				__instance.submitButton.SetActive(true);
				__instance.loadingText.SetActive(false);
				PopulateDropdownList.Invoke(__instance, null);
				return false;
			}
		}
	}
	public static class EmailLoadingBugFix
	{
		[HarmonyPatch(typeof(EmailWindowBehavior), "DisplayEmail", new Type[] { typeof(Email) })]
		public static class DisplayEmailPatch
		{
			private static readonly int ScreenLoad = Animator.StringToHash("ScreenLoad");

			private static readonly MethodInfo UpdateLayoutGroupMethod = typeof(EmailWindowBehavior).GetMethod("UpdateLayoutGroup", BindingFlags.Instance | BindingFlags.NonPublic);

			private static bool Prefix(EmailWindowBehavior __instance, ref Email emailToDisplay)
			{
				//IL_030f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0314: Unknown result type (might be due to invalid IL or missing references)
				if (UpdateLayoutGroupMethod == null)
				{
					LoggingHelper.ReflectionError("UpdateLayoutGroupMethod");
					return true;
				}
				if ((Object)(object)__instance.selectedEmail != (Object)null)
				{
					string text = "<b>Subject Line: " + __instance.selectedEmail.subjectLine + "</b> \n\nFrom: " + __instance.selectedEmail.sender + "\n\n\n" + __instance.selectedEmail.emailBody;
					if (((TMP_Text)__instance.displayedEmailBody).text.Equals(text))
					{
						if (!((Object)(object)__instance.selectedEmail.imageAttachment != (Object)null))
						{
							return false;
						}
						if (((object)__instance.displayedImage.sprite).Equals((object?)__instance.selectedEmail.imageAttachment))
						{
							return false;
						}
					}
					((TMP_Text)__instance.displayedEmailBody).text = text;
					bool flag = false;
					if (CustomCampaignGlobal.InCustomCampaign)
					{
						CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
						if (activeCustomCampaign == null)
						{
							return true;
						}
						CustomEmail customEmail = CustomCampaignGlobal.GetCustomEmailFromActiveCampaign(__instance.selectedEmail);
						LoggingHelper.DebugLog(() => "Trying to find associated custom email. Did we find a custom email? " + $"{customEmail != null}.", LoggingHelper.LoggingCategory.EMAIL);
						if (customEmail != null)
						{
							if (customEmail.HasAnimatedVideo)
							{
								LoggingHelper.DebugLog(() => "Playing email video: '" + customEmail.EmailAnimatedVideo + "'.", LoggingHelper.LoggingCategory.EMAIL);
								EmailHelper.SetVideoUrlEmail(customEmail.EmailAnimatedVideo);
								if (customEmail.EmailAnimatedVideoShouldLoop.HasChanged)
								{
									EmailHelper.SetLoopInAnimatedImage(customEmail.EmailAnimatedVideoShouldLoop.Data);
								}
								else
								{
									EmailHelper.SetLoopInAnimatedImage(shouldLoop: true);
								}
								flag = true;
							}
							else
							{
								EmailHelper.RestoreEmailPortrait();
							}
							EmailHelper.SetClickUrlToOpen(customEmail.EmailClickURL == null, customEmail.EmailClickURL, customEmail.HasAnimatedVideo);
						}
						else
						{
							EmailHelper.RestoreEmailPortrait();
							EmailHelper.DisableEmailImageCursorHover();
						}
					}
					if (flag || (Object)(object)__instance.selectedEmail.imageAttachment != (Object)null)
					{
						((Component)((Component)__instance.displayedImage).transform.parent).gameObject.SetActive(true);
					}
					else
					{
						((Component)((Component)__instance.displayedImage).transform.parent).gameObject.SetActive(false);
					}
					if ((Object)(object)__instance.selectedEmail.imageAttachment != (Object)null)
					{
						__instance.displayedImage.sprite = __instance.selectedEmail.imageAttachment;
					}
				}
				else
				{
					((TMP_Text)__instance.displayedEmailBody).text = "No Message to Display.";
					((Component)((Component)__instance.displayedImage).transform.parent).gameObject.SetActive(false);
				}
				AnimatorStateInfo currentAnimatorStateInfo = __instance.loadingHiderAnimator.GetCurrentAnimatorStateInfo(0);
				if (!((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsName("ScreenLoad") && !__instance.loadingHiderAnimator.IsInTransition(0))
				{
					__instance.loadingHiderAnimator.SetTrigger(ScreenLoad);
				}
				else
				{
					__instance.loadingHiderAnimator.ResetTrigger(ScreenLoad);
					__instance.loadingHiderAnimator.Play(ScreenLoad, 0, 0f);
				}
				__instance.previewScrollbar.value = 1f;
				IEnumerator enumerator = (IEnumerator)UpdateLayoutGroupMethod.Invoke(__instance, new object[1] { __instance.inboxLayoutGroup });
				((MonoBehaviour)__instance).StartCoroutine(enumerator);
				return false;
			}
		}
	}
	public static class EntryLoadingBuxFix
	{
		[HarmonyPatch(typeof(MainCanvasBehavior), "UpdateSelectedEntry", new Type[] { typeof(MonsterProfile) })]
		public static class MainCanvasUpdateSelectedEntryPatch
		{
			private static readonly MethodInfo IsNetworkDown = typeof(MainCanvasBehavior).GetMethod("IsNetworkDown", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

			private static readonly MethodInfo SelectMonsterPortrait = typeof(MainCanvasBehavior).GetMethod("SelectMonsterPortrait", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

			private static readonly MethodInfo UpdateLayoutGroupMethod = typeof(MainCanvasBehavior).GetMethod("UpdateLayoutGroup", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

			private static bool Prefix(MainCanvasBehavior __instance, ref MonsterProfile profile)
			{
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Expected O, but got Unknown
				//IL_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
				if (SelectMonsterPortrait == null || IsNetworkDown == null || UpdateLayoutGroupMethod == null)
				{
					LoggingHelper.ReflectionError("IsNetworkDown", "SelectMonsterPortrait", "UpdateLayoutGroupMethod");
					return true;
				}
				if ((Object)(object)__instance.selectedMonsterProfile != (Object)null && ((object)__instance.selectedMonsterProfile).Equals((object?)profile))
				{
					return false;
				}
				__instance.selectedMonsterProfile = profile;
				if ((bool)IsNetworkDown.Invoke(__instance, null))
				{
					profile = __instance.errorProfile;
					__instance.cameraAnimator.SetTrigger(Glitch);
				}
				((Component)__instance.selectedMonsterPortraitImage).gameObject.SetActive(false);
				__instance.monsterAudioSamplePlayer.SetActive(false);
				if ((Object)(object)profile.monsterPortrait != (Object)null)
				{
					((Component)__instance.selectedMonsterPortraitImage).gameObject.SetActive(true);
					__instance.selectedMonsterPortraitImage.sprite = (Sprite)SelectMonsterPortrait.Invoke(__instance, new object[1] { profile });
					if (hasActiveEasterEgg)
					{
						((Graphic)__instance.selectedMonsterPortraitImage).color = Color.white;
						MelonCoroutines.Stop(easterEggCoroutine);
						hasActiveEasterEgg = false;
					}
					if (((Object)__instance.selectedMonsterProfile).name == "Boggart")
					{
						easterEggCoroutine = MelonCoroutines.Start(EasterEgg(delegate
						{
							//IL_0021: Unknown result type (might be due to invalid IL or missing references)
							LoggingHelper.DebugLog("Easter Egg!");
							((Graphic)__instance.selectedMonsterPortraitImage).color = Color.red;
						}));
					}
				}
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					EntryMetadata entryFromActiveCampaign = CustomCampaignGlobal.GetEntryFromActiveCampaign(profile.monsterName);
					if (entryFromActiveCampaign != null && entryFromActiveCampaign.IsVideoPortrait)
					{
						((Component)__instance.selectedMonsterPortraitImage).gameObject.SetActive(true);
						MainCanvasEntry.SetVideoUrl(entryFromActiveCampaign.VideoUrlPortrait, MainCanvasEntry.PortraitType.ENTRY);
						if (entryFromActiveCampaign.VideoPortraitShouldLoop.HasChanged)
						{
							MainCanvasEntry.SetVideoLoop(entryFromActiveCampaign.VideoPortraitShouldLoop.Data, MainCanvasEntry.PortraitType.ENTRY);
						}
					}
					else
					{
						MainCanvasEntry.RestorePortrait(MainCanvasEntry.PortraitType.ENTRY);
						MainCanvasEntry.SetVideoLoop(shouldLoop: true, MainCanvasEntry.PortraitType.ENTRY);
					}
				}
				if ((Object)(object)profile.monsterAudioClip != (Object)null)
				{
					__instance.monsterAudioSamplePlayer.SetActive(true);
				}
				((TMP_Text)__instance.selectedMonsterTitle).text = profile.monsterName;
				((TMP_Text)__instance.selectedMonsterDescription).text = profile.monsterDescription;
				AnimatorStateInfo currentAnimatorStateInfo = __instance.screenLoader.GetCurrentAnimatorStateInfo(0);
				if (!((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsName("ScreenLoad") && !__instance.screenLoader.IsInTransition(0))
				{
					__instance.screenLoader.SetTrigger(ScreenLoad);
				}
				else
				{
					__instance.screenLoader.ResetTrigger(ScreenLoad);
					__instance.screenLoader.Play(ScreenLoad, 0, 0f);
				}
				IEnumerator enumerator = (IEnumerator)UpdateLayoutGroupMethod.Invoke(__instance, new object[1] { __instance.mainEntryLayoutGroup });
				((MonoBehaviour)__instance).StartCoroutine(enumerator);
				if ((Object)(object)GlobalVariables.UISoundControllerScript != (Object)null)
				{
					GlobalVariables.UISoundControllerScript.myMonsterSampleAudioSource.Stop();
				}
				__instance.selectedEntryScrollbar.value = 1f;
				return false;
			}

			private static IEnumerator EasterEgg(Action updateSpriteAction)
			{
				hasActiveEasterEgg = true;
				yield return (object)new WaitForSeconds(603f);
				updateSpriteAction();
			}
		}

		[HarmonyPatch(typeof(EntryCanvasStandaloneBehavior), "UpdateSelectedEntry", new Type[] { typeof(MonsterProfile) })]
		public static class EntryCanvasUpdateSelectedEntryPatch
		{
			private static readonly MethodInfo SelectMonsterPortrait = typeof(EntryCanvasStandaloneBehavior).GetMethod("SelectMonsterPortrait", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

			private static readonly MethodInfo UpdateLayoutGroupMethod = typeof(EntryCanvasStandaloneBehavior).GetMethod("UpdateLayoutGroup", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

			private static bool Prefix(EntryCanvasStandaloneBehavior __instance, ref MonsterProfile profile)
			{
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Expected O, but got Unknown
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				if (SelectMonsterPortrait == null || UpdateLayoutGroupMethod == null)
				{
					LoggingHelper.ReflectionError("SelectMonsterPortrait", "UpdateLayoutGroupMethod");
					return true;
				}
				if ((Object)(object)__instance.selectedMonsterProfile != (Object)null && ((object)__instance.selectedMonsterProfile).Equals((object?)profile))
				{
					return false;
				}
				__instance.selectedMonsterProfile = profile;
				((Component)__instance.selectedMonsterPortraitImage).gameObject.SetActive(false);
				__instance.monsterAudioSamplePlayer.SetActive(false);
				if ((Object)(object)profile.monsterPortrait != (Object)null)
				{
					((Component)__instance.selectedMonsterPortraitImage).gameObject.SetActive(true);
					__instance.selectedMonsterPortraitImage.sprite = (Sprite)SelectMonsterPortrait.Invoke(__instance, new object[1] { profile });
				}
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					EntryMetadata entryFromActiveCampaign = CustomCampaignGlobal.GetEntryFromActiveCampaign(profile.monsterName);
					if (entryFromActiveCampaign != null && entryFromActiveCampaign.IsVideoPortrait)
					{
						((Component)__instance.selectedMonsterPortraitImage).gameObject.SetActive(true);
						EntryCanvasStandaloneEntry.SetVideoUrlEntryStandaloneCanvas(entryFromActiveCampaign.VideoUrlPortrait);
					}
					else
					{
						EntryCanvasStandaloneEntry.RestoreNormalPortrait();
					}
				}
				if ((Object)(object)profile.monsterAudioClip != (Object)null)
				{
					__instance.monsterAudioSamplePlayer.SetActive(true);
				}
				((TMP_Text)__instance.selectedMonsterTitle).text = profile.monsterName;
				((TMP_Text)__instance.selectedMonsterDescription).text = profile.monsterDescription;
				AnimatorStateInfo currentAnimatorStateInfo = __instance.screenLoader.GetCurrentAnimatorStateInfo(0);
				if (!((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsName("ScreenLoad") && !__instance.screenLoader.IsInTransition(0))
				{
					__instance.screenLoader.SetTrigger(ScreenLoad);
				}
				else
				{
					__instance.screenLoader.ResetTrigger(ScreenLoad);
					__instance.screenLoader.Play(ScreenLoad, 0, 0f);
				}
				IEnumerator enumerator = (IEnumerator)UpdateLayoutGroupMethod.Invoke(__instance, new object[1] { __instance.mainEntryLayoutGroup });
				((MonoBehaviour)__instance).StartCoroutine(enumerator);
				if ((Object)(object)GlobalVariables.UISoundControllerScript != (Object)null)
				{
					GlobalVariables.UISoundControllerScript.myMonsterSampleAudioSource.Stop();
				}
				__instance.selectedEntryScrollbar.value = 1f;
				return false;
			}
		}

		private static readonly int ScreenLoad = Animator.StringToHash("ScreenLoad");

		private static readonly int Glitch = Animator.StringToHash("glitch");

		private static object easterEggCoroutine;

		private static bool hasActiveEasterEgg;
	}
	public static class EntryViewNotUpdating
	{
		[HarmonyPatch(typeof(OptionsExecutable), "Open")]
		public static class UpdateListDesktop
		{
			private static readonly MethodInfo StartMethod = typeof(EntryCanvasStandaloneBehavior).GetMethod("Start", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static void Prefix(OptionsExecutable __instance)
			{
				if (((Object)__instance.myPopup).name == "EntryCanvasStandalone")
				{
					if (StartMethod == null)
					{
						LoggingHelper.ReflectionError("StartMethod");
					}
					else
					{
						StartMethod.Invoke(__instance.myPopup.GetComponent<EntryCanvasStandaloneBehavior>(), null);
					}
				}
			}
		}
	}
	public static class ScreenResolutionBugFix
	{
		[HarmonyPatch(typeof(ScreenResolutions), "SetMenuValue", new Type[]
		{
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		public static class FixScreenResolutionOptions
		{
			private static bool Prefix(ScreenResolutions __instance, ref int width, ref int height, ref int refresh)
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				FieldInfo field = typeof(ScreenResolutions).GetField("resolutions", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (field == null)
				{
					LoggingHelper.ErrorLog("ScreenResolutions field not found. Unable of patching out bug. Defaulting to normal function.");
					return true;
				}
				Resolution[] array = (Resolution[])field.GetValue(__instance);
				if (array.Length == 0)
				{
					LoggingHelper.ErrorLog("ScreenResolutions field was empty. Unable of patching out bug. Defaulting to normal function.");
					return true;
				}
				for (int i = 0; i < array.Length; i++)
				{
					Resolution val = array[i];
					if (((Resolution)(ref val)).width == width && ((Resolution)(ref val)).height == height && ((Resolution)(ref val)).refreshRate == refresh)
					{
						if (i >= __instance.dropdownMenu.options.Count)
						{
							__instance.dropdownMenu.value = i;
						}
						else
						{
							__instance.dropdownMenu.value = i;
							__instance.dropdownMenu.captionText.text = __instance.dropdownMenu.options[i].text;
						}
						return false;
					}
				}
				return false;
			}
		}
	}
	public static class UISoundBugFix
	{
		[HarmonyPatch(typeof(UISoundController), "FadeInLoopingSound", new Type[]
		{
			typeof(RichAudioClip),
			typeof(AudioSource),
			typeof(float)
		})]
		public static class FadeInLoopingSoundBugFix
		{
			private static bool Prefix(UISoundController __instance, ref IEnumerator __result, ref RichAudioClip myRichClip, ref AudioSource mySource, ref float interpolaterScalar)
			{
				__result = FadeInLoopingSoundChanged(__instance, myRichClip, mySource, interpolaterScalar);
				return false;
			}

			private static IEnumerator FadeInLoopingSoundChanged(UISoundController __instance, RichAudioClip myRichClip, AudioSource mySource, float interpolaterScalar)
			{
				if ((Object)(object)mySource == (Object)null)
				{
					yield break;
				}
				if (!Object.op_Implicit((Object)(object)mySource))
				{
					if (!((Object)(object)myRichClip.clip == (Object)null))
					{
						__instance.myLoopingSource.clip = myRichClip.clip;
						__instance.myLoopingSource.volume = 0f;
						__instance.myLoopingSource.Play();
						float interpolater = 0f;
						while (__instance.myLoopingSource.volume < myRichClip.volume)
						{
							__instance.myLoopingSource.volume = Mathf.Lerp(0f, myRichClip.volume, interpolater);
							interpolater += interpolaterScalar * Time.deltaTime;
							yield return null;
						}
						__instance.myLoopingSource.volume = myRichClip.volume;
					}
				}
				else
				{
					LoggingHelper.DebugLog($"[UNITY] {mySource} is fading in.");
					mySource.clip = myRichClip.clip;
					mySource.volume = 0f;
					mySource.Play();
					float interpolater = 0f;
					while (mySource.volume < myRichClip.volume)
					{
						mySource.volume = Mathf.Lerp(0f, myRichClip.volume, interpolater);
						interpolater += interpolaterScalar * Time.deltaTime;
						yield return null;
					}
					mySource.volume = myRichClip.volume;
				}
			}
		}
	}
}
namespace NewSafetyHelp.LoggingSystem
{
	public static class LoggingHelper
	{
		public enum LoggingCategory
		{
			NONE,
			SKIPPED_CALLER,
			THEME,
			RINGTONE,
			EMAIL,
			VIDEO,
			TEXT_FILE,
			ENTRY,
			CUTSCENE,
			MEMORY,
			LINK_APP
		}

		private enum LoggingLevel
		{
			ERROR,
			CRITICAL_ERROR,
			WARNING,
			INFO,
			DEBUG,
			DEBUG_WARNING
		}

		private static bool CheckLoggingCategory(LoggingCategory loggingCategory = LoggingCategory.NONE, bool checkDebugLog = false)
		{
			if (checkDebugLog && !GlobalPreferences.ShowDebugLogs.Value)
			{
				return false;
			}
			switch (loggingCategory)
			{
			case LoggingCategory.SKIPPED_CALLER:
				if (!GlobalPreferences.ShowSkippedCallerDebugLog.Value)
				{
					return false;
				}
				break;
			case LoggingCategory.THEME:
				if (!GlobalPreferences.ShowThemeDebugLog.Value)
				{
					return false;
				}
				break;
			case LoggingCategory.RINGTONE:
				if (!GlobalPreferences.ShowRingtoneDebugLog.Value)
				{
					return false;
				}
				break;
			case LoggingCategory.EMAIL:
				if (!GlobalPreferences.ShowEmailDebugLog.Value)
				{
					return false;
				}
				break;
			case LoggingCategory.VIDEO:
				if (!GlobalPreferences.ShowVideoDebugLog.Value)
				{
					return false;
				}
				break;
			case LoggingCategory.ENTRY:
				if (!GlobalPreferences.ShowEntryDebugLog.Value)
				{
					return false;
				}
				break;
			case LoggingCategory.TEXT_FILE:
				if (!GlobalPreferences.ShowTextFileDebugLog.Value)
				{
					return false;
				}
				break;
			case LoggingCategory.CUTSCENE:
				if (!GlobalPreferences.ShowDebugLogs.Value)
				{
					return false;
				}
				break;
			case LoggingCategory.MEMORY:
				if (!GlobalPreferences.ShowMemoryLog.Value)
				{
					return false;
				}
				break;
			case LoggingCategory.LINK_APP:
				if (!GlobalPreferences.ShowLinkAppLog.Value)
				{
					return false;
				}
				break;
			}
			return true;
		}

		private static void Log(string loggingMessage, LoggingLevel loggingLevel = LoggingLevel.INFO, ConsoleColor? consoleColor = null)
		{
			switch (loggingLevel)
			{
			case LoggingLevel.ERROR:
				MelonLogger.Error("ERROR: " + loggingMessage);
				break;
			case LoggingLevel.CRITICAL_ERROR:
				MelonLogger.Msg(ConsoleColor.Red, "CRITICAL ERROR: " + loggingMessage);
				break;
			case LoggingLevel.WARNING:
				MelonLogger.Warning("WARNING: " + loggingMessage);
				break;
			case LoggingLevel.INFO:
				if (consoleColor.HasValue)
				{
					MelonLogger.Msg(consoleColor.Value, "INFO: " + loggingMessage);
				}
				else
				{
					MelonLogger.Msg("INFO: " + loggingMessage);
				}
				break;
			case LoggingLevel.DEBUG:
				if (consoleColor.HasValue)
				{
					MelonLogger.Msg(consoleColor.Value, "DEBUG: " + loggingMessage);
				}
				else
				{
					MelonLogger.Msg("DEBUG: " + loggingMessage);
				}
				break;
			case LoggingLevel.DEBUG_WARNING:
				if (consoleColor.HasValue)
				{
					MelonLogger.Msg(consoleColor.Value, "DEBUG WARNING: " + loggingMessage);
				}
				else
				{
					MelonLogger.Msg("DEBUG WARNING: " + loggingMessage);
				}
				break;
			}
		}

		public static void InfoLog(string loggingMessage, LoggingCategory loggingCategory = LoggingCategory.NONE, ConsoleColor? consoleColor = null)
		{
			if (CheckLoggingCategory(loggingCategory))
			{
				Log(loggingMessage, LoggingLevel.INFO, consoleColor);
			}
		}

		public static void InfoLog(Func<string> loggingMessageConstructor, LoggingCategory loggingCategory = LoggingCategory.NONE, ConsoleColor? consoleColor = null)
		{
			if (CheckLoggingCategory(loggingCategory))
			{
				string loggingMessage = loggingMessageConstructor();
				Log(loggingMessage, LoggingLevel.INFO, consoleColor);
			}
		}

		public static void DebugLog(string loggingMessage, LoggingCategory loggingCategory = LoggingCategory.NONE, ConsoleColor? consoleColor = null)
		{
			if (CheckLoggingCategory(loggingCategory, checkDebugLog: true))
			{
				Log(loggingMessage, LoggingLevel.DEBUG, consoleColor);
			}
		}

		public static void DebugLog(Func<string> loggingMessageConstructor, LoggingCategory loggingCategory = LoggingCategory.NONE, ConsoleColor? consoleColor = null)
		{
			if (CheckLoggingCategory(loggingCategory, checkDebugLog: true))
			{
				string loggingMessage = loggingMessageConstructor();
				Log(loggingMessage, LoggingLevel.DEBUG, consoleColor);
			}
		}

		public static void TestLog(string loggingMessage, LoggingCategory loggingCategory = LoggingCategory.NONE)
		{
			if (CheckLoggingCategory(loggingCategory, checkDebugLog: true))
			{
				Log(loggingMessage, LoggingLevel.DEBUG, ConsoleColor.Magenta);
			}
		}

		public static void ErrorLog(string loggingMessage, LoggingCategory loggingCategory = LoggingCategory.NONE)
		{
			if (CheckLoggingCategory(loggingCategory))
			{
				Log(loggingMessage, LoggingLevel.ERROR);
			}
		}

		public static void CriticalErrorLog(string loggingMessage, LoggingCategory loggingCategory = LoggingCategory.NONE)
		{
			if (CheckLoggingCategory(loggingCategory))
			{
				Log(loggingMessage, LoggingLevel.CRITICAL_ERROR);
			}
		}

		public static void WarningLog(string loggingMessage, LoggingCategory loggingCategory = LoggingCategory.NONE)
		{
			if (CheckLoggingCategory(loggingCategory))
			{
				Log(loggingMessage, LoggingLevel.WARNING);
			}
		}

		public static void CampaignNullError()
		{
			ErrorLog("Custom Campaign is null, even though custom campaign is active. Calling either original function or cancelling the current operation.");
		}

		public static void ReflectionError(params string[] differentVariableNames)
		{
			string loggingMessage = "Method or Field reflection failed. Possible variables that failed: '" + string.Join("' '", differentVariableNames) + "'. Calling original function.";
			Log(loggingMessage, LoggingLevel.ERROR);
		}
	}
}
namespace NewSafetyHelp.JSONParsing
{
	public static class GlobalParsingVariables
	{
		public static readonly List<EntryMetadata> EntriesMetadata = new List<EntryMetadata>();

		public static readonly List<CustomTheme> MainGameThemes = new List<CustomTheme>();

		public static readonly List<CustomEmail> MainCampaignEmails = new List<CustomEmail>();

		public static readonly Dictionary<int, CustomCCaller> CustomCallersMainGame = new Dictionary<int, CustomCCaller>();

		public static readonly List<CustomCCaller> PendingCustomCampaignCustomCallers = new List<CustomCCaller>();

		public static List<EntryMetadata> PendingCustomCampaignEntries = new List<EntryMetadata>();

		public static List<EntryMetadata> PendingCustomCampaignReplaceEntries = new List<EntryMetadata>();

		public static List<CustomEmail> PendingCustomCampaignEmails = new List<CustomEmail>();

		public static readonly List<CustomMusic> PendingCustomCampaignMusic = new List<CustomMusic>();

		public static readonly List<CustomModifier> PendingCustomCampaignModifiers = new List<CustomModifier>();

		public static readonly List<CustomTheme> PendingCustomCampaignThemes = new List<CustomTheme>();

		public static List<CustomVideo> PendingCustomCampaignVideos = new List<CustomVideo>();

		public static List<CustomRingtone> PendingCustomCampaignRingtones = new List<CustomRingtone>();

		public static List<CustomTextFile> PendingCustomCampaignTextFile = new List<CustomTextFile>();

		public static List<CustomCutscene> PendingCustomCampaignCutscenes = new List<CustomCutscene>();

		public static List<Computer3DScreen> PendingCustomCampaign3DComputerScreens = new List<Computer3DScreen>();

		public static List<LinkApp> PendingCustomCampaignLinkApps = new List<LinkApp>();

		public static int CustomCampaignEntryIDOffset = 100000;

		public const int MainCampaignCallAmount = 116;
	}
	public static class ParseJSONFiles
	{
		public enum JSONParseTypes
		{
			Campaign,
			Call,
			Entry,
			Email,
			Video,
			Music,
			Modifier,
			Theme,
			Ringtone,
			TextProgram,
			Cutscene,
			Computer3DScreen,
			LinkApp,
			Invalid
		}

		public static void LoadAllJSON(EntryUnlockController __instance)
		{
			Time.timeScale = 0f;
			EmbeddedTimerData.Initialize();
			string userDataFolderPath = FileImporter.GetUserDataFolderPath();
			string[] directories = Directory.GetDirectories(userDataFolderPath);
			string[] array = directories;
			foreach (string modFolderPath in array)
			{
				LoadJsonFilesFromFolder(modFolderPath, __instance);
			}
			foreach (CustomCampaign item in CustomCampaignGlobal.CustomCampaignsAvailable)
			{
				if (item.Emails.Count > 0)
				{
					item.SortEmailsInCustomCampaign();
				}
				if (item.CustomVideos.Count > 0)
				{
					item.SortCustomVideoFiles();
				}
				if (item.CustomCutscenes.Count > 0)
				{
					item.SortCutsceneInCustomCampaign();
				}
				if (item.CustomTextProgramFiles.Count > 0)
				{
					item.SortTextFiles();
				}
				if (item.CustomCallersInCampaign.Count > 0)
				{
					item.SortCustomCallersInCustomCampaign();
				}
				if (item.CustomComputer3DScreens.Count > 0)
				{
					item.SortComputer3DScreens();
				}
				if (item.LinkApps.Count > 0)
				{
					item.SortLinkApps();
				}
			}
			if (AudioImport.CurrentLoadingAudios.Count <= 0)
			{
				Time.timeScale = 1f;
			}
		}

		public static void LoadJsonFilesFromFolder(string modFolderPath, EntryUnlockController __instance)
		{
			string[] files = Directory.GetFiles(modFolderPath, "*.json", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string text in array)
			{
				try
				{
					LoggingHelper.InfoLog("Found new JSON file at '" + text + "', attempting to parse it now.");
					string text2 = File.ReadAllText(text);
					string directoryName = Path.GetDirectoryName(text);
					JObject val = JObject.Parse(text2);
					switch (GetJSONParsingType(val, modFolderPath))
					{
					case JSONParseTypes.Campaign:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a custom campaign.");
						CustomCampaignParsing.CreateCustomCampaign(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.Call:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a custom caller.");
						CustomCallerParsing.CreateCustomCaller(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.Entry:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as an entry (monster).");
						NewSafetyHelp.JSONParsing.EntryParsing.EntryParsing.CreateEntryFromJSON(val, -1, modFolderPath, directoryName, __instance);
						break;
					case JSONParseTypes.Email:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a email.");
						EmailParsing.CreateEmail(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.Video:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a video.");
						VideoParsing.CreateVideo(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.Music:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a music file.");
						MusicParsing.CreateMusic(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.Modifier:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a modifier file.");
						ModifierParsing.CreateModifier(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.Theme:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a theme file.");
						ThemeParsing.CreateTheme(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.Ringtone:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a ringtone file.");
						RingtoneParsing.CreateRingtone(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.TextProgram:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a text file program.");
						TextProgramParsing.CreateTextProgram(val, modFolderPath);
						break;
					case JSONParseTypes.Cutscene:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a cutscene.");
						CutsceneParsing.CreateCutscene(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.Computer3DScreen:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a 3D Computer Screen.");
						Computer3DScreenParsing.Create3DComputerScreen(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.LinkApp:
						LoggingHelper.InfoLog("Provided JSON file at '" + text + "' has been interpreted as a link app.");
						LinkAppParsing.CreateLinkApp(val, modFolderPath, directoryName);
						break;
					case JSONParseTypes.Invalid:
						LoggingHelper.ErrorLog("ERROR: Provided JSON file parsing failed or is not any known provided format.\n(If this intended, you can ignore this, if not, check if you have written your JSON correctly).\nSkipping trying to read this file.");
						break;
					default:
						LoggingHelper.ErrorLog("This error should not happen. Possible file corruption.");
						break;
					}
				}
				catch (Exception ex)
				{
					LoggingHelper.ErrorLog("Failed reading the file '" + text + "'. \n---\nError message: '" + ex.Message + "'. \n---\nError Stacktrace: \n'\n" + ex.StackTrace + "\n'.");
				}
			}
		}

		public static JSONParseTypes GetJSONParsingType(JObject json, string filePath = "")
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if (json == null || (int)((JToken)json).Type != 1 || string.IsNullOrEmpty(filePath))
			{
				return JSONParseTypes.Invalid;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "custom_campaign_name", "custom_campaign_days", "custom_campaign_icon_image_name" }, json))
			{
				return JSONParseTypes.Campaign;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "custom_caller_transcript", "custom_caller_name", "order_in_campaign", "custom_caller_audio_clip_name" }, json))
			{
				return JSONParseTypes.Call;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "monster_name", "replace_entry", "caller_name", "entry_name", "entry_description", "monster_description", "monster_portrait_image_name", "entry_portrait_image_name", "monster_audio_clip_name", "entry_audio_clip_name" }, json))
			{
				return JSONParseTypes.Entry;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "email_subject", "email_in_main_campaign", "email_custom_campaign_name" }, json))
			{
				return JSONParseTypes.Email;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "video_desktop_name", "video_file_name", "video_unlock_day" }, json))
			{
				return JSONParseTypes.Video;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "music_audio_clip_name" }, json))
			{
				return JSONParseTypes.Music;
			}
			if (!ParsingHelper.ContainsKeys(new List<string> { "custom_campaign_name", "custom_campaign_days", "custom_campaign_icon_image_name", "email_subject", "email_in_main_campaign", "email_custom_campaign_name" }, json) && ParsingHelper.ContainsKeys(new List<string> { "modifier_custom_campaign_attached" }, json))
			{
				return JSONParseTypes.Modifier;
			}
			if (!ParsingHelper.ContainsKeys(new List<string> { "custom_campaign_name", "custom_campaign_days", "custom_campaign_icon_image_name", "email_subject", "email_in_main_campaign", "email_custom_campaign_name" }, json) && ParsingHelper.ContainsKeys(new List<string> { "theme_custom_campaign_attached", "theme_name", "title_bar_color", "theme_in_main_campaign" }, json))
			{
				return JSONParseTypes.Theme;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "ringtone_audio_clip_name" }, json))
			{
				return JSONParseTypes.Ringtone;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "text_file_desktop_name", "text_file_unlock_day", "text_file_contents", "text_file_unlock_when_game_finished" }, json))
			{
				return JSONParseTypes.TextProgram;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "cutscene_custom_campaign_name", "custom_cutscene_video_file", "custom_cutscene_priority" }, json))
			{
				return JSONParseTypes.Cutscene;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "computer_3D_screen_custom_campaign_attached", "computer_3D_screen_in_main_campaign", "computer_3D_screen_priority", "computer_3D_screen_skip_click_wait_time" }, json))
			{
				return JSONParseTypes.Computer3DScreen;
			}
			if (ParsingHelper.ContainsKeys(new List<string> { "link_app_custom_campaign_name", "link_app_unlock_day", "link_app_unlock_when_game_finished", "link_app_priority", "link_app_click_url" }, json))
			{
				return JSONParseTypes.LinkApp;
			}
			return JSONParseTypes.Invalid;
		}
	}
	public static class ParsingHelper
	{
		public static bool ContainsKeys(List<string> keys, JObject json)
		{
			return ((IEnumerable<string>)keys).Any((Func<string, bool>)json.ContainsKey);
		}

		public static void TryAssign<T>(JObject jObjectParsed, string key, ref T target)
		{
			JToken val = default(JToken);
			if (jObjectParsed.TryGetValue(key, ref val))
			{
				target = Extensions.Value<T>((IEnumerable<JToken>)val);
			}
		}

		public static void TryAssign<T>(JObject jObjectParsed, List<string> key, ref T target)
		{
			JToken val = default(JToken);
			foreach (string item in key)
			{
				if (jObjectParsed.TryGetValue(item, ref val))
				{
					target = Extensions.Value<T>((IEnumerable<JToken>)val);
				}
			}
		}

		public static void TryAssignWithBool<T>(JObject jObjectParsed, string key, ref T target, ref bool wasAssigned)
		{
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				wasAssigned = false;
				return;
			}
			wasAssigned = true;
			target = Extensions.Value<T>((IEnumerable<JToken>)val);
		}

		public static void TryAssignWithChangedBool<T>(JObject jObjectParsed, string key, ref VariableChanged<T> target, bool setHasChangedToFalseOnFail = true)
		{
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				if (setHasChangedToFalseOnFail)
				{
					target.HasChanged = false;
				}
			}
			else
			{
				target.HasChanged = true;
				target.Data = Extensions.Value<T>((IEnumerable<JToken>)val);
			}
		}

		public static void TryAssignWithChangedBool<T>(JObject jObjectParsed, List<string> keys, ref VariableChanged<T> target)
		{
			target.HasChanged = false;
			foreach (string key in keys)
			{
				TryAssignWithChangedBool(jObjectParsed, key, ref target, setHasChangedToFalseOnFail: false);
			}
		}

		public static bool? TryAssignListOrSingleElement<T>(JObject jObjectParsed, string key, ref List<T> target)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return null;
			}
			if (target == null)
			{
				target = new List<T>();
			}
			if ((int)val.Type == 2)
			{
				foreach (JToken item3 in (IEnumerable<JToken>)val)
				{
					T item = Extensions.Value<T>((IEnumerable<JToken>)item3);
					target.Add(item);
				}
				return false;
			}
			try
			{
				T item2 = Extensions.Value<T>((IEnumerable<JToken>)val);
				target.Add(item2);
				return true;
			}
			catch
			{
				LoggingHelper.ErrorLog("For provided key '" + key + "' we were unable of assigning any value, as the wrong value was given.");
				return null;
			}
		}

		public static bool? TryAssignListOrSingleElementVariableChanged<T>(JObject jObjectParsed, string key, ref VariableChanged<List<T>> target)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return null;
			}
			if (target.Data == null)
			{
				target.Data = new List<T>();
			}
			if ((int)val.Type == 2)
			{
				foreach (JToken item3 in (IEnumerable<JToken>)val)
				{
					T item = Extensions.Value<T>((IEnumerable<JToken>)item3);
					target.Data.Add(item);
				}
				target.HasChanged = true;
				return false;
			}
			try
			{
				T item2 = Extensions.Value<T>((IEnumerable<JToken>)val);
				target.Data.Add(item2);
				target.HasChanged = true;
				return true;
			}
			catch
			{
				LoggingHelper.ErrorLog("For provided key '" + key + "' we were unable of assigning any value, as the wrong value was given.");
				return null;
			}
		}

		public static void TryAssignList<T>(JObject jObjectParsed, string key, ref List<T> target)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return;
			}
			if (target == null)
			{
				target = new List<T>();
			}
			if ((int)val.Type == 2)
			{
				foreach (JToken item2 in (IEnumerable<JToken>)val)
				{
					T item = Extensions.Value<T>((IEnumerable<JToken>)item2);
					target.Add(item);
				}
				return;
			}
			LoggingHelper.ErrorLog("Provided key '" + key + "' does not contain a list.");
		}
	}
	public static class ReloadJSONParsing
	{
		public static bool IsInHotReload;

		public static void ReloadAllJSONFiles(GameObject resetButton)
		{
			resetButton.SetActive(false);
			MelonCoroutines.Start(StartHotReloading());
		}

		private static IEnumerator StartHotReloading()
		{
			string activeCustomCampaignName = null;
			bool wasInCustomCampaign = false;
			if (CustomCampaignGlobal.InCustomCampaign)
			{
				activeCustomCampaignName = CustomCampaignGlobal.GetActiveCustomCampaign().CampaignName;
				wasInCustomCampaign = true;
				MainClassForMonsterEntries.AddedEntriesToCustomCampaign = false;
				CustomCampaignSceneSwitcher.BackToMainGame(alsoLoadMainMenu: false);
				yield return null;
			}
			IsInHotReload = true;
			LoggingHelper.DebugLog($"Current allocated memory (before hot reload): Allocated: '{Profiler.GetTotalAllocatedMemoryLong()}'; " + $"Reserved: '{Profiler.GetTotalReservedMemoryLong()}'.", LoggingHelper.LoggingCategory.MEMORY);
			AudioSource[] audioSources = Object.FindObjectsOfType<AudioSource>();
			AudioSource[] array = audioSources;
			foreach (AudioSource audioSource in array)
			{
				audioSource.Stop();
				((Behaviour)audioSource).enabled = false;
				audioSource.clip = null;
			}
			yield return null;
			AudioCache.RemoveEntireCache();
			CustomCampaignGlobal.CustomCampaignsAvailable.Clear();
			GlobalParsingVariables.EntriesMetadata.Clear();
			GlobalParsingVariables.MainGameThemes.Clear();
			GlobalParsingVariables.MainCampaignEmails.Clear();
			GlobalParsingVariables.CustomCallersMainGame.Clear();
			GlobalParsingVariables.PendingCustomCampaignCustomCallers.Clear();
			GlobalParsingVariables.PendingCustomCampaignEntries.Clear();
			GlobalParsingVariables.PendingCustomCampaignReplaceEntries.Clear();
			GlobalParsingVariables.PendingCustomCampaignEmails.Clear();
			GlobalParsingVariables.PendingCustomCampaignMusic.Clear();
			GlobalParsingVariables.PendingCustomCampaignModifiers.Clear();
			GlobalParsingVariables.PendingCustomCampaignThemes.Clear();
			GlobalParsingVariables.PendingCustomCampaignVideos.Clear();
			GlobalParsingVariables.PendingCustomCampaignRingtones.Clear();
			GlobalParsingVariables.PendingCustomCampaignTextFile.Clear();
			GlobalParsingVariables.PendingCustomCampaignCutscenes.Clear();
			EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierOne.Clear();
			EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierTwo.Clear();
			EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierThree.Clear();
			EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierFour.Clear();
			EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierFive.Clear();
			EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierSix.Clear();
			GlobalVariables.entryUnlockScript.firstTierUnlocks.monsterProfiles = MainClassForMonsterEntries.CopyTierUnlocks[0];
			GlobalVariables.entryUnlockScript.secondTierUnlocks.monsterProfiles = MainClassForMonsterEntries.CopyTierUnlocks[1];
			GlobalVariables.entryUnlockScript.thirdTierUnlocks.monsterProfiles = MainClassForMonsterEntries.CopyTierUnlocks[2];
			GlobalVariables.entryUnlockScript.fourthTierUnlocks.monsterProfiles = MainClassForMonsterEntries.CopyTierUnlocks[3];
			GlobalVariables.entryUnlockScript.fifthTierUnlocks.monsterProfiles = MainClassForMonsterEntries.CopyTierUnlocks[4];
			GlobalVariables.entryUnlockScript.sixthTierUnlocks.monsterProfiles = MainClassForMonsterEntries.CopyTierUnlocks[5];
			GlobalVariables.entryUnlockScript.xmastFirstTier.monsterProfiles = MainClassForMonsterEntries.CopyXmasTier[0];
			GlobalVariables.entryUnlockScript.xmasSecondTier.monsterProfiles = MainClassForMonsterEntries.CopyXmasTier[1];
			GlobalVariables.entryUnlockScript.xmasThirdTier.monsterProfiles = MainClassForMonsterEntries.CopyXmasTier[2];
			GlobalVariables.entryUnlockScript.xmasFourthTier.monsterProfiles = MainClassForMonsterEntries.CopyXmasTier[3];
			GlobalParsingVariables.CustomCampaignEntryIDOffset = 100000;
			GlobalVariables.entryUnlockScript.allEntries.monsterProfiles = MainClassForMonsterEntries.CopyMonsterProfiles;
			yield return Resources.UnloadUnusedAssets();
			GC.Collect(2, GCCollectionMode.Forced);
			GC.WaitForPendingFinalizers();
			GC.Collect(2, GCCollectionMode.Forced);
			yield return Resources.UnloadUnusedAssets();
			yield return null;
			LoggingHelper.DebugLog($"Current allocated memory (after clear): Allocated: '{Profiler.GetTotalAllocatedMemoryLong()}'; " + $"Reserved: '{Profiler.GetTotalReservedMemoryLong()}'.", LoggingHelper.LoggingCategory.MEMORY);
			MainClassForMonsterEntries.StartingJSONParsing(GlobalVariables.entryUnlockScript);
			LoggingHelper.DebugLog($"Current allocated memory (after loading all JSON files): Allocated: '{Profiler.GetTotalAllocatedMemoryLong()}'; " + $"Reserved: '{Profiler.GetTotalReservedMemoryLong()}'.", LoggingHelper.LoggingCategory.MEMORY);
			if (wasInCustomCampaign && !string.IsNullOrEmpty(activeCustomCampaignName))
			{
				MelonCoroutines.Start(LoadCustomCampaign(activeCustomCampaignName));
				yield break;
			}
			SceneManager.LoadScene("MainMenuScene");
			IsInHotReload = false;
		}

		private static IEnumerator LoadCustomCampaign(string activeCustomCampaignName)
		{
			SceneManager.LoadScene("MainMenuScene");
			Scene activeScene;
			while (true)
			{
				activeScene = SceneManager.GetActiveScene();
				int num;
				if (!(((Scene)(ref activeScene)).name != "MainMenuScene"))
				{
					activeScene = SceneManager.GetActiveScene();
					num = ((!((Scene)(ref activeScene)).isLoaded) ? 1 : 0);
				}
				else
				{
					num = 1;
				}
				if (num == 0)
				{
					break;
				}
				yield return null;
			}
			for (int i = 0; i < 10; i++)
			{
				yield return null;
			}
			MelonCoroutines.Start(CustomCampaignSceneSwitcher.ChangeToCustomCampaignSettings(activeCustomCampaignName, inHotReload: true));
			while (true)
			{
				activeScene = SceneManager.GetActiveScene();
				int num2;
				if (!(((Scene)(ref activeScene)).name != "MainMenuScene"))
				{
					activeScene = SceneManager.GetActiveScene();
					num2 = ((!((Scene)(ref activeScene)).isLoaded) ? 1 : 0);
				}
				else
				{
					num2 = 1;
				}
				if (num2 == 0)
				{
					break;
				}
				yield return null;
			}
			yield return null;
			IsInHotReload = false;
		}
	}
}
namespace NewSafetyHelp.JSONParsing.ParsingHelpers
{
	public static class AccuracyParsingHelper
	{
		private const string AccuracyCheckTypeString = "accuracy_check_type";

		private const string AccuracyRequiredString = "accuracy_required";

		private const string TotalAccuracyString = "use_total_accuracy";

		private static AccuracyHelper.CheckOptions TryAssignSingleAccuracyType(string accuracyCheckTypeString)
		{
			if (!string.IsNullOrEmpty(accuracyCheckTypeString))
			{
				switch (accuracyCheckTypeString.ToLowerInvariant())
				{
				case "equal":
				case "eq":
					return AccuracyHelper.CheckOptions.EqualTo;
				case "":
				case "no":
				case "n":
				case "none":
					return AccuracyHelper.CheckOptions.NoneSet;
				case "greaterorequal":
				case "geq":
					return AccuracyHelper.CheckOptions.GreaterThanOrEqualTo;
				case "lesserorequal":
				case "lessorequal":
				case "leq":
					return AccuracyHelper.CheckOptions.LessThanOrEqualTo;
				case "nequal":
				case "notequal":
				case "!equal":
				case "!eq":
				case "noteq":
				case "neq":
					return AccuracyHelper.CheckOptions.NotEqualTo;
				default:
					LoggingHelper.WarningLog("Provided accuracy check type '" + accuracyCheckTypeString + "' is not in any known format. Please double check.");
					return AccuracyHelper.CheckOptions.NoneSet;
				}
			}
			LoggingHelper.WarningLog("Unable of parsing accuracy check type. Possible syntax problem?");
			return AccuracyHelper.CheckOptions.NoneSet;
		}

		public static bool TryAssignListAccuracyType(JObject jObjectParsed, ref List<CallerAccuracyType> target)
		{
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue("accuracy_check_type", ref val))
			{
				return false;
			}
			if (target == null)
			{
				target = new List<CallerAccuracyType>();
			}
			List<bool> target2 = new List<bool>();
			bool? flag = ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, "use_total_accuracy", ref target2);
			List<float> target3 = new List<float>();
			ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, "accuracy_required", ref target3);
			List<string> target4 = new List<string>();
			ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, "accuracy_check_type", ref target4);
			if (target4.Count < 1)
			{
				LoggingHelper.ErrorLog("Provided accuracy lists are empty or could not be parsed. Unable of parsing accuracy checks.");
				return false;
			}
			if (target3.Count != target4.Count)
			{
				LoggingHelper.ErrorLog("Provided accuracy lists must all have equal length. Unable of parsing accuracy checks.");
				return false;
			}
			if (target2.Count > target4.Count)
			{
				LoggingHelper.ErrorLog("Provided list of total accuracy is larger than available accuracy checks. Unable of parsing accuracy checks.");
				return false;
			}
			for (int i = 0; i < target4.Count; i++)
			{
				CallerAccuracyType callerAccuracyType = new CallerAccuracyType();
				if (!string.IsNullOrEmpty(target4[i]))
				{
					callerAccuracyType.AccuracyCheck = TryAssignSingleAccuracyType(target4[i]);
				}
				else
				{
					LoggingHelper.WarningLog("Provided accuracy type is invalid. Defaulting to 'none'.");
				}
				if (flag.HasValue)
				{
					if (flag.Value && target2.Count > 0)
					{
						callerAccuracyType.UseTotalAccuracy = target2[0];
					}
					else if (i < target2.Count)
					{
						callerAccuracyType.UseTotalAccuracy = target2[i];
					}
				}
				callerAccuracyType.RequiredAccuracy = target3[i];
				target.Add(callerAccuracyType);
			}
			return true;
		}

		public static void TryAssignListGeneralAccuracyType(JObject jObjectParsed, ref List<GeneralAccuracyType> target, ref bool isUsingOldSystem, string requiredAccuracyKey = "email_required_accuracy", string accuracyDaysKey = "email_accuracy_days", string accuracyCheckTypesKey = "email_accuracy_check_type")
		{
			isUsingOldSystem = true;
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(requiredAccuracyKey, ref val))
			{
				return;
			}
			if (target == null)
			{
				target = new List<GeneralAccuracyType>();
			}
			List<int> target2 = new List<int>();
			bool? flag = ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, accuracyDaysKey, ref target2);
			List<float> target3 = new List<float>();
			ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, requiredAccuracyKey, ref target3);
			List<string> target4 = new List<string>();
			bool? flag2 = ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, accuracyCheckTypesKey, ref target4);
			if (flag2.HasValue && (!flag2).Value && target3.Count != target4.Count)
			{
				if (target3.Count < target4.Count)
				{
					LoggingHelper.ErrorLog("Provided accuracy lists must all should have equal length. Unable of parsing accuracy checks.");
					return;
				}
				if (target4.Count >= 1)
				{
					LoggingHelper.WarningLog("Provided accuracy lists must all should have equal length. Adding any missing accuracy checks with 'geq' (greater or equal).");
				}
				while (target4.Count < target3.Count)
				{
					target4.Add("geq");
				}
			}
			if (target4.Count > 0 || target4.Count > 0 || target2.Count > 0)
			{
				isUsingOldSystem = false;
			}
			for (int i = 0; i < target4.Count; i++)
			{
				GeneralAccuracyType generalAccuracyType = new GeneralAccuracyType();
				if (flag2.HasValue)
				{
					if (flag2.Value && target4.Count > 0)
					{
						generalAccuracyType.AccuracyCheck = TryAssignSingleAccuracyType(target4[0]);
					}
					else if (i < target4.Count)
					{
						if (!string.IsNullOrEmpty(target4[i]))
						{
							generalAccuracyType.AccuracyCheck = TryAssignSingleAccuracyType(target4[i]);
						}
						else
						{
							LoggingHelper.WarningLog("Provided general accuracy type is invalid. Defaulting to 'greater or equal'.");
							generalAccuracyType.AccuracyCheck = AccuracyHelper.CheckOptions.GreaterThanOrEqualTo;
						}
					}
				}
				if (flag.HasValue)
				{
					if (flag.Value && target2.Count > 0)
					{
						generalAccuracyType.CheckDay = target2[0];
					}
					else if (i < target2.Count)
					{
						generalAccuracyType.CheckDay = target2[i];
					}
				}
				generalAccuracyType.RequiredAccuracy = target3[i];
				target.Add(generalAccuracyType);
			}
		}
	}
	public static class ArtbookParsingHelper
	{
		public static void ParseArtbookPages(JObject jObjectParsed, ref List<ArtbookPage> target, string jsonFolderPath, string usermodFolderPath, string firstImageKey = "artbook_page_first_images", string secondImageKey = "artbook_page_second_images", string titleKey = "artbook_page_titles", string descriptionKey = "artbook_page_descriptions")
		{
			if (target == null)
			{
				target = new List<ArtbookPage>();
			}
			List<Sprite> target2 = new List<Sprite>();
			bool? flag = ImageParsingHelper.TryAssignSpriteListOrSingleSprite(jObjectParsed, firstImageKey, ref target2, jsonFolderPath, usermodFolderPath);
			List<Sprite> target3 = new List<Sprite>();
			bool? flag2 = ImageParsingHelper.TryAssignSpriteListOrSingleSprite(jObjectParsed, secondImageKey, ref target3, jsonFolderPath, usermodFolderPath, ignoreIfNull: true);
			List<string> target4 = new List<string>();
			bool? flag3 = ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, titleKey, ref target4);
			List<string> target5 = new List<string>();
			bool? flag4 = ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, descriptionKey, ref target5);
			JToken val = default(JToken);
			if (target2.Count <= 0 && target3.Count <= 0 && target4.Count <= 0 && target5.Count <= 0 && (jObjectParsed.TryGetValue(firstImageKey, ref val) || jObjectParsed.TryGetValue(descriptionKey, ref val)))
			{
				LoggingHelper.WarningLog("Provided artbook pages are invalid or could not be parsed. No artbook pages will be updated.");
				return;
			}
			if (target2.Count < target3.Count)
			{
				LoggingHelper.WarningLog("Artbook second Images list is greater than the first artbook images. You need more or equal the amount of first images. No artbook pages will be updated.");
				return;
			}
			int num = new List<int> { target2.Count, target3.Count, target5.Count, target4.Count }.Max();
			for (int i = 0; i < num; i++)
			{
				ArtbookPage val2 = ScriptableObject.CreateInstance<ArtbookPage>();
				val2.title = "";
				val2.description = "";
				val2.image = null;
				val2.image2 = null;
				if (flag.HasValue)
				{
					if (flag.Value && target2.Count > 0)
					{
						val2.image = target2[0];
					}
					else if (i < target2.Count)
					{
						val2.image = target2[i];
					}
				}
				if (flag2.HasValue)
				{
					if (flag2.Value && target3.Count > 0)
					{
						val2.image2 = target3[0];
					}
					else if (i < target3.Count)
					{
						val2.image2 = target3[i];
					}
				}
				if (flag3.HasValue)
				{
					if (flag3.Value && target4.Count > 0)
					{
						val2.title = target4[0];
					}
					else if (i < target4.Count)
					{
						val2.title = target4[i];
					}
				}
				if (flag4.HasValue)
				{
					if (flag4.Value && target5.Count > 0)
					{
						val2.description = target5[0];
					}
					else if (i < target5.Count)
					{
						val2.description = target5[i];
					}
				}
				target.Add(val2);
			}
		}
	}
	public static class AudioParsingHelper
	{
		public static void UpdateAudioAtLocation(JObject jObjectParsed, string audioLocation, Action<RichAudioClip> setAudioClip, string jsonFolderPath, string key = "audio_clip_location")
		{
			if (setAudioClip == null)
			{
				LoggingHelper.ErrorLog("Provided lambda function was not set. Unable of updating the audio.");
			}
			else
			{
				if (!jObjectParsed.ContainsKey(key))
				{
					return;
				}
				if (string.IsNullOrEmpty(audioLocation))
				{
					LoggingHelper.WarningLog("No valid audio file given for file in " + jsonFolderPath + ".");
					return;
				}
				if (!File.Exists(audioLocation))
				{
					LoggingHelper.ErrorLog("Location " + jsonFolderPath + " does not contain '" + audioLocation + "'. Unable of adding the audio.");
					return;
				}
				MelonCoroutines.Start(AudioImport.UpdateAudioClip(delegate(AudioClip myReturnValue)
				{
					if ((Object)(object)myReturnValue != (Object)null)
					{
						setAudioClip(AudioImport.CreateRichAudioClip(myReturnValue));
					}
					else
					{
						LoggingHelper.ErrorLog("Failed to load audio clip '" + audioLocation + "'.");
					}
				}, audioLocation, (AudioType)20));
			}
		}

		public static void UpdateAudioAtLocation(JObject jObjectParsed, VariableChanged<string> audioLocation, Action<RichAudioClip> setAudioClip, string jsonFolderPath, string key = "audio_clip_location")
		{
			if (audioLocation.HasChanged)
			{
				UpdateAudioAtLocation(jObjectParsed, audioLocation.Data, setAudioClip, jsonFolderPath, key);
			}
		}

		public static void UpdateAudioAtLocationNoKey(string audioLocation, Action<RichAudioClip> setAudioClip, string jsonFolderPath)
		{
			if (setAudioClip == null)
			{
				LoggingHelper.ErrorLog("Provided lambda function was not set. Unable of updating the audio.");
				return;
			}
			if (string.IsNullOrEmpty(audioLocation))
			{
				LoggingHelper.WarningLog("No valid audio file given for file in " + jsonFolderPath + ".");
				return;
			}
			if (!File.Exists(audioLocation))
			{
				LoggingHelper.ErrorLog("Location " + jsonFolderPath + " does not contain '" + audioLocation + "'. Unable of adding the audio.");
				return;
			}
			MelonCoroutines.Start(AudioImport.UpdateAudioClip(delegate(AudioClip myReturnValue)
			{
				if ((Object)(object)myReturnValue != (Object)null)
				{
					setAudioClip(AudioImport.CreateRichAudioClip(myReturnValue));
				}
				else
				{
					LoggingHelper.ErrorLog("Failed to load audio clip '" + audioLocation + "'.");
				}
			}, audioLocation, (AudioType)20));
		}

		public static void TryAssignAudioPath(JObject jObjectParsed, string key, ref string target, string jsonFolderPath, string usermodFolderPath, string nameOfTarget = null)
		{
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return;
			}
			string text = Extensions.Value<string>((IEnumerable<JToken>)val);
			if (File.Exists(text))
			{
				target = text;
			}
			else if (!File.Exists(jsonFolderPath + "\\" + text))
			{
				if (!File.Exists(usermodFolderPath + "\\" + text))
				{
					LoggingHelper.WarningLog("Could not find provided audio file for key '" + key + "' at '" + jsonFolderPath + "' (For Audio '" + text + "').");
					if (nameOfTarget != null)
					{
						LoggingHelper.WarningLog("For '" + nameOfTarget + "'.");
					}
				}
				else
				{
					target = usermodFolderPath + "\\" + text;
				}
			}
			else
			{
				target = jsonFolderPath + "\\" + text;
			}
		}

		public static void TryAssignAudioPathWithChangedBool(JObject jObjectParsed, string key, ref VariableChanged<string> target, string jsonFolderPath, string usermodFolderPath, string nameOfTarget = null)
		{
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return;
			}
			string text = Extensions.Value<string>((IEnumerable<JToken>)val);
			if (File.Exists(text))
			{
				target.Data = text;
				target.HasChanged = true;
			}
			else if (!File.Exists(jsonFolderPath + "\\" + text))
			{
				if (!File.Exists(usermodFolderPath + "\\" + text))
				{
					LoggingHelper.WarningLog("Could not find provided audio file for key '" + key + "' at '" + jsonFolderPath + "' (For Audio '" + text + "').");
					if (nameOfTarget != null)
					{
						LoggingHelper.WarningLog("For '" + nameOfTarget + "'.");
					}
				}
				else
				{
					target.Data = usermodFolderPath + "\\" + text;
					target.HasChanged = true;
				}
			}
			else
			{
				target.Data = jsonFolderPath + "\\" + text;
				target.HasChanged = true;
			}
		}
	}
	public static class CallerRequirementParsingHelper
	{
		public static void TryAssignCallerRequirement(JObject jObjectParsed, ref List<CallerRequirement> target, string callerRequirementIDKey = "email_caller_requirement_ids", string callerCorrectnessKey = "email_caller_requirement_should_be_correct")
		{
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(callerRequirementIDKey, ref val))
			{
				return;
			}
			if (target == null)
			{
				target = new List<CallerRequirement>();
			}
			List<int> target2 = new List<int>();
			ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, callerRequirementIDKey, ref target2);
			List<bool> target3 = new List<bool>();
			bool? flag = ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, callerCorrectnessKey, ref target3);
			if (target3.Count > target2.Count)
			{
				LoggingHelper.WarningLog("Too many caller correctness given, the given caller requirement will not use all elements.If this is intentional, then no action is required.");
			}
			for (int i = 0; i < target2.Count; i++)
			{
				CallerRequirement callerRequirement = new CallerRequirement
				{
					CallerID = target2[i]
				};
				if (flag.HasValue)
				{
					if (flag.Value && target3.Count > 0)
					{
						callerRequirement.ShouldCallerBeCorrect = target3[0];
					}
					else if (i < target3.Count)
					{
						callerRequirement.ShouldCallerBeCorrect = target3[i];
					}
				}
				target.Add(callerRequirement);
			}
		}
	}
	public static class ColorParsingHelper
	{
		public static void SetColor(ref JToken jsonValue, ref ColorPalette themeColorPalette, int colorIndex)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if ((int)jsonValue.Type != 2)
			{
				return;
			}
			List<float> list = new List<float>();
			foreach (JToken item in (JArray)jsonValue)
			{
				list.Add(Extensions.Value<float>((IEnumerable<JToken>)item));
			}
			switch (list.Count)
			{
			case 3:
				themeColorPalette.colorSwatch[colorIndex] = new Color(ColorHelper.GetConvertedColorFloat(list[0]), ColorHelper.GetConvertedColorFloat(list[1]), ColorHelper.GetConvertedColorFloat(list[2]));
				break;
			case 4:
				themeColorPalette.colorSwatch[colorIndex] = new Color(ColorHelper.GetConvertedColorFloat(list[0]), ColorHelper.GetConvertedColorFloat(list[1]), ColorHelper.GetConvertedColorFloat(list[2]), ColorHelper.GetConvertedColorFloat(list[3]));
				break;
			default:
				LoggingHelper.ErrorLog("Provided color for setting color is invalid! Make sure it's 3 or 4 values.");
				break;
			}
		}

		public static void SetColor(ref JToken jsonValue, ref Color parsedColor)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			if ((int)jsonValue.Type != 2)
			{
				return;
			}
			List<float> list = new List<float>();
			foreach (JToken item in (JArray)jsonValue)
			{
				list.Add(Extensions.Value<float>((IEnumerable<JToken>)item));
			}
			switch (list.Count)
			{
			case 3:
				parsedColor = new Color(ColorHelper.GetConvertedColorFloat(list[0]), ColorHelper.GetConvertedColorFloat(list[1]), ColorHelper.GetConvertedColorFloat(list[2]));
				break;
			case 4:
				parsedColor = new Color(ColorHelper.GetConvertedColorFloat(list[0]), ColorHelper.GetConvertedColorFloat(list[1]), ColorHelper.GetConvertedColorFloat(list[2]), ColorHelper.GetConvertedColorFloat(list[3]));
				break;
			default:
				LoggingHelper.ErrorLog("Provided color for setting color is invalid! Make sure it's 3 or 4 values.");
				break;
			}
		}

		public static void SetColor(ref JToken jsonValue, ref VariableChanged<Color> parsedColor)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if ((int)jsonValue.Type != 2)
			{
				return;
			}
			List<float> list = new List<float>();
			foreach (JToken item in (JArray)jsonValue)
			{
				list.Add(Extensions.Value<float>((IEnumerable<JToken>)item));
			}
			switch (list.Count)
			{
			case 3:
				parsedColor.Data = new Color(ColorHelper.GetConvertedColorFloat(list[0]), ColorHelper.GetConvertedColorFloat(list[1]), ColorHelper.GetConvertedColorFloat(list[2]));
				parsedColor.HasChanged = true;
				break;
			case 4:
				parsedColor.Data = new Color(ColorHelper.GetConvertedColorFloat(list[0]), ColorHelper.GetConvertedColorFloat(list[1]), ColorHelper.GetConvertedColorFloat(list[2]), ColorHelper.GetConvertedColorFloat(list[3]));
				parsedColor.HasChanged = true;
				break;
			default:
				LoggingHelper.ErrorLog("Provided color for setting color is invalid! Make sure it's 3 or 4 values.");
				break;
			}
		}

		public static void ParseColor(JObject jObjectParsed, string key, ref Color target)
		{
			JToken jsonValue = default(JToken);
			if (jObjectParsed.TryGetValue(key, ref jsonValue))
			{
				SetColor(ref jsonValue, ref target);
			}
		}

		public static void ParseColor(JObject jObjectParsed, string key, ref VariableChanged<Color> target)
		{
			JToken jsonValue = default(JToken);
			if (jObjectParsed.TryGetValue(key, ref jsonValue))
			{
				SetColor(ref jsonValue, ref target);
			}
		}
	}
	public static class IDParsingHelper
	{
		private static int GetNewEntryID(EntryUnlockController entryUnlocker, int type = 0)
		{
			return type switch
			{
				0 => entryUnlocker.allEntries.monsterProfiles.Length, 
				1 => entryUnlocker.allXmasEntries.monsterProfiles.Length, 
				_ => entryUnlocker.allEntries.monsterProfiles.Length, 
			};
		}

		public static void GenerateNewID(ref EntryMetadata newExtra, ref int newID, ref bool replaceEntry, ref string jsonFolderPath, ref bool onlyDlc, ref bool includeDlc, ref EntryUnlockController entryUnlockerInstance, ref bool inCustomCampaign)
		{
			if (newID == -1 && !replaceEntry && !inCustomCampaign)
			{
				int newEntryID = GetNewEntryID(entryUnlockerInstance);
				int newEntryID2 = GetNewEntryID(entryUnlockerInstance, 1);
				LoggingHelper.DebugLog($"Entries in Main Campaign: {newEntryID} and entries in DLC: {newEntryID2}.");
				if (onlyDlc)
				{
					newID = newEntryID2;
				}
				else if (includeDlc)
				{
					newID = ((newEntryID < newEntryID2) ? newEntryID2 : newEntryID);
				}
				else
				{
					newID = newEntryID;
				}
			}
			if ((newID == -1 && !replaceEntry) & inCustomCampaign)
			{
				int newEntryID3 = GetNewEntryID(entryUnlockerInstance);
				newEntryID3 += GlobalParsingVariables.CustomCampaignEntryIDOffset;
				GlobalParsingVariables.CustomCampaignEntryIDOffset++;
				newID = newEntryID3;
			}
			newExtra.ID = newID;
			LoggingHelper.InfoLog($"Defaulting to a new Monster ID {newExtra.ID} for file in {jsonFolderPath}.");
			LoggingHelper.InfoLog("(This is the intended and recommended way of providing the ID.)");
		}
	}
	public static class ImageParsingHelper
	{
		public static bool TryAssignSprite(JObject jObjectParsed, string key, ref Sprite target, string jsonFolderPath, string usermodFolderPath, string customCampaignName = null)
		{
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return false;
			}
			string text = Extensions.Value<string>((IEnumerable<JToken>)val);
			if (string.IsNullOrEmpty(text))
			{
				LoggingHelper.ErrorLog("Invalid file name given for '" + text + "' for key " + key + ". Not updating " + ((!string.IsNullOrEmpty(customCampaignName)) ? ("for " + customCampaignName + ".") : "."));
			}
			else
			{
				target = ImageImport.LoadImage(jsonFolderPath + "\\" + text, usermodFolderPath + "\\" + text);
			}
			return true;
		}

		public static bool? TryAssignSpriteListOrSingleSprite(JObject jObjectParsed, string key, ref List<Sprite> target, string jsonFolderPath, string usermodFolderPath, bool ignoreIfNull = false)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return null;
			}
			if (target == null)
			{
				target = new List<Sprite>();
			}
			if ((int)val.Type == 2)
			{
				TryAssignSpriteList(jObjectParsed, key, ref target, jsonFolderPath, usermodFolderPath, ignoreIfNull);
				return false;
			}
			try
			{
				Sprite item = null;
				string text = Extensions.Value<string>((IEnumerable<JToken>)val);
				if (string.IsNullOrEmpty(text))
				{
					LoggingHelper.ErrorLog("Invalid file name given for '" + text + "' for key " + key + ".");
				}
				else
				{
					item = ImageImport.LoadImage(jsonFolderPath + "\\" + text, usermodFolderPath + "\\" + text);
				}
				target.Add(item);
				return true;
			}
			catch
			{
				LoggingHelper.ErrorLog("For provided key '" + key + "' we were unable of assigning any value, as the wrong value was given.");
				return null;
			}
		}

		public static bool TryAssignSpriteList(JObject jObjectParsed, string key, ref List<Sprite> target, string jsonFolderPath, string usermodFolderPath, bool ignoreIfNull = false)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return false;
			}
			JArray val2 = (JArray)val;
			foreach (JToken item in val2)
			{
				string text = Extensions.Value<string>((IEnumerable<JToken>)item);
				if (string.IsNullOrEmpty(text))
				{
					if (ignoreIfNull)
					{
						target.Add(null);
						continue;
					}
					LoggingHelper.ErrorLog("Invalid file name given for '" + text + "' for key " + key + ".");
				}
				else
				{
					target.Add(ImageImport.LoadImage(jsonFolderPath + "\\" + text, usermodFolderPath + "\\" + text));
				}
			}
			return true;
		}

		public static bool? TryAssignSpriteListOrSingleSpriteVariableChanged(JObject jObjectParsed, string key, ref VariableChanged<List<Sprite>> target, string jsonFolderPath, string usermodFolderPath, bool ignoreIfNull = false)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return null;
			}
			if (target.Data == null)
			{
				target.Data = new List<Sprite>();
			}
			if ((int)val.Type == 2)
			{
				TryAssignSpriteList(jObjectParsed, key, ref target.Data, jsonFolderPath, usermodFolderPath, ignoreIfNull);
				if (target.Data.Count > 0)
				{
					target.HasChanged = true;
				}
				return false;
			}
			try
			{
				Sprite item = null;
				string text = Extensions.Value<string>((IEnumerable<JToken>)val);
				if (string.IsNullOrEmpty(text))
				{
					LoggingHelper.ErrorLog("Invalid file name given for '" + text + "' for key " + key + ".");
				}
				else
				{
					item = ImageImport.LoadImage(jsonFolderPath + "\\" + text, usermodFolderPath + "\\" + text);
				}
				target.Data.Add(item);
				target.HasChanged = true;
				return true;
			}
			catch
			{
				LoggingHelper.ErrorLog("For provided key '" + key + "' we were unable of assigning any value, as the wrong value was given.");
				return null;
			}
		}

		public static bool TryAssignSpriteListVariableChanged(JObject jObjectParsed, string key, ref VariableChanged<List<Sprite>> target, string jsonFolderPath, string usermodFolderPath, bool ignoreIfNull = false)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return false;
			}
			if (target.Data == null)
			{
				target.Data = new List<Sprite>();
			}
			JArray val2 = (JArray)val;
			foreach (JToken item in val2)
			{
				string text = Extensions.Value<string>((IEnumerable<JToken>)item);
				if (string.IsNullOrEmpty(text))
				{
					if (ignoreIfNull)
					{
						target.Data.Add(null);
						continue;
					}
					LoggingHelper.ErrorLog("Invalid file name given for '" + text + "' for key " + key + ".");
				}
				else
				{
					target.Data.Add(ImageImport.LoadImage(jsonFolderPath + "\\" + text, usermodFolderPath + "\\" + text));
				}
			}
			if (target.Data.Count > 0)
			{
				target.HasChanged = true;
			}
			return true;
		}

		public static void TryAssignSpriteChanged(JObject jObjectParsed, string key, ref VariableChanged<Sprite> target, string jsonFolderPath, string usermodFolderPath, string customCampaignName = null)
		{
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return;
			}
			string text = Extensions.Value<string>((IEnumerable<JToken>)val);
			target = new VariableChanged<Sprite>();
			if (string.IsNullOrEmpty(text))
			{
				LoggingHelper.ErrorLog("Invalid file name given for '" + text + "' for key " + key + ". Not updating " + ((!string.IsNullOrEmpty(customCampaignName)) ? ("for " + customCampaignName + ".") : "."));
			}
			else
			{
				Sprite val2 = ImageImport.LoadImage(jsonFolderPath + "\\" + text, usermodFolderPath + "\\" + text);
				if ((Object)(object)val2 != (Object)null)
				{
					LoggingHelper.DebugLog("Loaded in sprite (image) '" + text + "' successfully.");
					target.HasChanged = true;
					target.Data = val2;
				}
			}
		}
	}
	public static class PendingParsingHelper
	{
		public static void AddPendingElementsToCampaign<T>(ref List<T> pendingList, ref List<T> listToBeAddedTo, string customCampaignName, string elementName = "NO_NAME_GIVEN") where T : CustomCampaignElementBase
		{
			if (pendingList.Count <= 0)
			{
				return;
			}
			List<T> list = new List<T>(pendingList);
			foreach (T item in list)
			{
				if (item.CustomCampaignName == customCampaignName)
				{
					LoggingHelper.DebugLog("Adding missing " + elementName + " to the custom campaign: " + customCampaignName + ".");
					listToBeAddedTo.Add(item);
					pendingList.Remove(item);
				}
			}
		}
	}
	public static class URLParsingHelper
	{
		public static bool TryAssignURL(JObject jObjectParsed, string key, ref Uri target)
		{
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return false;
			}
			string stringURL = Extensions.Value<string>((IEnumerable<JToken>)val);
			if (!URLVerification.SetClickURL(stringURL, ref target))
			{
				LoggingHelper.WarningLog("Provided URL with the key '" + key + "' is invalid. Unable of setting url.");
				return false;
			}
			LoggingHelper.DebugLog("Found click URL: '" + target.AbsoluteUri.Substring(0, 10) + "[...]'. It has been marked as valid.");
			return true;
		}
	}
	public static class VideoParsingHelper
	{
		public enum VideoType
		{
			AVI,
			MOV,
			MP4,
			MPEG,
			ASF,
			NONE
		}

		public static bool IsKnownVideoExtension(string filePath)
		{
			if (!File.Exists(filePath))
			{
				LoggingHelper.ErrorLog("Provided video '" + filePath + "' could not be found.");
				return false;
			}
			string text = Path.GetExtension(filePath).ToLowerInvariant().Trim();
			if (string.IsNullOrEmpty(text))
			{
				LoggingHelper.WarningLog("Provided video file extension for video '" + filePath + "' is empty. Will attempt to find correct format.");
				return false;
			}
			switch (text)
			{
			case ".asf":
			case ".avi":
			case ".dv":
			case ".m4v":
			case ".mov":
			case ".mp4":
			case ".mpg":
			case ".mpeg":
			case ".ogv":
			case ".vp8":
			case ".webm":
			case ".wmv":
				return true;
			default:
				LoggingHelper.InfoLog("Provided video file extension for video '" + filePath + "' is unknown. Will attempt to find correct format.");
				return false;
			}
		}

		public static VideoType TryFindingVideoType(string filePath)
		{
			using FileStream input = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
			using BinaryReader binaryReader = new BinaryReader(input);
			byte[] array = binaryReader.ReadBytes(16);
			if (array.Length < 16)
			{
				LoggingHelper.ErrorLog("Provided video file at '" + filePath + "' is too small to be considered a video file. Unable of assigning video.");
				return VideoType.NONE;
			}
			return MatchSignature(array);
		}

		private static VideoType MatchSignature(byte[] headerByteArray)
		{
			if (headerByteArray.Length < 16)
			{
				LoggingHelper.ErrorLog("Provided header bytes are less than 16, unable of properly checking for video type.");
				return VideoType.NONE;
			}
			string text = Encoding.ASCII.GetString(headerByteArray, 4, 4).ToLower().Trim();
			if (text == "ftyp")
			{
				string text2 = Encoding.ASCII.GetString(headerByteArray, 8, 4).ToLower().Trim();
				if (text2 == "qt")
				{
					return VideoType.MOV;
				}
				return VideoType.MP4;
			}
			string text3 = Encoding.ASCII.GetString(headerByteArray, 0, 4).ToLower().Trim();
			string text4 = Encoding.ASCII.GetString(headerByteArray, 8, 4).ToLower().Trim();
			if (text3 == "riff" && text4 == "avi")
			{
				return VideoType.AVI;
			}
			if (headerByteArray[0] == 0 && headerByteArray[1] == 0 && headerByteArray[2] == 1 && (headerByteArray[3] == 186 || headerByteArray[3] == 179))
			{
				return VideoType.MPEG;
			}
			byte[] second = new byte[16]
			{
				48, 38, 178, 117, 142, 102, 207, 17, 166, 217,
				0, 170, 0, 98, 206, 108
			};
			if (headerByteArray.Take(16).SequenceEqual(second))
			{
				return VideoType.ASF;
			}
			return VideoType.NONE;
		}

		[CanBeNull]
		public static string GetVideoTypeExtension(VideoType videoType)
		{
			switch (videoType)
			{
			case VideoType.AVI:
				return ".avi";
			case VideoType.MOV:
				return ".mov";
			case VideoType.MP4:
				return ".mp4";
			case VideoType.MPEG:
				return ".mpeg";
			case VideoType.ASF:
				return ".wmv";
			default:
				LoggingHelper.ErrorLog("Unsupported video type '" + videoType.ToString() + "' provided. Could not get file extension.");
				return null;
			}
		}

		public static (bool createdTemptFile, string pathToTempFile) CreateTempVideoFile(string currentFilePath, VideoType videoType)
		{
			if (string.IsNullOrEmpty(currentFilePath))
			{
				LoggingHelper.ErrorLog("Provided file path is empty. Unable of creating temporary copy.");
				return (createdTemptFile: false, pathToTempFile: "");
			}
			if (videoType == VideoType.NONE)
			{
				LoggingHelper.ErrorLog("Video type is not known. Unable of creating temporary copy.");
				return (createdTemptFile: false, pathToTempFile: "");
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(currentFilePath);
			string videoTypeExtension = GetVideoTypeExtension(videoType);
			if (string.IsNullOrEmpty(videoTypeExtension))
			{
				LoggingHelper.ErrorLog("Failed getting a file extension. Unable of creating temporary copy.");
				return (createdTemptFile: false, pathToTempFile: "");
			}
			if (string.IsNullOrEmpty(fileNameWithoutExtension))
			{
				LoggingHelper.ErrorLog("Failed getting file path for '" + currentFilePath + "' without extension. Unable of creating temporary copy.");
				return (createdTemptFile: false, pathToTempFile: "");
			}
			string text = Path.Combine(Path.GetTempPath(), string.Format("{0}{1}_{2}{3}", "NewSafetyHelp_", fileNameWithoutExtension, Guid.NewGuid(), videoTypeExtension));
			try
			{
				File.Copy(currentFilePath, text, overwrite: true);
				LoggingHelper.DebugLog("Created copy of the video file at '" + text + "'.");
			}
			catch (Exception arg)
			{
				LoggingHelper.DebugLog($"Failec creating a copy at '{text}'. Reason: \n'\n{arg}\n'.");
				return (createdTemptFile: false, pathToTempFile: text);
			}
			return (createdTemptFile: true, pathToTempFile: text);
		}

		public static bool? TryAssignUrlListOrSingleUrl(JObject jObjectParsed, string key, ref List<string> target, string jsonFolderPath, string usermodFolderPath)
		{
			bool? result = ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, key, ref target);
			for (int i = 0; i < target.Count; i++)
			{
				if (string.IsNullOrEmpty(target[i]))
				{
					LoggingHelper.WarningLog("Provided video path is empty. Unable to show video.");
					continue;
				}
				string text = jsonFolderPath + "\\" + target[i];
				string text2 = usermodFolderPath + "\\" + target[i];
				string text3 = "";
				if (File.Exists(target[i]))
				{
					text3 = target[i];
				}
				else if (File.Exists(text))
				{
					text3 = text;
				}
				else if (File.Exists(text2))
				{
					text3 = text2;
				}
				else if (!File.Exists(text) && !File.Exists(text2))
				{
					LoggingHelper.ErrorLog("Could not find video '" + target[i] + "' in either: '" + text + "' or '" + text2 + "'.");
					text3 = "";
				}
				if (IsKnownVideoExtension(text3))
				{
					target[i] = text3;
					continue;
				}
				VideoType videoType = TryFindingVideoType(text3);
				bool flag = false;
				VideoType videoType2 = videoType;
				VideoType videoType3 = videoType2;
				if (videoType3 == VideoType.NONE)
				{
					LoggingHelper.ErrorLog("Provided video file at '" + text3 + "' could not be understood. Possible unsupported file format.");
				}
				else
				{
					flag = true;
					LoggingHelper.InfoLog("Provided video file '" + text3 + "' was interpreted as a '" + videoType.ToString() + "'.");
				}
				if (flag)
				{
					var (flag2, value) = CreateTempVideoFile(text3, videoType);
					if (flag2)
					{
						target[i] = value;
						continue;
					}
					LoggingHelper.ErrorLog("Failed creating a temporary copy of the video. Not showing video.");
					target[i] = "";
				}
				else
				{
					LoggingHelper.InfoLog("Video type at '" + text3 + "' seems to be unsupported. Attempting to still use it.");
					target[i] = text3;
				}
			}
			return result;
		}

		public static bool TryAssignVideoPath(JObject jObjectParsed, string key, ref string target, string jsonFolderPath, string usermodFolderPath)
		{
			JToken val = default(JToken);
			if (!jObjectParsed.TryGetValue(key, ref val))
			{
				return false;
			}
			string text = Extensions.Value<string>((IEnumerable<JToken>)val);
			string text2 = jsonFolderPath + "\\" + text;
			string text3 = usermodFolderPath + "\\" + text;
			if (string.IsNullOrEmpty(text))
			{
				LoggingHelper.WarningLog("Provided video path is empty. Unable to show video.");
				target = "";
			}
			else
			{
				string text4;
				if (File.Exists(text))
				{
					text4 = text;
				}
				else if (File.Exists(text2))
				{
					text4 = text2;
				}
				else
				{
					if (!File.Exists(text3))
					{
						LoggingHelper.ErrorLog("Provided video '" + text + "' could not be found in either '" + text2 + "' or '" + text3 + "'.");
						target = "";
						return true;
					}
					text4 = text3;
				}
				if (IsKnownVideoExtension(text4))
				{
					target = text4;
				}
				else
				{
					VideoType videoType = TryFindingVideoType(text4);
					bool flag = false;
					VideoType videoType2 = videoType;
					VideoType videoType3 = videoType2;
					if (videoType3 == VideoType.NONE)
					{
						LoggingHelper.ErrorLog("Provided video file at '" + text4 + "' could not be understood. Possible unsupported file format.");
					}
					else
					{
						flag = true;
						LoggingHelper.InfoLog("Provided video file '" + text4 + "' was interpreted as a '" + videoType.ToString() + "'.");
					}
					if (flag)
					{
						var (flag2, text5) = CreateTempVideoFile(text4, videoType);
						if (flag2)
						{
							target = text5;
						}
						else
						{
							LoggingHelper.ErrorLog("Failed creating a temporary copy of the video. Not showing video.");
							target = "";
						}
					}
					else
					{
						LoggingHelper.InfoLog("Video type at '" + text4 + "' seems to be unsupported. Attempting to still use it.");
						target = text4;
					}
				}
			}
			return true;
		}
	}
}
namespace NewSafetyHelp.JSONParsing.EntryParsing
{
	public static class MainCampaignCallerParsing
	{
		public static void ParseCaller(ref JObject jsonObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref string callerName, ref string callerTranscript, ref string callerImageLocation, ref float callerReplaceChance, ref bool callerRestartCallAgain, ref Sprite callerPortrait)
		{
			ParsingHelper.TryAssign(jsonObjectParsed, "caller_name", ref callerName);
			ParsingHelper.TryAssign(jsonObjectParsed, "caller_transcript", ref callerTranscript);
			ParsingHelper.TryAssign(jsonObjectParsed, "caller_image_name", ref callerImageLocation);
			ImageParsingHelper.TryAssignSprite(jsonObjectParsed, "caller_image_name", ref callerPortrait, jsonFolderPath, usermodFolderPath, callerName);
			ParsingHelper.TryAssign(jsonObjectParsed, "caller_chance", ref callerReplaceChance);
			ParsingHelper.TryAssign(jsonObjectParsed, "allow_calling_again_over_restarts", ref callerRestartCallAgain);
		}

		public static void ParseConsequenceCaller(ref JObject jsonObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref string consequenceCallerName, ref string consequenceCallerTranscript, ref string consequenceCallerImageLocation, ref Sprite consequenceCallerPortrait)
		{
			ParsingHelper.TryAssign(jsonObjectParsed, "consequence_caller_name", ref consequenceCallerName);
			ParsingHelper.TryAssign(jsonObjectParsed, "consequence_caller_transcript", ref consequenceCallerTranscript);
			ParsingHelper.TryAssign(jsonObjectParsed, "consequence_caller_image_name", ref consequenceCallerImageLocation);
			ImageParsingHelper.TryAssignSprite(jsonObjectParsed, "caller_image_name", ref consequenceCallerPortrait, jsonFolderPath, usermodFolderPath, consequenceCallerName);
		}
	}
	public static class EntryParsing
	{
		private static void ParseEntry(ref JObject jsonObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref int accessLevel, ref bool accessLevelAdded, ref bool replaceEntry, ref bool onlyDLC, ref bool includeDLC, ref bool includeMainCampaign, ref string entryName, ref string entryDescription, ref List<string> arcadeCalls, ref Sprite entryPortrait, ref string entryPortraitLocation, ref string entryAudioClipLocation, ref bool deleteReplaceEntry, ref bool inCustomCampaign, ref string customCampaignName, ref string videoUrlPortrait, ref bool isVideoPortrait, ref VariableChanged<bool> videoPortraitShouldLoop)
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			ParsingHelper.TryAssign(jsonObjectParsed, "replace_entry", ref replaceEntry);
			JToken val = default(JToken);
			JToken val2 = default(JToken);
			if (jsonObjectParsed.TryGetValue("monster_name", ref val))
			{
				if (!string.IsNullOrEmpty((string)val))
				{
					entryName = (string)val;
				}
			}
			else if (jsonObjectParsed.TryGetValue("entry_name", ref val2))
			{
				if (!string.IsNullOrEmpty((string)val2))
				{
					entryName = (string)val2;
				}
			}
			else if (!replaceEntry)
			{
				LoggingHelper.WarningLog("No entry name given for file in " + usermodFolderPath + ". Defaulting to NO_NAME.");
			}
			JToken val3 = default(JToken);
			JToken val4 = default(JToken);
			if (jsonObjectParsed.TryGetValue("monster_description", ref val3))
			{
				entryDescription = Extensions.Value<string>((IEnumerable<JToken>)val3);
			}
			else if (jsonObjectParsed.TryGetValue("entry_description", ref val4))
			{
				entryDescription = Extensions.Value<string>((IEnumerable<JToken>)val4);
			}
			else if (!replaceEntry)
			{
				LoggingHelper.WarningLog("No entry description given for file in " + usermodFolderPath + ". Defaulting to NO_DESCRIPTION.");
			}
			ParsingHelper.TryAssign(jsonObjectParsed, "only_dlc", ref onlyDLC);
			ParsingHelper.TryAssign(jsonObjectParsed, "include_dlc", ref includeDLC);
			ParsingHelper.TryAssign(jsonObjectParsed, "include_campaign", ref includeMainCampaign);
			ParsingHelper.TryAssignWithBool(jsonObjectParsed, "access_level", ref accessLevel, ref accessLevelAdded);
			JToken val5 = default(JToken);
			if (jsonObjectParsed.TryGetValue("arcade_calls", ref val5))
			{
				JArray val6 = (JArray)val5;
				foreach (JToken item in val6)
				{
					arcadeCalls.Add(Extensions.Value<string>((IEnumerable<JToken>)item));
				}
			}
			else if (!replaceEntry)
			{
				LoggingHelper.InfoLog("No Arcade Calls given for file in " + usermodFolderPath + ". Defaulting to empty values.");
			}
			JToken val7 = default(JToken);
			JToken val8 = default(JToken);
			if (jsonObjectParsed.TryGetValue("monster_portrait_image_name", ref val7))
			{
				entryPortraitLocation = Extensions.Value<string>((IEnumerable<JToken>)val7);
				if (string.IsNullOrEmpty(entryPortraitLocation))
				{
					entryPortrait = null;
					if (!replaceEntry)
					{
						LoggingHelper.WarningLog("No entry portrait given for file in " + usermodFolderPath + ". No image will be shown.");
					}
				}
				else
				{
					entryPortrait = ImageImport.LoadImage(jsonFolderPath + "\\" + entryPortraitLocation, usermodFolderPath + "\\" + entryPortraitLocation);
				}
			}
			else if (jsonObjectParsed.TryGetValue("entry_portrait_image_name", ref val8))
			{
				entryPortraitLocation = Extensions.Value<string>((IEnumerable<JToken>)val8);
				if (string.IsNullOrEmpty(entryPortraitLocation))
				{
					entryPortrait = null;
					if (!replaceEntry)
					{
						LoggingHelper.WarningLog("No entry portrait given for file in " + usermodFolderPath + ". No image will be shown.");
					}
				}
				else
				{
					entryPortrait = ImageImport.LoadImage(jsonFolderPath + "\\" + entryPortraitLocation, usermodFolderPath + "\\" + entryPortraitLocation);
				}
			}
			else if (!replaceEntry)
			{
				LoggingHelper.WarningLog("No entry portrait given for file in " + usermodFolderPath + ". No image will be shown.");
			}
			JToken val9 = default(JToken);
			JToken val10 = default(JToken);
			if (jsonObjectParsed.TryGetValue("monster_audio_clip_name", ref val9))
			{
				entryAudioClipLocation = Extensions.Value<string>((IEnumerable<JToken>)val9);
				if (string.IsNullOrEmpty(entryAudioClipLocation) && !replaceEntry)
				{
					LoggingHelper.InfoLog("No entry audio given for file in " + usermodFolderPath + ". No audio will be shown.");
				}
			}
			else if (jsonObjectParsed.TryGetValue("entry_audio_clip_name", ref val10))
			{
				entryAudioClipLocation = Extensions.Value<string>((IEnumerable<JToken>)val10);
				if (string.IsNullOrEmpty(entryAudioClipLocation) && !replaceEntry)
				{
					LoggingHelper.InfoLog("No entry audio given for file in " + usermodFolderPath + ". No audio will be shown.");
				}
			}
			else if (!replaceEntry)
			{
				LoggingHelper.InfoLog("No entry audio given for file in " + usermodFolderPath + ". No audio will be shown.");
			}
			JToken val11 = default(JToken);
			if (jsonObjectParsed.TryGetValue("attached_custom_campaign_name", ref val11))
			{
				LoggingHelper.DebugLog("Found an entry that is custom campaign only.", LoggingHelper.LoggingCategory.ENTRY);
				customCampaignName = Extensions.Value<string>((IEnumerable<JToken>)val11);
				inCustomCampaign = true;
			}
			ParsingHelper.TryAssign(jsonObjectParsed, "delete_entry", ref deleteReplaceEntry);
			isVideoPortrait = VideoParsingHelper.TryAssignVideoPath(jsonObjectParsed, "portrait_video_name", ref videoUrlPortrait, jsonFolderPath, usermodFolderPath);
			ParsingHelper.TryAssignWithChangedBool(jsonObjectParsed, "portrait_video_should_loop", ref videoPortraitShouldLoop);
		}

		private static void ParsePhobias(ref JObject jsonObjectParsed, ref bool spiderPhobia, ref bool spiderPhobiaIncluded, ref bool darknessPhobia, ref bool darknessPhobiaIncluded, ref bool dogPhobia, ref bool dogPhobiaIncluded, ref bool holesPhobia, ref bool holesPhobiaIncluded, ref bool insectPhobia, ref bool insectPhobiaIncluded, ref bool watchingPhobia, ref bool watchingPhobiaIncluded, ref bool tightSpacePhobia, ref bool tightSpacePhobiaIncluded)
		{
			ParsingHelper.TryAssignWithBool(jsonObjectParsed, "spider_phobia", ref spiderPhobia, ref spiderPhobiaIncluded);
			ParsingHelper.TryAssignWithBool(jsonObjectParsed, "darkness_phobia", ref darknessPhobia, ref darknessPhobiaIncluded);
			ParsingHelper.TryAssignWithBool(jsonObjectParsed, "dog_phobia", ref dogPhobia, ref dogPhobiaIncluded);
			ParsingHelper.TryAssignWithBool(jsonObjectParsed, "holes_phobia", ref holesPhobia, ref holesPhobiaIncluded);
			ParsingHelper.TryAssignWithBool(jsonObjectParsed, "insect_phobia", ref insectPhobia, ref insectPhobiaIncluded);
			ParsingHelper.TryAssignWithBool(jsonObjectParsed, "watching_phobia", ref watchingPhobia, ref watchingPhobiaIncluded);
			ParsingHelper.TryAssignWithBool(jsonObjectParsed, "tight_space_phobia", ref tightSpacePhobia, ref tightSpacePhobiaIncluded);
		}

		public static void CreateEntryFromJSON(JObject jObjectParsed, int newID = -1, string usermodFolderPath = "", string jsonFolderPath = "", EntryUnlockController entryUnlockerInstance = null)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as an entry. Possible syntax mistake?");
				return;
			}
			int accessLevel = -1;
			bool accessLevelAdded = false;
			bool replaceEntry = false;
			bool onlyDLC = false;
			bool includeDLC = false;
			bool includeMainCampaign = false;
			string entryName = "NO_NAME";
			string entryDescription = "NO_DESCRIPTION";
			List<string> arcadeCalls = new List<string>();
			Sprite entryPortrait = null;
			string entryPortraitLocation = "";
			string entryAudioClipLocation = "";
			string callerName = "NO_CALLER_NAME";
			string callerTranscript = "NO_TRANSCRIPT";
			string callerImageLocation = "";
			float callerReplaceChance = 0.1f;
			bool callerRestartCallAgain = true;
			Sprite callerPortrait = null;
			string consequenceCallerName = "NO_CALLER_NAME";
			string consequenceCallerTranscript = "NO_TRANSCRIPT";
			string consequenceCallerImageLocation = "";
			Sprite consequenceCallerPortrait = null;
			bool inCustomCampaign = false;
			string customCampaignName = "NO_CUSTOM_CAMPAIGN_NAME";
			bool deleteReplaceEntry = false;
			string videoUrlPortrait = string.Empty;
			bool isVideoPortrait = false;
			VariableChanged<bool> videoPortraitShouldLoop = new VariableChanged<bool>
			{
				Data = true
			};
			bool spiderPhobia = false;
			bool spiderPhobiaIncluded = false;
			bool darknessPhobia = false;
			bool darknessPhobiaIncluded = false;
			bool dogPhobia = false;
			bool dogPhobiaIncluded = false;
			bool holesPhobia = false;
			bool holesPhobiaIncluded = false;
			bool insectPhobia = false;
			bool insectPhobiaIncluded = false;
			bool watchingPhobia = false;
			bool watchingPhobiaIncluded = false;
			bool tightSpacePhobia = false;
			bool tightSpacePhobiaIncluded = false;
			EntryMetadata newExtra = null;
			ParseEntry(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref accessLevel, ref accessLevelAdded, ref replaceEntry, ref onlyDLC, ref includeDLC, ref includeMainCampaign, ref entryName, ref entryDescription, ref arcadeCalls, ref entryPortrait, ref entryPortraitLocation, ref entryAudioClipLocation, ref deleteReplaceEntry, ref inCustomCampaign, ref customCampaignName, ref videoUrlPortrait, ref isVideoPortrait, ref videoPortraitShouldLoop);
			ParsePhobias(ref jObjectParsed, ref spiderPhobia, ref spiderPhobiaIncluded, ref darknessPhobia, ref darknessPhobiaIncluded, ref dogPhobia, ref dogPhobiaIncluded, ref holesPhobia, ref holesPhobiaIncluded, ref insectPhobia, ref insectPhobiaIncluded, ref watchingPhobia, ref watchingPhobiaIncluded, ref tightSpacePhobia, ref tightSpacePhobiaIncluded);
			MainCampaignCallerParsing.ParseCaller(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref callerName, ref callerTranscript, ref callerImageLocation, ref callerReplaceChance, ref callerRestartCallAgain, ref callerPortrait);
			MainCampaignCallerParsing.ParseConsequenceCaller(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref consequenceCallerName, ref consequenceCallerTranscript, ref consequenceCallerImageLocation, ref consequenceCallerPortrait);
			CreateNewExtra(ref newExtra, ref entryName, ref newID, ref replaceEntry, ref callerName, ref callerTranscript, ref callerPortrait, ref callerReplaceChance, ref callerRestartCallAgain, ref accessLevel, ref onlyDLC, ref includeDLC, ref includeMainCampaign, ref consequenceCallerName, ref consequenceCallerTranscript, ref consequenceCallerPortrait, ref deleteReplaceEntry, ref inCustomCampaign, ref customCampaignName, ref videoUrlPortrait, ref isVideoPortrait, ref videoPortraitShouldLoop);
			JToken val = default(JToken);
			if (jObjectParsed.TryGetValue("caller_audio_clip_name", ref val))
			{
				string text = (string)val;
				if (string.IsNullOrEmpty(text) && !replaceEntry)
				{
					LoggingHelper.InfoLog("No caller audio given for file in " + jsonFolderPath + ". No audio will be heard.");
				}
				else if (!File.Exists(jsonFolderPath + "\\" + text) && !File.Exists(usermodFolderPath + "\\" + text))
				{
					LoggingHelper.ErrorLog("Location " + jsonFolderPath + " does not contain " + text + ". Unable to add audio.");
				}
				else
				{
					string text2 = jsonFolderPath + "\\" + text;
					if (!File.Exists(text2))
					{
						text2 = usermodFolderPath + "\\" + text;
					}
					AudioParsingHelper.UpdateAudioAtLocationNoKey(text2, delegate(RichAudioClip clip)
					{
						newExtra.CallerClip = AudioImport.CreateRichAudioClip(clip.clip);
					}, jsonFolderPath);
				}
			}
			JToken val2 = default(JToken);
			if (jObjectParsed.TryGetValue("consequence_caller_audio_clip_name", ref val2))
			{
				string text3 = (string)val2;
				if (string.IsNullOrEmpty(text3) && !replaceEntry)
				{
					LoggingHelper.InfoLog("No caller audio given for file in " + usermodFolderPath + ". No audio will be heard.");
				}
				else if (!File.Exists(jsonFolderPath + "\\" + text3) && !File.Exists(usermodFolderPath + "\\" + text3))
				{
					LoggingHelper.ErrorLog("Location " + jsonFolderPath + " does not contain " + text3 + ". Unable to add audio.");
				}
				else
				{
					string text4 = jsonFolderPath + "\\" + text3;
					if (!File.Exists(text4))
					{
						text4 = usermodFolderPath + "\\" + text3;
					}
					AudioParsingHelper.UpdateAudioAtLocationNoKey(text4, delegate(RichAudioClip clip)
					{
						newExtra.ConsequenceCallerClip = AudioImport.CreateRichAudioClip(clip.clip);
					}, jsonFolderPath);
				}
			}
			if ((jObjectParsed.ContainsKey("caller_audio_clip_name") || includeMainCampaign || inCustomCampaign || replaceEntry) && newExtra != null)
			{
				GlobalParsingVariables.EntriesMetadata.Add(newExtra);
			}
			IDParsingHelper.GenerateNewID(ref newExtra, ref newID, ref replaceEntry, ref jsonFolderPath, ref onlyDLC, ref includeDLC, ref entryUnlockerInstance, ref inCustomCampaign);
			if (replaceEntry)
			{
				MonsterProfile foundMonster = null;
				MonsterProfile foundMonsterXMAS = null;
				ReplaceEntryFunction(ref entryUnlockerInstance, ref onlyDLC, ref includeDLC, ref entryName, ref newID, ref entryPortraitLocation, ref entryPortrait, ref entryDescription, ref replaceEntry, ref arcadeCalls, ref accessLevel, ref accessLevelAdded, ref includeMainCampaign, ref spiderPhobiaIncluded, ref spiderPhobia, ref darknessPhobiaIncluded, ref darknessPhobia, ref dogPhobiaIncluded, ref dogPhobia, ref holesPhobiaIncluded, ref holesPhobia, ref insectPhobiaIncluded, ref insectPhobia, ref watchingPhobiaIncluded, ref watchingPhobia, ref tightSpacePhobiaIncluded, ref tightSpacePhobia, ref foundMonster, ref foundMonsterXMAS, ref inCustomCampaign, ref customCampaignName);
				if (!string.IsNullOrEmpty(entryAudioClipLocation))
				{
					string text5 = jsonFolderPath + "\\" + entryAudioClipLocation;
					if (!File.Exists(text5))
					{
						text5 = usermodFolderPath + "\\" + entryAudioClipLocation;
					}
					AudioParsingHelper.UpdateAudioAtLocationNoKey(text5, delegate(RichAudioClip clip)
					{
						if ((Object)(object)foundMonster != (Object)null)
						{
							foundMonster.monsterAudioClip = AudioImport.CreateRichAudioClip(clip.clip);
						}
						if ((Object)(object)foundMonsterXMAS != (Object)null)
						{
							foundMonsterXMAS.monsterAudioClip = AudioImport.CreateRichAudioClip(clip.clip);
						}
					}, jsonFolderPath);
				}
			}
			else
			{
				MonsterProfile newMonster = null;
				CreateNewEntryFunction(ref entryUnlockerInstance, ref onlyDLC, ref includeDLC, ref entryName, ref newID, ref entryPortrait, ref entryDescription, ref arcadeCalls, ref accessLevel, ref spiderPhobia, ref darknessPhobia, ref dogPhobia, ref holesPhobia, ref insectPhobia, ref watchingPhobia, ref tightSpacePhobia, ref newMonster, ref inCustomCampaign, ref customCampaignName);
				if (!string.IsNullOrEmpty(entryAudioClipLocation))
				{
					string text6 = jsonFolderPath + "\\" + entryAudioClipLocation;
					if (!File.Exists(text6))
					{
						text6 = usermodFolderPath + "\\" + entryAudioClipLocation;
					}
					AudioParsingHelper.UpdateAudioAtLocationNoKey(text6, delegate(RichAudioClip clip)
					{
						newMonster.monsterAudioClip = AudioImport.CreateRichAudioClip(clip.clip);
					}, jsonFolderPath);
				}
			}
			NewSafetyHelp.EntryManager.EntryManager.SortEntryProfiles(ref entryUnlockerInstance.allEntries.monsterProfiles);
			NewSafetyHelp.EntryManager.EntryManager.SortEntryProfiles(ref entryUnlockerInstance.allXmasEntries.monsterProfiles);
		}

		private static void CreateNewExtra(ref EntryMetadata newExtra, ref string entryName, ref int newID, ref bool replaceEntry, ref string callerName, ref string callerTranscript, ref Sprite callerPortrait, ref float callerReplaceChance, ref bool callerRestartCallAgain, ref int accessLevel, ref bool onlyDLC, ref bool includeDLC, ref bool includeMainCampaign, ref string consequenceCallerName, ref string consequenceCallerTranscript, ref Sprite consequenceCallerPortrait, ref bool deleteReplaceEntry, ref bool inCustomCampaign, ref string customCampaignName, ref string videoUrlPortrait, ref bool isVideoPortrait, ref VariableChanged<bool> videoPortraitShouldLoop)
		{
			newExtra = new EntryMetadata(entryName, newID)
			{
				Replace = replaceEntry,
				CallerName = callerName,
				CallTranscript = callerTranscript
			};
			if ((Object)(object)callerPortrait != (Object)null)
			{
				newExtra.CallerImage = callerPortrait;
			}
			newExtra.CallerReplaceChance = callerReplaceChance;
			newExtra.AllowCallAgainOverRestart = callerRestartCallAgain;
			newExtra.PermissionLevel = accessLevel;
			newExtra.OnlyDLC = onlyDLC;
			newExtra.IncludeInDlc = includeDLC;
			newExtra.InMainCampaign = includeMainCampaign;
			newExtra.ConsequenceName = consequenceCallerName;
			newExtra.ConsequenceTranscript = consequenceCallerTranscript;
			newExtra.ConsequenceCallerImage = consequenceCallerPortrait;
			newExtra.OnlyCustomCampaign = inCustomCampaign;
			newExtra.CustomCampaignName = customCampaignName;
			newExtra.VideoUrlPortrait = videoUrlPortrait;
			newExtra.IsVideoPortrait = isVideoPortrait;
			newExtra.VideoPortraitShouldLoop = videoPortraitShouldLoop;
			if (deleteReplaceEntry)
			{
				if (replaceEntry)
				{
					newExtra.DeleteEntry = deleteReplaceEntry;
				}
				else
				{
					LoggingHelper.WarningLog("Provided entry '" + entryName + "' cannot be deleted as it is not replacing an entry.");
				}
			}
		}

		private static void ReplaceEntryFunction(ref EntryUnlockController entryUnlockerInstance, ref bool onlyDLC, ref bool includeDLC, ref string entryName, ref int newID, ref string entryPortraitLocation, ref Sprite entryPortrait, ref string entryDescription, ref bool replaceEntry, ref List<string> arcadeCalls, ref int accessLevel, ref bool accessLevelAdded, ref bool includeMainCampaign, ref bool spiderPhobiaIncluded, ref bool spiderPhobia, ref bool darknessPhobiaIncluded, ref bool darknessPhobia, ref bool dogPhobiaIncluded, ref bool dogPhobia, ref bool holesPhobiaIncluded, ref bool holesPhobia, ref bool insectPhobiaIncluded, ref bool insectPhobia, ref bool watchingPhobiaIncluded, ref bool watchingPhobia, ref bool tightSpacePhobiaIncluded, ref bool tightSpacePhobia, ref MonsterProfile foundMonster, ref MonsterProfile foundMonsterXMAS, ref bool inCustomCampaign, ref string customCampaignName)
		{
			if (onlyDLC)
			{
				foundMonster = NewSafetyHelp.EntryManager.EntryManager.FindEntry(ref entryUnlockerInstance.allXmasEntries.monsterProfiles, entryName, newID);
			}
			else if (includeDLC)
			{
				foundMonster = NewSafetyHelp.EntryManager.EntryManager.FindEntry(ref entryUnlockerInstance.allEntries.monsterProfiles, entryName, newID);
				foundMonsterXMAS = NewSafetyHelp.EntryManager.EntryManager.FindEntry(ref entryUnlockerInstance.allXmasEntries.monsterProfiles, entryName, newID);
			}
			else if (includeMainCampaign)
			{
				foundMonster = NewSafetyHelp.EntryManager.EntryManager.FindEntry(ref entryUnlockerInstance.allEntries.monsterProfiles, entryName, newID);
			}
			else if (inCustomCampaign)
			{
				foundMonster = ScriptableObject.CreateInstance<MonsterProfile>();
				foundMonster.monsterID = newID;
				foundMonster.monsterName = entryName;
			}
			if (((Object)(object)foundMonster == (Object)null && !onlyDLC && !includeDLC) || ((Object)(object)foundMonster == (Object)null && (Object)(object)foundMonsterXMAS == (Object)null))
			{
				LoggingHelper.WarningLog("Entry that was suppose to replace an entry failed. Information about the entry: " + $"Was found: {(Object)(object)foundMonster != (Object)null} and was found in DLC: {(Object)(object)foundMonsterXMAS != (Object)null}. " + $"Replacer Name: {entryName} with Replacer ID: {newID}.");
				return;
			}
			LoggingHelper.InfoLog($"Found in the original list {entryName} / {newID}. " + "Now replacing/updating (for the main campaign / custom campaign) " + $"the entry with given information for {entryName} / {newID}.");
			if (!string.IsNullOrEmpty(entryPortraitLocation))
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.monsterPortrait = entryPortrait;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.monsterPortrait = entryPortrait;
				}
			}
			if (entryDescription != "NO_DESCRIPTION")
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.monsterDescription = entryDescription;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.monsterDescription = entryDescription;
				}
			}
			if (((entryName != "NO_NAME" && newID >= 0 && (Object)(object)foundMonster != (Object)null) & replaceEntry) && entryName != foundMonster.monsterName)
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.monsterName = entryName;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.monsterName = entryName;
				}
				if ((Object)(object)foundMonster != (Object)null)
				{
					((Object)foundMonster).name = entryName;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					((Object)foundMonsterXMAS).name = entryName;
				}
			}
			if (arcadeCalls.Count > 0)
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.arcadeCalls = arcadeCalls.ToArray();
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.arcadeCalls = arcadeCalls.ToArray();
				}
			}
			if (spiderPhobiaIncluded)
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.spider = spiderPhobia;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.spider = spiderPhobia;
				}
			}
			if (darknessPhobiaIncluded)
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.dark = darknessPhobia;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.dark = darknessPhobia;
				}
			}
			if (dogPhobiaIncluded)
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.dog = dogPhobia;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.dog = dogPhobia;
				}
			}
			if (holesPhobiaIncluded)
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.holes = holesPhobia;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.holes = holesPhobia;
				}
			}
			if (insectPhobiaIncluded)
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.insect = insectPhobia;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.insect = insectPhobia;
				}
			}
			if (watchingPhobiaIncluded)
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.watching = watchingPhobia;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.watching = watchingPhobia;
				}
			}
			if (tightSpacePhobiaIncluded)
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					foundMonster.tightSpace = tightSpacePhobia;
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					foundMonsterXMAS.tightSpace = tightSpacePhobia;
				}
			}
			if (accessLevel == -1)
			{
				accessLevel = 0;
			}
			switch (accessLevel)
			{
			case 0:
				if (accessLevelAdded)
				{
					if ((Object)(object)foundMonster != (Object)null)
					{
						NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.firstTierUnlocks.monsterProfiles, "firstTierUnlocks");
						NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.xmastFirstTier.monsterProfiles, "xmastFirstTier");
					}
					if ((Object)(object)foundMonsterXMAS != (Object)null)
					{
						NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.firstTierUnlocks.monsterProfiles, "firstTierUnlocks");
						NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.xmastFirstTier.monsterProfiles, "xmastFirstTier");
					}
				}
				break;
			case 1:
				if ((Object)(object)foundMonster != (Object)null)
				{
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.secondTierUnlocks.monsterProfiles, "secondTierUnlocks");
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.xmasSecondTier.monsterProfiles, "xmasSecondTier");
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.secondTierUnlocks.monsterProfiles, "secondTierUnlocks");
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.xmasSecondTier.monsterProfiles, "xmasSecondTier");
				}
				break;
			case 2:
				if ((Object)(object)foundMonster != (Object)null)
				{
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.thirdTierUnlocks.monsterProfiles, "thirdTierUnlocks");
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.xmasThirdTier.monsterProfiles, "xmasThirdTier");
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.thirdTierUnlocks.monsterProfiles, "thirdTierUnlocks");
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.xmasThirdTier.monsterProfiles, "xmasThirdTier");
				}
				break;
			case 3:
				if ((Object)(object)foundMonster != (Object)null)
				{
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.fourthTierUnlocks.monsterProfiles, "fourthTierUnlocks");
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.xmasFourthTier.monsterProfiles, "xmasFourthTier");
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.fourthTierUnlocks.monsterProfiles, "fourthTierUnlocks");
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.xmasFourthTier.monsterProfiles, "xmasFourthTier");
				}
				break;
			case 4:
				if ((Object)(object)foundMonster != (Object)null)
				{
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.fifthTierUnlocks.monsterProfiles, "fifthTierUnlocks");
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.xmasFourthTier.monsterProfiles, "xmasFourthTier");
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.fifthTierUnlocks.monsterProfiles, "fifthTierUnlocks");
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.xmasFourthTier.monsterProfiles, "xmasFourthTier");
				}
				break;
			case 5:
				if ((Object)(object)foundMonster != (Object)null)
				{
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.sixthTierUnlocks.monsterProfiles, "sixthTierUnlocks");
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonster, ref entryUnlockerInstance.xmasFourthTier.monsterProfiles, "xmasFourthTier");
				}
				if ((Object)(object)foundMonsterXMAS != (Object)null)
				{
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.sixthTierUnlocks.monsterProfiles, "sixthTierUnlocks");
					NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(foundMonsterXMAS, ref entryUnlockerInstance.xmasFourthTier.monsterProfiles, "xmasFourthTier");
				}
				break;
			}
			if (includeMainCampaign)
			{
				if ((Object)(object)foundMonster != (Object)null)
				{
					MonsterProfile foundMonsterCopy = foundMonster;
					NewSafetyHelp.EntryManager.EntryManager.ReplaceEntry(ref entryUnlockerInstance.allMainCampaignEntries.monsterProfiles, entryName, foundMonster);
					GlobalParsingVariables.EntriesMetadata.Find((EntryMetadata item) => item.Name == foundMonsterCopy.monsterName || item.ID == foundMonsterCopy.monsterID).ReferenceCopyEntry = foundMonster;
				}
				if (!((Object)(object)foundMonsterXMAS != (Object)null))
				{
					return;
				}
				MonsterProfile foundMonsterXMASCopy = foundMonsterXMAS;
				NewSafetyHelp.EntryManager.EntryManager.ReplaceEntry(ref entryUnlockerInstance.allMainCampaignEntries.monsterProfiles, entryName, foundMonsterXMAS);
				if ((Object)(object)foundMonster == (Object)null)
				{
					GlobalParsingVariables.EntriesMetadata.Find((EntryMetadata item) => item.Name == foundMonsterXMASCopy.monsterName || item.ID == foundMonsterXMASCopy.monsterID).ReferenceCopyEntry = foundMonster;
				}
			}
			else
			{
				if (!inCustomCampaign || !((Object)(object)foundMonster != (Object)null))
				{
					return;
				}
				string monsterNameCopy = foundMonster.monsterName;
				EntryMetadata entryMetadata = GlobalParsingVariables.EntriesMetadata.Find((EntryMetadata item) => item.Name == monsterNameCopy);
				if (entryMetadata != null)
				{
					entryMetadata.ReferenceCopyEntry = foundMonster;
					string customCampaignNameCopy = customCampaignName;
					CustomCampaign customCampaign = CustomCampaignGlobal.CustomCampaignsAvailable.Find((CustomCampaign customCampaignSearch) => customCampaignSearch.CampaignName == customCampaignNameCopy);
					if (customCampaign == null)
					{
						LoggingHelper.DebugLog("Custom Campaign replace entry found before custom campaign has been parsed. Adding to late add.");
						GlobalParsingVariables.PendingCustomCampaignReplaceEntries.Add(entryMetadata);
					}
					else
					{
						customCampaign.EntryReplaceOnlyInCampaign.Add(entryMetadata);
					}
				}
			}
		}

		private static void CreateNewEntryFunction(ref EntryUnlockController entryUnlockerInstance, ref bool onlyDLC, ref bool includeDLC, ref string entryName, ref int newID, ref Sprite entryPortrait, ref string entryDescription, ref List<string> arcadeCalls, ref int accessLevel, ref bool spiderPhobia, ref bool darknessPhobia, ref bool dogPhobia, ref bool holesPhobia, ref bool insectPhobia, ref bool watchingPhobia, ref bool tightSpacePhobia, ref MonsterProfile newMonster, ref bool inCustomCampaign, ref string customCampaignName)
		{
			newMonster = NewSafetyHelp.EntryManager.EntryManager.CreateEntry(entryName, entryDescription, newID, arcadeCalls: arcadeCalls.ToArray(), entryPortrait: entryPortrait, entryAudioClip: null, spiderPhobia: spiderPhobia, darknessPhobia: darknessPhobia, dogPhobia: dogPhobia, holesPhobia: holesPhobia, insectPhobia: insectPhobia, watchingPhobia: watchingPhobia, tightSpacePhobia: tightSpacePhobia);
			MonsterProfile _newMonsterCopy = newMonster;
			EntryMetadata entryMetadata = GlobalParsingVariables.EntriesMetadata.Find((EntryMetadata item) => item.Name == _newMonsterCopy.monsterName || item.ID == _newMonsterCopy.monsterID);
			if (entryMetadata != null)
			{
				entryMetadata.ReferenceCopyEntry = newMonster;
			}
			if (onlyDLC)
			{
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.allXmasEntries.monsterProfiles, "allXmasEntries");
			}
			else if (includeDLC)
			{
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.allEntries.monsterProfiles, "allEntries");
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.allXmasEntries.monsterProfiles, "allXmasEntries");
			}
			else if (inCustomCampaign)
			{
				string customCampaignNameCopy = customCampaignName;
				CustomCampaign customCampaign = CustomCampaignGlobal.CustomCampaignsAvailable.Find((CustomCampaign customCampaignSearch) => customCampaignSearch.CampaignName == customCampaignNameCopy);
				if (customCampaign != null)
				{
					LoggingHelper.DebugLog("Adding found custom campaign entry to the custom campaign.");
					if (entryMetadata != null)
					{
						customCampaign.EntriesOnlyInCampaign.Add(entryMetadata);
					}
					else
					{
						LoggingHelper.WarningLog("Entry that was suppose to be added in custom campaign does not exist as extra info. (Error Type: 1) ");
					}
				}
				else
				{
					LoggingHelper.DebugLog("Found entry (monster) before the custom campaign was found / does not exist.");
					if (entryMetadata != null)
					{
						GlobalParsingVariables.PendingCustomCampaignEntries.Add(entryMetadata);
					}
					else
					{
						LoggingHelper.WarningLog("Entry that was suppose to be added in custom campaign does not exist as extra info. (Error Type: 2) ");
					}
				}
			}
			else
			{
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.allEntries.monsterProfiles, "allEntries");
			}
			if (accessLevel == -1)
			{
				accessLevel = 0;
			}
			switch (accessLevel)
			{
			case 0:
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.firstTierUnlocks.monsterProfiles, "firstTierUnlocks");
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.xmastFirstTier.monsterProfiles, "xmastFirstTier");
				break;
			case 1:
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.secondTierUnlocks.monsterProfiles, "secondTierUnlocks");
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.xmasSecondTier.monsterProfiles, "xmasSecondTier");
				break;
			case 2:
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.thirdTierUnlocks.monsterProfiles, "thirdTierUnlocks");
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.xmasThirdTier.monsterProfiles, "xmasThirdTier");
				break;
			case 3:
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.fourthTierUnlocks.monsterProfiles, "fourthTierUnlocks");
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.xmasFourthTier.monsterProfiles, "xmasFourthTier");
				break;
			case 4:
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.fifthTierUnlocks.monsterProfiles, "fifthTierUnlocks");
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.xmasFourthTier.monsterProfiles, "xmasFourthTier");
				break;
			case 5:
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.sixthTierUnlocks.monsterProfiles, "sixthTierUnlocks");
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.xmasFourthTier.monsterProfiles, "xmasFourthTier");
				break;
			default:
				MelonLogger.Warning("WARNING: Provided access level is invalid (0-5). Defaulting to 0th access level.");
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.firstTierUnlocks.monsterProfiles, "firstTierUnlocks");
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(newMonster, ref entryUnlockerInstance.xmastFirstTier.monsterProfiles, "xmastFirstTier");
				break;
			}
			LoggingHelper.DebugLog("Finished parsing entry: " + newMonster.monsterName + ".", LoggingHelper.LoggingCategory.ENTRY);
		}
	}
}
namespace NewSafetyHelp.JSONParsing.CCParsing
{
	public static class Computer3DScreenParsing
	{
		public static void Create3DComputerScreen(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as a 3D computer screen. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "";
			Computer3DScreen custom3DScreen = Parse3DComputerScreen(ref jObjectParsed, ref customCampaignName, usermodFolderPath, jsonFolderPath);
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, custom3DScreen.MusicPath, delegate(RichAudioClip clip)
			{
				custom3DScreen.Music = clip;
			}, jsonFolderPath, "computer_3D_screen_music_clip_name");
			CustomCampaign customCampaign = CustomCampaignGlobal.CustomCampaignsAvailable.Find((CustomCampaign customCampaignSearch) => customCampaignSearch.CampaignName == customCampaignName);
			if (customCampaign != null)
			{
				customCampaign.CustomComputer3DScreens.Add(custom3DScreen);
				return;
			}
			LoggingHelper.DebugLog("Found 3D computer screen before the custom campaign was found / does not exist.");
			GlobalParsingVariables.PendingCustomCampaign3DComputerScreens.Add(custom3DScreen);
		}

		private static Computer3DScreen Parse3DComputerScreen(ref JObject jObjectParsed, ref string customCampaignName, string usermodFolderPath, string jsonFolderPath)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			bool target = false;
			int target2 = 0;
			VariableChanged<bool> target3 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Color> target4 = new VariableChanged<Color>
			{
				Data = default(Color)
			};
			VariableChanged<bool> target5 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Color> target6 = new VariableChanged<Color>
			{
				Data = default(Color)
			};
			VariableChanged<bool> target7 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Color> target8 = new VariableChanged<Color>
			{
				Data = default(Color)
			};
			VariableChanged<bool> target9 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Color> target10 = new VariableChanged<Color>
			{
				Data = default(Color)
			};
			VariableChanged<bool> target11 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Color> target12 = new VariableChanged<Color>
			{
				Data = default(Color)
			};
			VariableChanged<bool> target13 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target14 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target15 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target16 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Color> target17 = new VariableChanged<Color>
			{
				Data = default(Color)
			};
			VariableChanged<bool> target18 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target19 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<int> target20 = new VariableChanged<int>
			{
				Data = 10
			};
			VariableChanged<float> target21 = new VariableChanged<float>
			{
				Data = 0.01f
			};
			VariableChanged<Color> target22 = new VariableChanged<Color>
			{
				Data = default(Color)
			};
			VariableChanged<Sprite> target23 = new VariableChanged<Sprite>
			{
				Data = null
			};
			VariableChanged<List<string>> target24 = new VariableChanged<List<string>>
			{
				Data = null
			};
			VariableChanged<Sprite> target25 = new VariableChanged<Sprite>
			{
				Data = null
			};
			string target26 = null;
			VariableChanged<bool> target27 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target28 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<float> target29 = new VariableChanged<float>
			{
				Data = 0.07f
			};
			VariableChanged<bool> target30 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target31 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Sprite> target32 = new VariableChanged<Sprite>
			{
				Data = null
			};
			VariableChanged<bool> target33 = new VariableChanged<bool>
			{
				Data = false
			};
			ParsingHelper.TryAssign(jObjectParsed, "computer_3D_screen_custom_campaign_attached", ref customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "computer_3D_screen_in_main_campaign", ref target);
			ParsingHelper.TryAssign(jObjectParsed, "computer_3D_screen_priority", ref target2);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "computer_3D_screen_skip_click_wait_time", ref target3);
			ColorParsingHelper.ParseColor(jObjectParsed, "computer_3D_screen_main_light_color", ref target4);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_computer_3D_screen_main_light", ref target5);
			ColorParsingHelper.ParseColor(jObjectParsed, "computer_3D_screen_second_main_light_color", ref target6);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_computer_3D_screen_second_main_light", ref target7);
			ColorParsingHelper.ParseColor(jObjectParsed, "computer_3D_screen_desk_light_color", ref target8);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_computer_3D_screen_desk_light", ref target9);
			ColorParsingHelper.ParseColor(jObjectParsed, "computer_3D_screen_keyboard_light_color", ref target10);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_computer_3D_screen_keyboard_light", ref target11);
			ColorParsingHelper.ParseColor(jObjectParsed, "computer_3D_screen_right_light_color", ref target12);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_computer_3D_screen_right_light", ref target13);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_computer_screen_object", ref target14);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_keyboard_object", ref target15);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_table_object", ref target16);
			ColorParsingHelper.ParseColor(jObjectParsed, "computer_3D_screen_background_color", ref target17);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_computer_3D_screen_post_processing", ref target18);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_particles", ref target19);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "particle_emission_rate", ref target20);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "particle_start_size", ref target21);
			ColorParsingHelper.ParseColor(jObjectParsed, "particle_color", ref target22);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "particle_image_name", ref target23, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignListOrSingleElementVariableChanged(jObjectParsed, "title_text", ref target24);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "title_logo", ref target25, jsonFolderPath, usermodFolderPath, customCampaignName);
			AudioParsingHelper.TryAssignAudioPath(jObjectParsed, "computer_3D_screen_music_clip_name", ref target26, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "computer_3D_screen_music_move_closer", ref target27);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "computer_3D_screen_center_music", ref target28);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "computer_3D_screen_music_volume", ref target29);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_computer_3D_screen_music", ref target30);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "enable_computer_3D_screen_background_image", ref target31);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "computer_3D_screen_background_image", ref target32, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "computer_3D_screen_add_sun", ref target33);
			return new Computer3DScreen
			{
				CustomCampaignName = customCampaignName,
				InMainCampaign = target,
				ApplyPriority = target2,
				SkipClickTime = target3,
				MainLightColor = target4,
				DisableMainLight = target5,
				SecondMainLightColor = target6,
				DisableSecondMainLight = target7,
				DeskLightColor = target8,
				DisableDeskLight = target9,
				KeyboardLightColor = target10,
				DisableKeyboardLight = target11,
				RightLightColor = target12,
				DisableRightLight = target13,
				DisableComputerScreen = target14,
				DisableKeyboard = target15,
				DisableTable = target16,
				BackgroundColor = target17,
				DisablePostProcessing = target18,
				DisableParticles = target19,
				ParticleEmissionRate = target20,
				ParticleStartSize = target21,
				ParticleColor = target22,
				ParticleTexture = target23,
				TitleText = target24,
				TitleLogo = target25,
				MusicPath = target26,
				BringMusicCloser = target27,
				CenterMusic = target28,
				MusicVolume = target29,
				DisableMusic = target30,
				EnableBackgroundImage = target31,
				BackgroundImage = target32,
				AddSun = target33
			};
		}
	}
	public static class CustomCallerParsing
	{
		public static void CreateCustomCaller(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as a custom caller. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "NO_CUSTOM_CAMPAIGN";
			bool inMainCampaign = false;
			int orderInCampaign = -1;
			string customCallerMonsterName = "NO_CUSTOM_CALLER_MONSTER_NAME";
			string customCallerAudioPath = "";
			CustomCCaller customCCaller = ParseCustomCaller(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref customCampaignName, ref inMainCampaign, ref customCallerMonsterName, ref customCallerAudioPath, ref orderInCampaign, 116, GlobalParsingVariables.CustomCallersMainGame);
			if (customCallerMonsterName != "NO_CUSTOM_CALLER_MONSTER_NAME")
			{
				customCCaller.EntryNameAttached = customCallerMonsterName;
			}
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, customCCaller.CallerClipPath, delegate(RichAudioClip clip)
			{
				customCCaller.CallerClip = clip;
				customCCaller.IsCallerClipLoaded = true;
				if (AudioImport.CurrentLoadingAudios.Count <= 0)
				{
					AudioImport.ReCallCallerListStart();
				}
			}, jsonFolderPath, "custom_caller_audio_clip_name");
			if (inMainCampaign)
			{
				LoggingHelper.InfoLog("Found entry to add to the main game.");
				GlobalParsingVariables.CustomCallersMainGame.Add(orderInCampaign, customCCaller);
			}
			else
			{
				CustomCampaign namedCustomCampaign = CustomCampaignGlobal.GetNamedCustomCampaign(customCampaignName);
				if (namedCustomCampaign != null)
				{
					if (customCCaller.IsGameOverCaller)
					{
						namedCustomCampaign.CustomGameOverCallersInCampaign.Add(customCCaller);
					}
					else if (customCCaller.IsWarningCaller)
					{
						namedCustomCampaign.CustomWarningCallersInCampaign.Add(customCCaller);
					}
					else
					{
						namedCustomCampaign.CustomCallersInCampaign.Add(customCCaller);
					}
				}
				else
				{
					LoggingHelper.DebugLog("Found entry before the custom campaign was found / does not exist.");
					GlobalParsingVariables.PendingCustomCampaignCustomCallers.Add(customCCaller);
				}
			}
			LoggingHelper.DebugLog("Finished adding this custom caller.");
		}

		private static CustomCCaller ParseCustomCaller(ref JObject jObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref string customCampaignName, ref bool inMainCampaign, ref string customCallerMonsterName, ref string customCallerAudioPath, ref int orderInCampaign, int mainCampaignCallAmount, Dictionary<int, CustomCCaller> customCallerMainGame)
		{
			string target = "NO_CUSTOM_CALLER_NAME";
			string target2 = "NO_CUSTOM_CALLER_TRANSCRIPT";
			bool target3 = false;
			bool target4 = false;
			bool target5 = false;
			int target6 = -1;
			int target7 = -1;
			Sprite target8 = null;
			string target9 = null;
			VariableChanged<bool> target10 = new VariableChanged<bool>
			{
				Data = true
			};
			bool target11 = false;
			int target12 = -1;
			bool target13 = false;
			int target14 = -1;
			bool target15 = false;
			List<CallerAccuracyType> target16 = new List<CallerAccuracyType>();
			bool target17 = false;
			bool target18 = false;
			float target19 = 0f;
			JToken val = default(JToken);
			JToken val2 = default(JToken);
			if (jObjectParsed.TryGetValue("custom_campaign_attached", ref val))
			{
				customCampaignName = (string)val;
			}
			else if (jObjectParsed.TryGetValue("include_in_main_campaign", ref val2))
			{
				inMainCampaign = (bool)val2;
			}
			else
			{
				LoggingHelper.ErrorLog("Provided custom caller is not attached to either custom campaign or main campaign?");
			}
			ParsingHelper.TryAssign(jObjectParsed, "custom_caller_name", ref target);
			ParsingHelper.TryAssign(jObjectParsed, "custom_caller_transcript", ref target2);
			ImageParsingHelper.TryAssignSprite(jObjectParsed, "custom_caller_image_name", ref target8, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "order_in_campaign", ref orderInCampaign);
			ParsingHelper.TryAssign(jObjectParsed, "custom_caller_monster_name", ref customCallerMonsterName);
			ParsingHelper.TryAssign(jObjectParsed, "custom_caller_monster_id", ref target7);
			ParsingHelper.TryAssign(jObjectParsed, "custom_caller_increases_tier", ref target3);
			ParsingHelper.TryAssign(jObjectParsed, "custom_caller_last_caller_day", ref target4);
			AudioParsingHelper.TryAssignAudioPath(jObjectParsed, "custom_caller_audio_clip_name", ref customCallerAudioPath, jsonFolderPath, usermodFolderPath, target);
			ParsingHelper.TryAssign(jObjectParsed, "custom_caller_consequence_caller_id", ref target6);
			ParsingHelper.TryAssign(jObjectParsed, "custom_caller_downed_network", ref target5);
			ParsingHelper.TryAssign(jObjectParsed, "is_warning_caller", ref target11);
			ParsingHelper.TryAssign(jObjectParsed, "warning_caller_day", ref target12);
			ParsingHelper.TryAssign(jObjectParsed, "is_gameover_caller", ref target13);
			ParsingHelper.TryAssign(jObjectParsed, "gameover_caller_day", ref target14);
			bool wasAssigned = false;
			ParsingHelper.TryAssignWithBool(jObjectParsed, "is_accuracy_caller", ref target15, ref wasAssigned);
			bool flag = AccuracyParsingHelper.TryAssignListAccuracyType(jObjectParsed, ref target16);
			if (!wasAssigned && flag)
			{
				target15 = true;
			}
			ParsingHelper.TryAssign(jObjectParsed, "accuracy_caller_count_total_day_instead", ref target17);
			bool callerHasAnimatedPortrait = VideoParsingHelper.TryAssignVideoPath(jObjectParsed, "custom_caller_animated_portrait_name", ref target9, jsonFolderPath, usermodFolderPath);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "custom_caller_animated_portrait_should_loop", ref target10);
			ParsingHelper.TryAssign(jObjectParsed, "is_timed_caller", ref target18);
			ParsingHelper.TryAssign(jObjectParsed, "timed_caller_duration", ref target19);
			if (orderInCampaign < 0 && !target11 && !target13)
			{
				LoggingHelper.WarningLog("No order was provided for custom caller at '" + jsonFolderPath + "'. This could accidentally replace a caller! Set to replace last caller! " + ((target != null && target != "NO_CUSTOM_CALLER_NAME") ? ("(Caller Name: " + target + ")") : ""));
				orderInCampaign = mainCampaignCallAmount + customCallerMainGame.Count;
			}
			return new CustomCCaller(orderInCampaign)
			{
				CallerName = target,
				CallerImage = target8,
				CallTranscript = target2,
				EntryIDAttached = target7,
				InCustomCampaign = !inMainCampaign,
				CallerIncreasesTier = target3,
				CallerClipPath = customCallerAudioPath,
				ConsequenceCallerID = target6,
				CustomCampaignName = customCampaignName,
				LastDayCaller = target4,
				DownedNetworkCaller = target5,
				CallerAnimatedPortraitURL = target9,
				CallerHasAnimatedPortrait = callerHasAnimatedPortrait,
				CallerAnimatedPortraitShouldLoop = target10,
				IsWarningCaller = target11,
				WarningCallDay = target12,
				IsGameOverCaller = target13,
				GameOverCallDay = target14,
				IsAccuracyCaller = target15,
				AccuracyChecks = target16,
				CountEveryCallerForLocalAccuracy = target17,
				IsTimedCaller = target18,
				TimedCallerDuration = target19
			};
		}
	}
	public static class CustomCampaignParsing
	{
		public static void CreateCustomCampaign(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as a custom campaign. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "NO_CAMPAIGN_NAME_PROVIDED";
			CustomCampaign customCampaign = ParseCampaignFile(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref customCampaignName);
			if (GlobalParsingVariables.PendingCustomCampaignCustomCallers.Count > 0)
			{
				List<CustomCCaller> list = new List<CustomCCaller>(GlobalParsingVariables.PendingCustomCampaignCustomCallers);
				foreach (CustomCCaller item in list)
				{
					if (item.CustomCampaignName == customCampaignName)
					{
						LoggingHelper.DebugLog("DEBUG: Adding missing custom caller " + item.CallerName + " to the custom campaign: " + customCampaignName + ".");
						if (item.IsGameOverCaller)
						{
							customCampaign.CustomGameOverCallersInCampaign.Add(item);
						}
						else if (item.IsWarningCaller)
						{
							customCampaign.CustomWarningCallersInCampaign.Add(item);
						}
						else
						{
							customCampaign.CustomCallersInCampaign.Add(item);
						}
						GlobalParsingVariables.PendingCustomCampaignCustomCallers.Remove(item);
					}
				}
			}
			PendingParsingHelper.AddPendingElementsToCampaign(ref GlobalParsingVariables.PendingCustomCampaignEntries, ref customCampaign.EntriesOnlyInCampaign, customCampaignName, "entries");
			PendingParsingHelper.AddPendingElementsToCampaign(ref GlobalParsingVariables.PendingCustomCampaignReplaceEntries, ref customCampaign.EntryReplaceOnlyInCampaign, customCampaignName, "replace-entries");
			PendingParsingHelper.AddPendingElementsToCampaign(ref GlobalParsingVariables.PendingCustomCampaignEmails, ref customCampaign.Emails, customCampaignName, "emails");
			PendingParsingHelper.AddPendingElementsToCampaign(ref GlobalParsingVariables.PendingCustomCampaignVideos, ref customCampaign.CustomVideos, customCampaignName, "videos");
			PendingParsingHelper.AddPendingElementsToCampaign(ref GlobalParsingVariables.PendingCustomCampaignCutscenes, ref customCampaign.CustomCutscenes, customCampaignName, "cutscenes");
			if (GlobalParsingVariables.PendingCustomCampaignMusic.Count > 0)
			{
				List<CustomMusic> list2 = new List<CustomMusic>(GlobalParsingVariables.PendingCustomCampaignMusic);
				foreach (CustomMusic item2 in list2)
				{
					if (item2.CustomCampaignName == customCampaignName)
					{
						LoggingHelper.DebugLog(() => "DEBUG: Adding missing music to the custom campaign: " + customCampaignName + ".");
						if (item2.IsIntermissionMusic)
						{
							customCampaign.CustomIntermissionMusic.Add(item2);
						}
						else
						{
							customCampaign.CustomMusic.Add(item2);
						}
						GlobalParsingVariables.PendingCustomCampaignMusic.Remove(item2);
					}
				}
			}
			customCampaign.ModifierSources = new List<ModifierSource>
			{
				new ModifierSource
				{
					ModifierName = "General Modifier",
					RequirementForAddingToModifierList = (CustomModifier modifier) => modifier.UnlockDays == null && !modifier.OnlyIfGameFinished
				},
				new ModifierSource
				{
					ModifierName = "General Modifier when game is finished.",
					SourceCondition = (CustomCampaign c) => c.SavedGameFinished == 1 || c.SavedGameFinishedDisplay == 1,
					RequirementForAddingToModifierList = (CustomModifier modifier) => modifier.UnlockDays == null && modifier.OnlyIfGameFinished
				},
				new ModifierSource
				{
					ModifierName = "Day Modifier",
					RequirementForAddingToModifierList = (CustomModifier modifier) => modifier.UnlockDays != null && !modifier.OnlyIfGameFinished,
					ModifierExtraSelectionCondition = (CustomModifier modifier) => modifier.UnlockDays != null && modifier.UnlockDays.Contains(GlobalVariables.currentDay)
				},
				new ModifierSource
				{
					ModifierName = "Day Modifier when the game is finished.",
					SourceCondition = (CustomCampaign c) => c.SavedGameFinished == 1 || c.SavedGameFinishedDisplay == 1,
					RequirementForAddingToModifierList = (CustomModifier modifier) => modifier.UnlockDays != null && modifier.OnlyIfGameFinished,
					ModifierExtraSelectionCondition = (CustomModifier modifier) => modifier.UnlockDays != null && modifier.UnlockDays.Contains(GlobalVariables.currentDay)
				}
			};
			if (GlobalParsingVariables.PendingCustomCampaignModifiers.Count > 0)
			{
				List<CustomModifier> list3 = new List<CustomModifier>(GlobalParsingVariables.PendingCustomCampaignModifiers);
				foreach (CustomModifier item3 in list3)
				{
					if (!(item3.CustomCampaignName == customCampaignName))
					{
						continue;
					}
					LoggingHelper.DebugLog(() => "DEBUG: Adding missing modifier to the custom campaign: " + customCampaignName + ".");
					if (item3.UnlockDays == null)
					{
						if (!item3.OnlyIfGameFinished)
						{
							customCampaign.ModifierSources[0].Modifiers.Add(item3);
						}
						else
						{
							customCampaign.ModifierSources[1].Modifiers.Add(item3);
						}
					}
					else if (!item3.OnlyIfGameFinished)
					{
						customCampaign.ModifierSources[2].Modifiers.Add(item3);
					}
					else
					{
						customCampaign.ModifierSources[3].Modifiers.Add(item3);
					}
					GlobalParsingVariables.PendingCustomCampaignModifiers.Remove(item3);
				}
			}
			if (GlobalParsingVariables.PendingCustomCampaignThemes.Count > 0)
			{
				List<CustomTheme> list4 = new List<CustomTheme>(GlobalParsingVariables.PendingCustomCampaignThemes);
				foreach (CustomTheme item4 in list4)
				{
					if (item4.CustomCampaignName == customCampaignName)
					{
						LoggingHelper.DebugLog(() => "DEBUG: Adding missing theme to the custom campaign: " + customCampaignName + ".");
						if (item4.UnlockDays == null)
						{
							customCampaign.CustomThemesGeneral.Add(item4);
						}
						else
						{
							customCampaign.CustomThemesDays.Add(item4);
						}
						GlobalParsingVariables.PendingCustomCampaignThemes.Remove(item4);
					}
				}
			}
			PendingParsingHelper.AddPendingElementsToCampaign(ref GlobalParsingVariables.PendingCustomCampaignRingtones, ref customCampaign.CustomRingtones, customCampaignName, "ringtone");
			PendingParsingHelper.AddPendingElementsToCampaign(ref GlobalParsingVariables.PendingCustomCampaignTextFile, ref customCampaign.CustomTextProgramFiles, customCampaignName, "text file");
			PendingParsingHelper.AddPendingElementsToCampaign(ref GlobalParsingVariables.PendingCustomCampaign3DComputerScreens, ref customCampaign.CustomComputer3DScreens, customCampaignName, "custom 3D screen");
			PendingParsingHelper.AddPendingElementsToCampaign(ref GlobalParsingVariables.PendingCustomCampaignLinkApps, ref customCampaign.LinkApps, customCampaignName, "link app");
			CustomCampaignGlobal.CustomCampaignsAvailable.Add(customCampaign);
		}

		private static CustomCampaign ParseCampaignFile(ref JObject jObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref string customCampaignName)
		{
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Expected O, but got Unknown
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Expected O, but got Unknown
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Expected O, but got Unknown
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Expected O, but got Unknown
			string target = "NO_NAME\nPROVIDED";
			Sprite target2 = null;
			List<List<string>> list = new List<List<string>>
			{
				new List<string> { "" },
				new List<string> { "" }
			};
			string target3 = "";
			int target4 = -1;
			int target5 = -1;
			int target6 = -1;
			bool target7 = false;
			int target8 = 7;
			List<string> list2 = new List<string>();
			bool target9 = false;
			bool target10 = false;
			bool flag = false;
			bool target11 = false;
			bool target12 = false;
			bool target13 = false;
			int target14 = 60;
			int target15 = 60;
			List<int> list3 = new List<int>();
			VariableChanged<bool> target16 = new VariableChanged<bool>
			{
				Data = false
			};
			string target17 = "";
			string target18 = "";
			bool target19 = true;
			bool target20 = false;
			List<float> target21 = new List<float>();
			bool enableCustomWaitBetweenCallers = false;
			bool target22 = false;
			bool target23 = false;
			bool target24 = false;
			bool target25 = false;
			bool target26 = true;
			bool target27 = false;
			string target28 = "";
			Sprite target29 = null;
			bool target30 = true;
			List<Sprite> list4 = new List<Sprite>();
			Sprite target31 = null;
			bool target32 = false;
			bool target33 = false;
			Sprite target34 = null;
			float target35 = 0.2627f;
			bool target36 = false;
			string target37 = null;
			VariableChanged<bool> target38 = new VariableChanged<bool>
			{
				Data = false
			};
			bool target39 = true;
			VariableChanged<bool> target40 = new VariableChanged<bool>
			{
				Data = true
			};
			VariableChanged<bool> target41 = new VariableChanged<bool>
			{
				Data = false
			};
			ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_name", ref customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_desktop_name", ref target);
			ParsingHelper.TryAssign(jObjectParsed, "desktop_username_text", ref target3);
			ParsingHelper.TryAssign(jObjectParsed, "start_year", ref target4);
			ParsingHelper.TryAssign(jObjectParsed, "start_month", ref target5);
			ParsingHelper.TryAssign(jObjectParsed, "start_day", ref target6);
			ParsingHelper.TryAssign(jObjectParsed, "use_europe_date_format", ref target7);
			ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_days", ref target8);
			ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_remove_main_entries", ref target9);
			ParsingHelper.TryAssign(jObjectParsed, "use_dlc_entries", ref target10);
			JToken val = default(JToken);
			if (jObjectParsed.TryGetValue("custom_campaign_empty_main_entries_permission", ref val))
			{
				flag = Extensions.Value<bool>((IEnumerable<JToken>)val);
				ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_show_new_tag_for_main_entries", ref target11);
			}
			JToken val2 = default(JToken);
			if (jObjectParsed.TryGetValue("custom_campaign_show_new_tag_for_main_entries", ref val2) && !flag)
			{
				LoggingHelper.WarningLog("Provided option to show 'NEW' tag for main game entries but main game entries are not being reset?");
			}
			ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_gameover_threshold", ref target14);
			ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_warning_threshold", ref target15);
			JToken val3 = default(JToken);
			if (jObjectParsed.TryGetValue("custom_campaign_days_names", ref val3))
			{
				JArray val4 = (JArray)val3;
				foreach (JToken item in val4)
				{
					list2.Add((string)item);
				}
			}
			ImageParsingHelper.TryAssignSprite(jObjectParsed, "custom_campaign_icon_image_name", ref target2, jsonFolderPath, usermodFolderPath, customCampaignName);
			JToken val5 = default(JToken);
			if (jObjectParsed.TryGetValue("custom_campaign_loading_desktop_text1", ref val5))
			{
				JArray val6 = (JArray)val5;
				list[0] = new List<string>();
				for (int i = 0; i < ((JContainer)val6).Count; i++)
				{
					list[0].Add((string)val6[i]);
				}
			}
			JToken val7 = default(JToken);
			if (jObjectParsed.TryGetValue("custom_campaign_loading_desktop_text2", ref val7))
			{
				JArray val8 = (JArray)val7;
				list[1] = new List<string>();
				for (int j = 0; j < ((JContainer)val8).Count; j++)
				{
					list[1].Add((string)val8[j]);
				}
			}
			JToken val9 = default(JToken);
			if (jObjectParsed.TryGetValue("custom_campaign_threshold_amount", ref val9))
			{
				JArray val10 = (JArray)val9;
				for (int k = 0; k < ((JContainer)val10).Count; k++)
				{
					list3.Add((int)val10[k]);
				}
			}
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "reset_game_beaten_on_week_reset", ref target16);
			VideoParsingHelper.TryAssignVideoPath(jObjectParsed, "custom_campaign_end_cutscene_video_name", ref target17, jsonFolderPath, usermodFolderPath);
			VideoParsingHelper.TryAssignVideoPath(jObjectParsed, "custom_campaign_gameover_cutscene_video_name", ref target18, jsonFolderPath, usermodFolderPath);
			ParsingHelper.TryAssign(jObjectParsed, "always_randomize_music", ref target19);
			ParsingHelper.TryAssign(jObjectParsed, "remove_default_music", ref target20);
			ParsingHelper.TryAssign(jObjectParsed, "entry_browser_always_active", ref target22);
			ParsingHelper.TryAssign(jObjectParsed, "scorecard_always_active", ref target23);
			ParsingHelper.TryAssign(jObjectParsed, "artbook_always_active", ref target24);
			ParsingHelper.TryAssign(jObjectParsed, "arcade_always_active", ref target25);
			ParsingHelper.TryAssign(jObjectParsed, "always_show_skip_call_wait_time", ref target27);
			ParsingHelper.TryAssign(jObjectParsed, "rename_main_game_desktop_icon", ref target28);
			ParsingHelper.TryAssign(jObjectParsed, "disable_main_campaign_videos", ref target26);
			ParsingHelper.TryAssign(jObjectParsed, "remove_default_emails", ref target30);
			ImageParsingHelper.TryAssignSprite(jObjectParsed, "main_game_desktop_icon_path", ref target29, jsonFolderPath, usermodFolderPath, customCampaignName);
			JToken val11 = default(JToken);
			if (jObjectParsed.TryGetValue("custom_campaign_desktop_backgrounds", ref val11))
			{
				JArray val12 = (JArray)val11;
				for (int l = 0; l < ((JContainer)val12).Count; l++)
				{
					if (string.IsNullOrEmpty((string)val12[l]))
					{
						LoggingHelper.ErrorLog($"Did not find '{val12[l]}'. Adding null.");
						list4.Add(null);
					}
					else
					{
						list4.Add(ImageImport.LoadImage(jsonFolderPath + "\\" + (object)val12[l], usermodFolderPath + "\\" + (object)val12[l]));
					}
				}
			}
			ImageParsingHelper.TryAssignSprite(jObjectParsed, "custom_campaign_desktop_game_finished_background", ref target31, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "disable_desktop_logo", ref target33);
			ParsingHelper.TryAssign(jObjectParsed, "disable_green_color_on_desktop", ref target32);
			ParsingHelper.TryAssign(jObjectParsed, "custom_desktop_logo_transparency", ref target35);
			ParsingHelper.TryAssign(jObjectParsed, "skip_callers_correctly", ref target12);
			ParsingHelper.TryAssign(jObjectParsed, "game_over_immunity", ref target13);
			ImageParsingHelper.TryAssignSprite(jObjectParsed, "custom_desktop_logo_name", ref target34, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, new List<string> { "defaultTheme", "default_theme" }, ref target37);
			ParsingHelper.TryAssign(jObjectParsed, "disable_theme_dropdown", ref target36);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "remove_default_themes", ref target38);
			ParsingHelper.TryAssign(jObjectParsed, "do_not_account_default_ringtone", ref target39);
			ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, "waiting_time", ref target21);
			if (target21 != null && target21.Count > 0)
			{
				enableCustomWaitBetweenCallers = true;
			}
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "skip_3D_computer_screen", ref target40);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "custom_campaign_fade_to_black", ref target41);
			return new CustomCampaign
			{
				CampaignName = customCampaignName,
				CampaignDays = target8,
				CampaignIcon = target2,
				CampaignDayStrings = list2,
				CampaignDesktopName = target,
				RemoveExistingEntries = target9,
				UseDLCEntries = target10,
				ResetDefaultEntriesPermission = flag,
				DoShowNewTagForMainGameEntries = target11,
				SkipCallersCorrectly = target12,
				LoadingTexts = list,
				DesktopUsernameText = target3,
				DesktopDateStartYear = target4,
				DesktopDateStartMonth = target5,
				DesktopDateStartDay = target6,
				UseEuropeDateFormat = target7,
				GameOverThreshold = target14,
				WarningThreshold = target15,
				WarningCallThresholdCallerAmounts = list3,
				ShouldResetGameBeatenVariableOnReset = target16,
				EndCutsceneVideoName = target17,
				GameOverCutsceneVideoName = target18,
				AlwaysRandomMusic = target19,
				RemoveDefaultMusic = target20,
				EntryBrowserAlwaysActive = target22,
				ScorecardAlwaysActive = target23,
				ArtbookAlwaysActive = target24,
				ArcadeAlwaysActive = target25,
				DisableAllDefaultVideos = target26,
				RenameMainGameDesktopIcon = target28,
				ChangeMainGameDesktopIcon = target29,
				AlwaysSkipCallButton = target27,
				GameOverImmunity = target13,
				RemoveDefaultEmails = target30,
				BackgroundSprites = list4,
				GameFinishedBackground = target31,
				DisableDesktopLogo = target33,
				CustomDesktopLogo = target34,
				CustomDesktopLogoTransparency = target35,
				DisableGreenColorBackground = target32,
				DefaultTheme = target37,
				DisablePickingThemeOption = target36,
				RemoveDefaultThemes = target38,
				DoNotAccountDefaultRingtone = target39,
				Skip3DComputerScreenForCustomCampaign = target40,
				FadeInCustomCampaign = target41,
				WaitBetweenCallers = target21,
				EnableCustomWaitBetweenCallers = enableCustomWaitBetweenCallers
			};
		}
	}
	public static class CutsceneParsing
	{
		public static void CreateCutscene(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as a cutscene. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "";
			CustomCutscene item = ParseCutscene(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref customCampaignName);
			CustomCampaign namedCustomCampaign = CustomCampaignGlobal.GetNamedCustomCampaign(customCampaignName);
			if (namedCustomCampaign != null)
			{
				namedCustomCampaign.CustomCutscenes.Add(item);
				return;
			}
			LoggingHelper.DebugLog("Found custom cutscene before the custom campaign was found / does not exist.");
			GlobalParsingVariables.PendingCustomCampaignCutscenes.Add(item);
		}

		private static CustomCutscene ParseCutscene(ref JObject jObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref string customCampaignName)
		{
			string target = null;
			bool isUsingOldSystem = false;
			List<GeneralAccuracyType> target2 = null;
			List<CallerRequirement> target3 = null;
			int target4 = 0;
			ParsingHelper.TryAssign(jObjectParsed, "cutscene_custom_campaign_name", ref customCampaignName);
			VideoParsingHelper.TryAssignVideoPath(jObjectParsed, "custom_cutscene_video_file", ref target, jsonFolderPath, usermodFolderPath);
			AccuracyParsingHelper.TryAssignListGeneralAccuracyType(jObjectParsed, ref target2, ref isUsingOldSystem, "custom_cutscene_required_accuracy", "custom_cutscene_accuracy_days", "custom_cutscene_accuracy_check_type");
			CallerRequirementParsingHelper.TryAssignCallerRequirement(jObjectParsed, ref target3, "custom_cutscene_caller_requirement_ids", "custom_cutscene_caller_requirement_should_be_correct");
			ParsingHelper.TryAssign(jObjectParsed, "custom_cutscene_priority", ref target4);
			return new CustomCutscene
			{
				CustomCampaignName = customCampaignName,
				CutsceneVideoPath = target,
				UnlockAccuracy = target2,
				UnlockRequiredCallers = target3,
				ApplyPriority = target4
			};
		}
	}
	public static class EmailParsing
	{
		public static void CreateEmail(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as a email. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "";
			bool inMainCampaign = false;
			CustomEmail item = ParseEmail(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref customCampaignName, ref inMainCampaign);
			if (inMainCampaign)
			{
				GlobalParsingVariables.MainCampaignEmails.Add(item);
				return;
			}
			CustomCampaign customCampaign = CustomCampaignGlobal.CustomCampaignsAvailable.Find((CustomCampaign customCampaignSearch) => customCampaignSearch.CampaignName == customCampaignName);
			if (customCampaign != null)
			{
				customCampaign.Emails.Add(item);
				return;
			}
			LoggingHelper.DebugLog("Found Email before the custom campaign was found / does not exist.");
			GlobalParsingVariables.PendingCustomCampaignEmails.Add(item);
		}

		private static CustomEmail ParseEmail(ref JObject jObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref string customCampaignName, ref bool inMainCampaign)
		{
			string target = "";
			string target2 = "";
			string target3 = "";
			Uri target4 = null;
			Sprite target5 = null;
			string target6 = null;
			VariableChanged<bool> target7 = new VariableChanged<bool>
			{
				Data = true
			};
			bool target8 = false;
			int target9 = 0;
			float target10 = 0f;
			int target11 = 0;
			List<CallerRequirement> target12 = null;
			List<GeneralAccuracyType> target13 = null;
			bool isUsingOldSystem = true;
			ParsingHelper.TryAssign(jObjectParsed, "email_in_main_campaign", ref inMainCampaign);
			ParsingHelper.TryAssign(jObjectParsed, "email_custom_campaign_name", ref customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "email_subject", ref target);
			ParsingHelper.TryAssign(jObjectParsed, "email_sender", ref target2);
			ParsingHelper.TryAssign(jObjectParsed, "email_body", ref target3);
			ParsingHelper.TryAssign(jObjectParsed, "email_unlock_day", ref target9);
			ParsingHelper.TryAssign(jObjectParsed, "unlock_when_game_finished", ref target8);
			ParsingHelper.TryAssign(jObjectParsed, "email_priority", ref target11);
			CallerRequirementParsingHelper.TryAssignCallerRequirement(jObjectParsed, ref target12);
			ParsingHelper.TryAssign(jObjectParsed, "email_unlock_threshold", ref target10);
			AccuracyParsingHelper.TryAssignListGeneralAccuracyType(jObjectParsed, ref target13, ref isUsingOldSystem);
			ImageParsingHelper.TryAssignSprite(jObjectParsed, "email_image", ref target5, jsonFolderPath, usermodFolderPath, customCampaignName);
			bool hasAnimatedVideo = VideoParsingHelper.TryAssignVideoPath(jObjectParsed, "email_animated_image", ref target6, jsonFolderPath, usermodFolderPath);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "email_animated_image_should_loop", ref target7);
			URLParsingHelper.TryAssignURL(jObjectParsed, "email_click_url", ref target4);
			return new CustomEmail
			{
				InMainCampaign = inMainCampaign,
				CustomCampaignName = customCampaignName,
				EmailSubject = target,
				SenderName = target2,
				EmailBody = target3,
				EmailClickURL = target4,
				EmailPriority = target11,
				UnlockWhenGameFinished = target8,
				UnlockDay = target9,
				UnlockThreshold = target10,
				UnlockAccuracy = target13,
				UseOldAccuracyChecks = isUsingOldSystem,
				UnlockRequiredCallers = target12,
				EmailImage = target5,
				EmailAnimatedVideo = target6,
				HasAnimatedVideo = hasAnimatedVideo,
				EmailAnimatedVideoShouldLoop = target7
			};
		}
	}
	public static class LinkAppParsing
	{
		public static void CreateLinkApp(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as a link app. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "";
			LinkApp item = ParseLinkApp(ref jObjectParsed, ref customCampaignName, usermodFolderPath, jsonFolderPath);
			CustomCampaign customCampaign = CustomCampaignGlobal.CustomCampaignsAvailable.Find((CustomCampaign customCampaignSearch) => customCampaignSearch.CampaignName == customCampaignName);
			if (customCampaign != null)
			{
				customCampaign.LinkApps.Add(item);
				return;
			}
			LoggingHelper.DebugLog("Found link app before the custom campaign was found / does not exist.");
			GlobalParsingVariables.PendingCustomCampaignLinkApps.Add(item);
		}

		private static LinkApp ParseLinkApp(ref JObject jObjectParsed, ref string customCampaignName, string usermodFolderPath, string jsonFolderPath)
		{
			Uri target = null;
			int target2 = 0;
			VariableChanged<int> target3 = new VariableChanged<int>
			{
				Data = 0
			};
			VariableChanged<string> target4 = new VariableChanged<string>
			{
				Data = "No Name Provided"
			};
			VariableChanged<Sprite> target5 = new VariableChanged<Sprite>
			{
				Data = null
			};
			bool target6 = false;
			int target7 = 0;
			List<CallerRequirement> target8 = null;
			List<GeneralAccuracyType> target9 = null;
			ParsingHelper.TryAssign(jObjectParsed, "link_app_custom_campaign_name", ref customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "link_app_unlock_day", ref target7);
			ParsingHelper.TryAssign(jObjectParsed, "link_app_unlock_when_game_finished", ref target6);
			ParsingHelper.TryAssign(jObjectParsed, "link_app_priority", ref target2);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "link_app_desktop_position", ref target3);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "link_app_desktop_name", ref target4);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "link_app_desktop_icon", ref target5, jsonFolderPath, usermodFolderPath, customCampaignName);
			CallerRequirementParsingHelper.TryAssignCallerRequirement(jObjectParsed, ref target8, "link_app_caller_requirement_ids", "link_app_caller_requirement_should_be_correct");
			bool isUsingOldSystem = true;
			AccuracyParsingHelper.TryAssignListGeneralAccuracyType(jObjectParsed, ref target9, ref isUsingOldSystem, "link_app_required_accuracy", "link_app_accuracy_days", "link_app_accuracy_check_type");
			URLParsingHelper.TryAssignURL(jObjectParsed, "link_app_click_url", ref target);
			return new LinkApp
			{
				CustomCampaignName = customCampaignName,
				LinkAppClickURL = target,
				LinkAppPriority = target2,
				GameObjectOrder = target3,
				DesktopName = target4,
				DesktopIcon = target5,
				UnlockWhenGameFinished = target6,
				UnlockDay = target7,
				UnlockAccuracy = target9,
				UnlockRequiredCallers = target8
			};
		}
	}
	public static class MusicParsing
	{
		public static void CreateMusic(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as music. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "";
			CustomMusic customMusic = ParseMusic(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref customCampaignName);
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, customMusic.MusicClipPath, delegate(RichAudioClip clip)
			{
				customMusic.MusicClip = clip;
			}, jsonFolderPath, "music_audio_clip_name");
			CustomCampaign namedCustomCampaign = CustomCampaignGlobal.GetNamedCustomCampaign(customCampaignName);
			if (namedCustomCampaign != null)
			{
				if (customMusic.IsIntermissionMusic)
				{
					namedCustomCampaign.CustomIntermissionMusic.Add(customMusic);
				}
				else
				{
					namedCustomCampaign.CustomMusic.Add(customMusic);
				}
			}
			else
			{
				LoggingHelper.DebugLog("Found Music File before the custom campaign was found / does not exist.");
				GlobalParsingVariables.PendingCustomCampaignMusic.Add(customMusic);
			}
		}

		private static CustomMusic ParseMusic(ref JObject jObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref string customCampaignName)
		{
			int target = 0;
			string target2 = "";
			bool target3 = false;
			bool target4 = false;
			List<float> target5 = new List<float>();
			List<float> target6 = new List<float>();
			ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_attached", ref customCampaignName);
			AudioParsingHelper.TryAssignAudioPath(jObjectParsed, "music_audio_clip_name", ref target2, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "unlock_day", ref target);
			ParsingHelper.TryAssign(jObjectParsed, "only_play_on_unlock_day", ref target3);
			ParsingHelper.TryAssign(jObjectParsed, "is_intermission_music", ref target4);
			ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, "start_range", ref target5);
			ParsingHelper.TryAssignListOrSingleElement(jObjectParsed, "end_range", ref target6);
			return new CustomMusic
			{
				CustomCampaignName = customCampaignName,
				MusicClipPath = target2,
				UnlockDay = target,
				OnlyPlayOnUnlockDay = target3,
				IsIntermissionMusic = target4,
				StartRange = target5,
				EndRange = target6
			};
		}
	}
	public static class ModifierParsing
	{
		public static void CreateModifier(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as a modifier. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "";
			CustomModifier customModifier = ParseModifier(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref customCampaignName);
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, customModifier.FinalCutsceneAudioPath, delegate(RichAudioClip clip)
			{
				customModifier.FinalCutsceneAudio.Data = clip;
				customModifier.FinalCutsceneAudio.HasChanged = true;
			}, jsonFolderPath, "final_cutscene_audio_name");
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, customModifier.TimedCallerStartSoundPath, delegate(RichAudioClip clip)
			{
				customModifier.TimedCallerStartSound.Data = clip;
				customModifier.TimedCallerStartSound.HasChanged = true;
			}, jsonFolderPath, "timed_caller_start_audio_name");
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, customModifier.TimedCallerHalfSoundPath, delegate(RichAudioClip clip)
			{
				customModifier.TimedCallerHalfSound.Data = clip;
				customModifier.TimedCallerHalfSound.HasChanged = true;
			}, jsonFolderPath, "timed_caller_half_point_audio_name");
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, customModifier.TimedCallerCriticalSoundPath, delegate(RichAudioClip clip)
			{
				customModifier.TimedCallerCriticalSound.Data = clip;
				customModifier.TimedCallerCriticalSound.HasChanged = true;
			}, jsonFolderPath, "timed_caller_critical_audio_name");
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, customModifier.ClockDayStartedAudioPath, delegate(RichAudioClip clip)
			{
				customModifier.ClockDayStartedAudio.Data = clip;
				customModifier.ClockDayStartedAudio.HasChanged = true;
			}, jsonFolderPath, "in_game_clock_start_audio_name");
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, customModifier.DayStartedAudioPath, delegate(RichAudioClip clip)
			{
				customModifier.DayStartedAudio.Data = clip;
				customModifier.DayStartedAudio.HasChanged = true;
			}, jsonFolderPath, "in_game_day_start_audio_name");
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, customModifier.InGameLogoFadeInAudioPath, delegate(RichAudioClip clip)
			{
				customModifier.InGameLogoFadeInAudio.Data = clip;
				customModifier.InGameLogoFadeInAudio.HasChanged = true;
			}, jsonFolderPath, "in_game_logo_fade_in_sound");
			CustomCampaign namedCustomCampaign = CustomCampaignGlobal.GetNamedCustomCampaign(customCampaignName);
			if (namedCustomCampaign != null)
			{
				if (customModifier.UnlockDays == null)
				{
					if (!customModifier.OnlyIfGameFinished)
					{
						namedCustomCampaign.ModifierSources[0].Modifiers.Add(customModifier);
					}
					else
					{
						namedCustomCampaign.ModifierSources[1].Modifiers.Add(customModifier);
					}
				}
				else if (!customModifier.OnlyIfGameFinished)
				{
					namedCustomCampaign.ModifierSources[2].Modifiers.Add(customModifier);
				}
				else
				{
					namedCustomCampaign.ModifierSources[3].Modifiers.Add(customModifier);
				}
			}
			else
			{
				LoggingHelper.DebugLog("Found modifier file before the custom campaign was found / does not exist.");
				GlobalParsingVariables.PendingCustomCampaignModifiers.Add(customModifier);
			}
		}

		private static CustomModifier ParseModifier(ref JObject jObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref string customCampaignName)
		{
			//IL_0544: Unknown result type (might be due to invalid IL or missing references)
			//IL_054a: Invalid comparison between Unknown and I4
			//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0606: Expected O, but got Unknown
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Invalid comparison between Unknown and I4
			//IL_071a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0720: Invalid comparison between Unknown and I4
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b53: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b5a: Expected O, but got Unknown
			//IL_0736: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fc: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = null;
			bool target = false;
			VariableChanged<string> target2 = new VariableChanged<string>
			{
				Data = string.Empty
			};
			VariableChanged<string> target3 = new VariableChanged<string>
			{
				Data = "NO_DATE_SET"
			};
			List<Sprite> list2 = new List<Sprite>();
			VariableChanged<Sprite> target4 = new VariableChanged<Sprite>();
			bool target5 = false;
			Color? desktopBackgroundColor = null;
			List<string> target6 = new List<string>();
			bool target7 = false;
			VariableChanged<bool> target8 = new VariableChanged<bool>
			{
				Data = true
			};
			VariableChanged<Sprite> target9 = new VariableChanged<Sprite>();
			VariableChanged<bool> target10 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<float> target11 = new VariableChanged<float>
			{
				Data = 0.2627f
			};
			VariableChanged<bool> target12 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<string> target13 = new VariableChanged<string>
			{
				Data = string.Empty
			};
			VariableChanged<Sprite> target14 = new VariableChanged<Sprite>();
			VariableChanged<Sprite> target15 = new VariableChanged<Sprite>();
			VariableChanged<Sprite> target16 = new VariableChanged<Sprite>();
			VariableChanged<string> target17 = new VariableChanged<string>();
			VariableChanged<string> target18 = new VariableChanged<string>();
			VariableChanged<bool> target19 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Sprite> target20 = new VariableChanged<Sprite>();
			VariableChanged<Sprite> target21 = new VariableChanged<Sprite>();
			VariableChanged<string> target22 = new VariableChanged<string>();
			VariableChanged<string> target23 = new VariableChanged<string>();
			VariableChanged<bool> target24 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Sprite> target25 = new VariableChanged<Sprite>();
			VariableChanged<Sprite> target26 = new VariableChanged<Sprite>();
			VariableChanged<string> target27 = new VariableChanged<string>();
			VariableChanged<string> target28 = new VariableChanged<string>();
			VariableChanged<Sprite> target29 = new VariableChanged<Sprite>();
			VariableChanged<Sprite> target30 = new VariableChanged<Sprite>();
			VariableChanged<string> target31 = new VariableChanged<string>();
			VariableChanged<string> target32 = new VariableChanged<string>();
			List<ArtbookPage> target33 = new List<ArtbookPage>();
			VariableChanged<bool> target34 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Sprite> target35 = new VariableChanged<Sprite>();
			VariableChanged<string> target36 = new VariableChanged<string>();
			VariableChanged<bool> target37 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Sprite> target38 = new VariableChanged<Sprite>();
			VariableChanged<Sprite> target39 = new VariableChanged<Sprite>();
			VariableChanged<string> target40 = new VariableChanged<string>();
			VariableChanged<string> target41 = new VariableChanged<string>();
			VariableChanged<bool> target42 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<string> target43 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<string> target44 = new VariableChanged<string>();
			VariableChanged<bool> target45 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Sprite> target46 = new VariableChanged<Sprite>();
			VariableChanged<bool> target47 = new VariableChanged<bool>
			{
				Data = false
			};
			List<string> list3 = new List<string>();
			VariableChanged<bool> target48 = new VariableChanged<bool>
			{
				Data = true
			};
			VariableChanged<bool> target49 = new VariableChanged<bool>
			{
				Data = true
			};
			VariableChanged<bool> target50 = new VariableChanged<bool>
			{
				Data = true
			};
			VariableChanged<bool> target51 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target52 = new VariableChanged<bool>
			{
				Data = true
			};
			VariableChanged<float> target53 = new VariableChanged<float>
			{
				Data = 3f
			};
			VariableChanged<float> target54 = new VariableChanged<float>
			{
				Data = 1f
			};
			VariableChanged<RichAudioClip> finalCutsceneAudio = new VariableChanged<RichAudioClip>
			{
				Data = null
			};
			VariableChanged<bool> target55 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target56 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target57 = new VariableChanged<bool>
			{
				Data = false
			};
			string target58 = null;
			VariableChanged<bool> target59 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target60 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<float> target61 = new VariableChanged<float>
			{
				Data = 1f
			};
			VariableChanged<float> target62 = new VariableChanged<float>
			{
				Data = 0.05f
			};
			VariableChanged<string> target63 = new VariableChanged<string>
			{
				Data = "TIMES UP!\nCALL DISCONNECTED"
			};
			VariableChanged<RichAudioClip> timedCallerStartSound = new VariableChanged<RichAudioClip>
			{
				Data = null
			};
			VariableChanged<string> target64 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<RichAudioClip> timedCallerHalfSound = new VariableChanged<RichAudioClip>
			{
				Data = null
			};
			VariableChanged<string> target65 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<RichAudioClip> timedCallerCriticalSound = new VariableChanged<RichAudioClip>
			{
				Data = null
			};
			VariableChanged<string> target66 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<Sprite> target67 = new VariableChanged<Sprite>
			{
				Data = null
			};
			VariableChanged<Sprite> target68 = new VariableChanged<Sprite>
			{
				Data = null
			};
			VariableChanged<float> target69 = new VariableChanged<float>
			{
				Data = 57.5f
			};
			VariableChanged<float> target70 = new VariableChanged<float>
			{
				Data = 1f
			};
			VariableChanged<float> target71 = new VariableChanged<float>
			{
				Data = 5f
			};
			VariableChanged<float> target72 = new VariableChanged<float>
			{
				Data = 5f
			};
			VariableChanged<Sprite> target73 = new VariableChanged<Sprite>
			{
				Data = null
			};
			VariableChanged<bool> target74 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<Sprite> target75 = new VariableChanged<Sprite>
			{
				Data = null
			};
			VariableChanged<bool> target76 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<string> target77 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<string> target78 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<string> target79 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<Sprite> target80 = new VariableChanged<Sprite>
			{
				Data = null
			};
			VariableChanged<RichAudioClip> clockDayStartedAudio = new VariableChanged<RichAudioClip>
			{
				Data = null
			};
			VariableChanged<string> target81 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<RichAudioClip> dayStartedAudio = new VariableChanged<RichAudioClip>
			{
				Data = null
			};
			VariableChanged<string> target82 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<RichAudioClip> inGameLogoFadeInAudio = new VariableChanged<RichAudioClip>
			{
				Data = null
			};
			VariableChanged<string> target83 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<List<Sprite>> target84 = new VariableChanged<List<Sprite>>
			{
				Data = new List<Sprite>()
			};
			VariableChanged<float> target85 = new VariableChanged<float>
			{
				Data = 1f
			};
			VariableChanged<float> target86 = new VariableChanged<float>
			{
				Data = 1.82f
			};
			VariableChanged<float> target87 = new VariableChanged<float>
			{
				Data = 1.42f
			};
			VariableChanged<string> target88 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<string> target89 = new VariableChanged<string>
			{
				Data = null
			};
			VariableChanged<Sprite> target90 = new VariableChanged<Sprite>
			{
				Data = null
			};
			VariableChanged<List<Sprite>> target91 = new VariableChanged<List<Sprite>>
			{
				Data = new List<Sprite>()
			};
			VariableChanged<float> target92 = new VariableChanged<float>
			{
				Data = 2.25f
			};
			VariableChanged<float> target93 = new VariableChanged<float>
			{
				Data = 1f
			};
			VariableChanged<bool> target94 = new VariableChanged<bool>();
			bool target95 = false;
			VariableChanged<bool> target96 = new VariableChanged<bool>
			{
				Data = false
			};
			VariableChanged<bool> target97 = new VariableChanged<bool>
			{
				Data = false
			};
			ParsingHelper.TryAssign(jObjectParsed, "modifier_custom_campaign_attached", ref customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "only_if_game_beaten", ref target);
			JToken val = default(JToken);
			if (jObjectParsed.TryGetValue("unlock_day", ref val))
			{
				if ((int)val.Type == 6)
				{
					list = new List<int> { Extensions.Value<int>((IEnumerable<JToken>)val) };
				}
				else if ((int)val.Type == 2)
				{
					list = new List<int>();
					foreach (JToken item in (JArray)val)
					{
						list.Add(Extensions.Value<int>((IEnumerable<JToken>)item));
					}
				}
			}
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "desktop_username_text", ref target2);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "date_label_custom_text", ref target3);
			JToken val2 = default(JToken);
			if (jObjectParsed.TryGetValue("desktop_backgrounds", ref val2))
			{
				JArray val3 = (JArray)val2;
				foreach (JToken item2 in val3)
				{
					if (string.IsNullOrEmpty(Extensions.Value<string>((IEnumerable<JToken>)item2)))
					{
						LoggingHelper.ErrorLog("Did not find '" + Extensions.Value<string>((IEnumerable<JToken>)item2) + "'. Adding no background.");
						list2.Add(null);
					}
					else
					{
						list2.Add(ImageImport.LoadImage(jsonFolderPath + "\\" + Extensions.Value<string>((IEnumerable<JToken>)item2), usermodFolderPath + "\\" + Extensions.Value<string>((IEnumerable<JToken>)item2)));
					}
				}
			}
			VideoParsingHelper.TryAssignUrlListOrSingleUrl(jObjectParsed, "animated_desktop_backgrounds", ref target6, jsonFolderPath, usermodFolderPath);
			ParsingHelper.TryAssign(jObjectParsed, "remove_background_with_animated_background", ref target7);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "animated_desktop_background_should_loop", ref target8);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "game_finished_desktop_background", ref target4, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "disable_green_color_on_desktop", ref target5);
			JToken val4 = default(JToken);
			if (jObjectParsed.TryGetValue("desktop_background_color", ref val4) && (int)val4.Type == 2)
			{
				List<float> list4 = new List<float>();
				foreach (JToken item3 in (JArray)val4)
				{
					list4.Add(Extensions.Value<float>((IEnumerable<JToken>)item3));
				}
				switch (list4.Count)
				{
				case 3:
					desktopBackgroundColor = new Color(ColorHelper.GetConvertedColorFloat(list4[0]), ColorHelper.GetConvertedColorFloat(list4[1]), ColorHelper.GetConvertedColorFloat(list4[2]));
					break;
				case 4:
					desktopBackgroundColor = new Color(ColorHelper.GetConvertedColorFloat(list4[0]), ColorHelper.GetConvertedColorFloat(list4[1]), ColorHelper.GetConvertedColorFloat(list4[2]), ColorHelper.GetConvertedColorFloat(list4[3]));
					break;
				default:
					LoggingHelper.ErrorLog("Provided color for desktop background is invalid! Make sure it's 3 or 4 values.");
					break;
				}
			}
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_logo_image_name", ref target9, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_desktop_logo", ref target10);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "desktop_logo_transparency", ref target11);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "video_player_desktop_wide_mode", ref target12);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "rename_main_game_desktop_icon", ref target13);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "main_game_desktop_icon_path", ref target14, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "show_mailbox_icon_on_desktop", ref target19);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_mailbox_image_name", ref target15, jsonFolderPath, usermodFolderPath, customCampaignName);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_mailbox_program_image_name", ref target16, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "rename_mailbox_program", ref target17);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "desktop_mailbox_program_title", ref target18);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, new List<string> { "entry_browser_state", "show_entry_browser_icon_on_desktop" }, ref target24);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_entry_browser_image_name", ref target20, jsonFolderPath, usermodFolderPath, customCampaignName);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_entry_browser_program_image_name", ref target21, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "rename_entry_browser_program", ref target22);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "desktop_entry_browser_program_title", ref target23);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_options_image_name", ref target25, jsonFolderPath, usermodFolderPath, customCampaignName);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_options_program_image_name", ref target26, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "rename_options_program", ref target27);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "desktop_options_program_title", ref target28);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, new List<string> { "artbook_state", "show_artbook_icon_on_desktop" }, ref target34);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_artbook_image_name", ref target29, jsonFolderPath, usermodFolderPath, customCampaignName);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_artbook_program_image_name", ref target30, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "desktop_artbook_program_title", ref target32);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "rename_artbook_program", ref target31);
			ArtbookParsingHelper.ParseArtbookPages(jObjectParsed, ref target33, jsonFolderPath, usermodFolderPath);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, new List<string> { "arcade_state", "show_arcade_icon_on_desktop" }, ref target37);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "rename_arcade_program", ref target36);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_arcade_image_name", ref target35, jsonFolderPath, usermodFolderPath, customCampaignName);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_scorecard_image_name", ref target38, jsonFolderPath, usermodFolderPath, customCampaignName);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_scorecard_program_image_name", ref target39, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "rename_scorecard_program", ref target40);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "desktop_scorecard_program_title", ref target41);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, new List<string> { "scorecard_state", "show_scorecard_icon_on_desktop" }, ref target42);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "desktop_credits", ref target43);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "hide_desktop_credits", ref target45);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "rename_credits_program", ref target44);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "desktop_credits_image_name", ref target46, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "hide_discord_program", ref target47);
			JToken val5 = default(JToken);
			if (jObjectParsed.TryGetValue("campaign_day_names", ref val5))
			{
				JArray val6 = (JArray)val5;
				foreach (JToken item4 in val6)
				{
					list3.Add(Extensions.Value<string>((IEnumerable<JToken>)item4));
				}
			}
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "final_cutscene_fade_to_black", ref target48);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "final_cutscene_shake", ref target49);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "final_cutscene_glitch_sounds", ref target50);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "final_cutscene_prevent_clicks", ref target51);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "final_cutscene_fade_to_black_duration", ref target53);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "final_cutscene_extra_fade_to_black_duration", ref target54);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "final_cutscene_stop_audio_after_fade", ref target52);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "final_cutscene_return_to_computer_start_menu", ref target55);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "final_cutscene_stay_in_custom_campaign", ref target56);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "final_cutscene_disable_skipping", ref target57);
			AudioParsingHelper.TryAssignAudioPath(jObjectParsed, "final_cutscene_audio_name", ref target58, jsonFolderPath, usermodFolderPath);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "disable_phone_static", ref target59);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "use_clock_instead_of_timer", ref target60);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "caller_digital_clock_tick_rate", ref target61);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "caller_analog_clock_tick_rate", ref target62);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "timed_caller_disconnect_message", ref target63);
			AudioParsingHelper.TryAssignAudioPathWithChangedBool(jObjectParsed, "timed_caller_start_audio_name", ref target64, jsonFolderPath, usermodFolderPath);
			AudioParsingHelper.TryAssignAudioPathWithChangedBool(jObjectParsed, "timed_caller_half_point_audio_name", ref target65, jsonFolderPath, usermodFolderPath);
			AudioParsingHelper.TryAssignAudioPathWithChangedBool(jObjectParsed, "timed_caller_critical_audio_name", ref target66, jsonFolderPath, usermodFolderPath);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "timed_caller_base_clock_image_name", ref target67, jsonFolderPath, usermodFolderPath, customCampaignName);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "timed_caller_clock_hand_image_name", ref target68, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "timed_caller_profile_clock_size", ref target69);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "timed_caller_profile_clock_size_multiplier", ref target70);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "timed_caller_profile_clock_vertical_spacing", ref target72);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "timed_caller_profile_clock_horizontal_spacing", ref target71);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "in_game_program_icon", ref target73, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "in_game_program_icon_center", ref target74);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "in_game_phone_call_icon", ref target75, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "in_game_phone_call_icon_center", ref target76);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "incoming_call_title", ref target77);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "incoming_call_label_text", ref target78);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "incoming_call_answer_button_text", ref target79);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "incoming_call_answer_button_image", ref target80, jsonFolderPath, usermodFolderPath, customCampaignName);
			AudioParsingHelper.TryAssignAudioPathWithChangedBool(jObjectParsed, "in_game_clock_start_audio_name", ref target81, jsonFolderPath, usermodFolderPath);
			AudioParsingHelper.TryAssignAudioPathWithChangedBool(jObjectParsed, "in_game_day_start_audio_name", ref target82, jsonFolderPath, usermodFolderPath);
			AudioParsingHelper.TryAssignAudioPathWithChangedBool(jObjectParsed, "in_game_logo_fade_in_sound", ref target83, jsonFolderPath, usermodFolderPath);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "in_game_clock_in_logo_fade_duration", ref target86);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "in_game_clock_in_logo_hold_duration", ref target87);
			ImageParsingHelper.TryAssignSpriteListOrSingleSpriteVariableChanged(jObjectParsed, "in_game_clock_in_logo_animation", ref target84, jsonFolderPath, usermodFolderPath);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "in_game_clock_in_logo_scale", ref target85);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "submit_window_title", ref target88);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "submit_window_text", ref target89);
			ImageParsingHelper.TryAssignSpriteChanged(jObjectParsed, "submit_window_icon", ref target90, jsonFolderPath, usermodFolderPath, customCampaignName);
			ImageParsingHelper.TryAssignSpriteListOrSingleSpriteVariableChanged(jObjectParsed, "in_game_clock_in_animation", ref target91, jsonFolderPath, usermodFolderPath);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "in_game_clock_in_animation_duration", ref target92);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "in_game_clock_in_animation_scale", ref target93);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "show_accuracy_display", ref target94);
			ParsingHelper.TryAssign(jObjectParsed, "skip_desktop_loading", ref target95);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "submit_window_default_show_last_selected", ref target96);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "submit_window_show_current_selected", ref target97);
			return new CustomModifier
			{
				CustomCampaignName = customCampaignName,
				UnlockDays = list,
				OnlyIfGameFinished = target,
				UsernameText = target2,
				DateLabelOverwritten = target3,
				DesktopBackgrounds = list2,
				GameFinishedBackground = target4,
				AnimatedDesktopBackgrounds = target6,
				BlackBackgroundOnAnimatedBackground = target7,
				AnimatedDesktopBackgroundShouldLoop = target8,
				DisableColorBackground = target5,
				DesktopBackgroundColor = desktopBackgroundColor,
				CustomBackgroundLogo = target9,
				DisableDesktopLogo = target10,
				BackgroundLogoTransparency = target11,
				VideoPlayerDesktopIsWideMode = target12,
				RenameMainGameDesktopIcon = target13,
				MainGameDesktopIcon = target14,
				MailboxIcon = target15,
				MailboxRename = target17,
				ApplicationMailboxTitle = target18,
				ApplicationMailboxIcon = target16,
				DisplayMailboxOnDesktop = target19,
				EntryBrowserIcon = target20,
				EntryBrowserRename = target22,
				ApplicationEntryBrowserTitle = target23,
				ApplicationEntryBrowserIcon = target21,
				DisplayEntryBrowserOnDesktop = target24,
				OptionsIcon = target25,
				OptionsRename = target27,
				ApplicationOptionsTitle = target28,
				ApplicationOptionsIcon = target26,
				ArtbookIcon = target29,
				ArtbookRename = target31,
				ArtbookPages = target33,
				ApplicationArtbookTitle = target32,
				ApplicationArtbookIcon = target30,
				DisplayArtbookOnDesktop = target34,
				ArcadeIcon = target35,
				ArcadeRename = target36,
				DisplayArcadeOnDesktop = target37,
				ScorecardIcon = target38,
				ScorecardRename = target40,
				ApplicationScorecardTitle = target41,
				ApplicationScorecardIcon = target39,
				DisplayScorecardOnDesktop = target42,
				DesktopCredits = target43,
				CreditsRename = target44,
				CreditsIcon = target46,
				HideDesktopCredits = target45,
				HideDiscordProgram = target47,
				DayTitleStrings = list3,
				FinalCutsceneFadeToBlack = target48,
				FinalCutsceneShake = target49,
				FinalCutsceneGlitchSounds = target50,
				FinalCutscenePreventClicks = target51,
				FinalCutsceneFadeDuration = target53,
				FinalCutsceneFadePaddingDuration = target54,
				FinalCutsceneAudioPath = target58,
				FinalCutsceneAudio = finalCutsceneAudio,
				FinalCutsceneStopAudioAfterFade = target52,
				FinalCutsceneReturnTo3DScreen = target55,
				FinalCutsceneStayInCustomCampaign = target56,
				FinalCutsceneDisableSkippingKeys = target57,
				DisablePhoneStatic = target59,
				UseClockInsteadOfTimer = target60,
				DigitalClockTickRate = target61,
				AnalogClockTickRate = target62,
				TimedCallerDisconnectedMessage = target63,
				TimedCallerStartSound = timedCallerStartSound,
				TimedCallerStartSoundPath = target64,
				TimedCallerHalfSound = timedCallerHalfSound,
				TimedCallerHalfSoundPath = target65,
				TimedCallerCriticalSound = timedCallerCriticalSound,
				TimedCallerCriticalSoundPath = target66,
				TimedCallerBaseClock = target67,
				TimedCallerClockHand = target68,
				TimedCallerProfileClockSize = target69,
				TimedCallerProfileClockSizeMultiplier = target70,
				TimedCallerProfileClockPadX = target71,
				TimedCallerProfileClockPadY = target72,
				InGameProgramIcon = target73,
				InGameProgramIconCenter = target74,
				InGamePhoneIcon = target75,
				InGamePhoneIconCenter = target76,
				ClockInLogoAnimation = target84,
				ClockInLogoAnimationScale = target85,
				ClockInLogoAnimationFadeDuration = target86,
				ClockInLogoAnimationHoldDuration = target87,
				IncomingCallTitle = target77,
				IncomingCallLabel = target78,
				IncomingCallAnswerButtonText = target79,
				IncomingCallAnswerButtonImage = target80,
				SubmitWindowTitle = target88,
				SubmitWindowText = target89,
				SubmitWindowIcon = target90,
				ClockInAnimation = target91,
				ClockInAnimationDuration = target92,
				ClockInAnimationScale = target93,
				DayStartedAudio = dayStartedAudio,
				DayStartedAudioPath = target82,
				ClockDayStartedAudio = clockDayStartedAudio,
				ClockDayStartedAudioPath = target81,
				InGameLogoFadeInAudio = inGameLogoFadeInAudio,
				InGameLogoFadeInAudioPath = target83,
				ShowDefaultUIAccuracyText = target94,
				DisableDesktopLoading = target95,
				SelectPreviouslySelectedEntryInSubmitWindow = target96,
				SelectCurrentlyMainViewSelectedEntryInSubmitWindow = target97
			};
		}
	}
	public static class RingtoneParsing
	{
		public static void CreateRingtone(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as ringtone. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "";
			CustomRingtone customRingtone = ParseRingtone(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref customCampaignName);
			AudioParsingHelper.UpdateAudioAtLocation(jObjectParsed, customRingtone.RingtoneClipPath, delegate(RichAudioClip clip)
			{
				customRingtone.RingtoneClip = clip;
			}, jsonFolderPath, "ringtone_audio_clip_name");
			CustomCampaign namedCustomCampaign = CustomCampaignGlobal.GetNamedCustomCampaign(customCampaignName);
			if (namedCustomCampaign != null)
			{
				namedCustomCampaign.CustomRingtones.Add(customRingtone);
				return;
			}
			LoggingHelper.DebugLog("Found ringtone file before the custom campaign was found / does not exist.");
			GlobalParsingVariables.PendingCustomCampaignRingtones.Add(customRingtone);
		}

		private static CustomRingtone ParseRingtone(ref JObject jObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref string customCampaignName)
		{
			int target = 0;
			bool target2 = true;
			string target3 = "";
			bool target4 = false;
			bool target5 = false;
			float target6 = 1f;
			ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_attached", ref customCampaignName);
			AudioParsingHelper.TryAssignAudioPath(jObjectParsed, "ringtone_audio_clip_name", ref target3, jsonFolderPath, usermodFolderPath, customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "unlock_day", ref target);
			if (target <= 0)
			{
				target2 = false;
			}
			ParsingHelper.TryAssign(jObjectParsed, "only_play_on_unlock_day", ref target2);
			ParsingHelper.TryAssign(jObjectParsed, "is_glitched_version", ref target4);
			ParsingHelper.TryAssign(jObjectParsed, "is_append_ringtone", ref target5);
			if (target5)
			{
				ParsingHelper.TryAssign(jObjectParsed, "ringtone_chance", ref target6);
			}
			return new CustomRingtone
			{
				CustomCampaignName = customCampaignName,
				RingtoneClipPath = target3,
				UnlockDay = target,
				OnlyOnUnlockDay = target2,
				IsGlitchedVersion = target4,
				AppendRingtone = target5,
				PlayChance = target6
			};
		}
	}
	public static class TextProgramParsing
	{
		public static void CreateTextProgram(JObject jObjectParsed, string usermodFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as a video. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "";
			CustomTextFile item = ParseTextFileProgram(ref jObjectParsed, ref customCampaignName);
			CustomCampaign customCampaign = CustomCampaignGlobal.CustomCampaignsAvailable.Find((CustomCampaign customCampaignSearch) => customCampaignSearch.CampaignName == customCampaignName);
			if (customCampaign != null)
			{
				customCampaign.CustomTextProgramFiles.Add(item);
				return;
			}
			LoggingHelper.DebugLog("Found Text file program before the custom campaign was found / does not exist.");
			GlobalParsingVariables.PendingCustomCampaignTextFile.Add(item);
		}

		private static CustomTextFile ParseTextFileProgram(ref JObject jObjectParsed, ref string customCampaignName)
		{
			string target = "file.txt";
			string target2 = "Empty";
			int target3 = 0;
			int target4 = 0;
			VariableChanged<int> target5 = new VariableChanged<int>
			{
				Data = 0
			};
			bool isUsingOldSystem = false;
			List<GeneralAccuracyType> target6 = null;
			List<CallerRequirement> target7 = null;
			bool target8 = false;
			ParsingHelper.TryAssign(jObjectParsed, "text_file_desktop_name", ref target);
			ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_attached", ref customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "text_file_unlock_day", ref target3);
			ParsingHelper.TryAssign(jObjectParsed, "text_file_order_priority", ref target4);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "text_file_desktop_position", ref target5);
			ParsingHelper.TryAssign(jObjectParsed, "text_file_contents", ref target2);
			AccuracyParsingHelper.TryAssignListGeneralAccuracyType(jObjectParsed, ref target6, ref isUsingOldSystem, "text_file_required_accuracy", "text_file_accuracy_days", "text_file_accuracy_check_type");
			CallerRequirementParsingHelper.TryAssignCallerRequirement(jObjectParsed, ref target7, "text_file_caller_requirement_ids", "text_file_caller_requirement_should_be_correct");
			ParsingHelper.TryAssign(jObjectParsed, "text_file_unlock_when_game_finished", ref target8);
			return new CustomTextFile
			{
				FileNameOnDesktop = target,
				CustomCampaignName = customCampaignName,
				TextFileContents = target2,
				UnlockDay = target3,
				OrderPriority = target4,
				GameObjectOrder = target5,
				UnlockAccuracy = target6,
				UnlockRequiredCallers = target7,
				UnlockWhenGameFinished = target8
			};
		}
	}
	public static class ThemeParsing
	{
		public static void CreateTheme(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as a theme. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "";
			CustomTheme customTheme = ParseTheme(ref jObjectParsed, ref customCampaignName);
			CustomCampaign customCampaign = CustomCampaignGlobal.CustomCampaignsAvailable.Find((CustomCampaign customCampaignSearch) => customCampaignSearch.CampaignName == customCampaignName);
			if (customTheme.InMainCampaign)
			{
				GlobalParsingVariables.MainGameThemes.Add(customTheme);
			}
			else if (customCampaign != null)
			{
				if (customTheme.UnlockDays == null)
				{
					customCampaign.CustomThemesGeneral.Add(customTheme);
				}
				else
				{
					customCampaign.CustomThemesDays.Add(customTheme);
				}
			}
			else
			{
				LoggingHelper.DebugLog("Found theme file before the custom campaign was found / does not exist.");
				GlobalParsingVariables.PendingCustomCampaignThemes.Add(customTheme);
			}
		}

		private static CustomTheme ParseTheme(ref JObject jObjectParsed, ref string customCampaignName)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Invalid comparison between Unknown and I4
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Invalid comparison between Unknown and I4
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			bool inMainCampaign = false;
			string target = "NO THEME NAME SET";
			string target2 = null;
			List<int> list = null;
			ColorPalette themeColorPalette = ScriptableObject.CreateInstance<ColorPalette>();
			themeColorPalette.colorSwatch = (Color[])(object)new Color[4];
			for (int i = 0; i < themeColorPalette.colorSwatch.Length; i++)
			{
				themeColorPalette.colorSwatch[i] = new Color(1f, 0.2178f, 0.2745f, 1f);
			}
			JToken val = default(JToken);
			JToken val2 = default(JToken);
			if (jObjectParsed.TryGetValue("theme_custom_campaign_attached", ref val))
			{
				customCampaignName = Extensions.Value<string>((IEnumerable<JToken>)val);
			}
			else if (jObjectParsed.TryGetValue("theme_in_main_campaign", ref val2))
			{
				inMainCampaign = Extensions.Value<bool>((IEnumerable<JToken>)val2);
			}
			ParsingHelper.TryAssign(jObjectParsed, "theme_name", ref target);
			ParsingHelper.TryAssign(jObjectParsed, "attached_to_theme", ref target2);
			JToken val3 = default(JToken);
			if (jObjectParsed.TryGetValue("unlock_day", ref val3))
			{
				if ((int)val3.Type == 6)
				{
					list = new List<int> { Extensions.Value<int>((IEnumerable<JToken>)val3) };
				}
				else if ((int)val3.Type == 2)
				{
					list = new List<int>();
					foreach (JToken item in (JArray)val3)
					{
						list.Add(Extensions.Value<int>((IEnumerable<JToken>)item));
					}
				}
			}
			JToken jsonValue = default(JToken);
			if (jObjectParsed.TryGetValue("title_bar_color", ref jsonValue))
			{
				ColorParsingHelper.SetColor(ref jsonValue, ref themeColorPalette, 0);
			}
			JToken jsonValue2 = default(JToken);
			if (jObjectParsed.TryGetValue("menu_color", ref jsonValue2))
			{
				ColorParsingHelper.SetColor(ref jsonValue2, ref themeColorPalette, 1);
			}
			JToken jsonValue3 = default(JToken);
			if (jObjectParsed.TryGetValue("third_color", ref jsonValue3))
			{
				ColorParsingHelper.SetColor(ref jsonValue3, ref themeColorPalette, 2);
			}
			JToken jsonValue4 = default(JToken);
			if (jObjectParsed.TryGetValue("entry_font_color", ref jsonValue4))
			{
				ColorParsingHelper.SetColor(ref jsonValue4, ref themeColorPalette, 2);
			}
			JToken jsonValue5 = default(JToken);
			if (jObjectParsed.TryGetValue("main_window_color", ref jsonValue5))
			{
				ColorParsingHelper.SetColor(ref jsonValue5, ref themeColorPalette, 3);
			}
			return new CustomTheme
			{
				InMainCampaign = inMainCampaign,
				ThemeName = target,
				CustomCampaignName = customCampaignName,
				AttachedToTheme = target2,
				UnlockDays = list,
				CustomThemePalette = themeColorPalette
			};
		}
	}
	public static class VideoParsing
	{
		public static void CreateVideo(JObject jObjectParsed, string usermodFolderPath = "", string jsonFolderPath = "")
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (jObjectParsed == null || (int)((JToken)jObjectParsed).Type != 1 || string.IsNullOrEmpty(usermodFolderPath))
			{
				LoggingHelper.ErrorLog("Provided JSON could not be parsed as a video. Possible syntax mistake?");
				return;
			}
			string customCampaignName = "";
			CustomVideo item = ParseVideo(ref jObjectParsed, ref usermodFolderPath, ref jsonFolderPath, ref customCampaignName);
			CustomCampaign customCampaign = CustomCampaignGlobal.CustomCampaignsAvailable.Find((CustomCampaign customCampaignSearch) => customCampaignSearch.CampaignName == customCampaignName);
			if (customCampaign != null)
			{
				customCampaign.CustomVideos.Add(item);
				return;
			}
			LoggingHelper.DebugLog("Found Video before the custom campaign was found / does not exist.");
			GlobalParsingVariables.PendingCustomCampaignVideos.Add(item);
		}

		private static CustomVideo ParseVideo(ref JObject jObjectParsed, ref string usermodFolderPath, ref string jsonFolderPath, ref string customCampaignName)
		{
			string target = "";
			string target2 = "";
			int target3 = 0;
			int target4 = 0;
			VariableChanged<int> target5 = new VariableChanged<int>
			{
				Data = 0
			};
			List<GeneralAccuracyType> target6 = null;
			bool isUsingOldSystem = true;
			List<CallerRequirement> target7 = null;
			bool target8 = false;
			ParsingHelper.TryAssign(jObjectParsed, "video_desktop_name", ref target);
			ParsingHelper.TryAssign(jObjectParsed, "custom_campaign_attached", ref customCampaignName);
			ParsingHelper.TryAssign(jObjectParsed, "video_unlock_day", ref target3);
			ParsingHelper.TryAssign(jObjectParsed, "video_order_priority", ref target4);
			ParsingHelper.TryAssignWithChangedBool(jObjectParsed, "video_desktop_position", ref target5);
			VideoParsingHelper.TryAssignVideoPath(jObjectParsed, "video_file_name", ref target2, jsonFolderPath, usermodFolderPath);
			AccuracyParsingHelper.TryAssignListGeneralAccuracyType(jObjectParsed, ref target6, ref isUsingOldSystem, "video_required_accuracy", "video_accuracy_days", "video_accuracy_check_type");
			CallerRequirementParsingHelper.TryAssignCallerRequirement(jObjectParsed, ref target7, "video_caller_requirement_ids", "video_caller_requirement_should_be_correct");
			ParsingHelper.TryAssign(jObjectParsed, "video_ignore_accuracy_checks", ref isUsingOldSystem);
			ParsingHelper.TryAssign(jObjectParsed, "video_unlock_when_game_finished", ref target8);
			return new CustomVideo
			{
				DesktopName = target,
				CustomCampaignName = customCampaignName,
				VideoURL = target2,
				UnlockDay = target3,
				OrderPriority = target4,
				GameObjectOrder = target5,
				IgnoreAccuracyChecks = isUsingOldSystem,
				UnlockAccuracy = target6,
				UnlockRequiredCallers = target7,
				UnlockWhenGameFinished = target8
			};
		}
	}
}
namespace NewSafetyHelp.InGameSettings
{
	public static class GlobalPreferences
	{
		public static MelonPreferences_Category PersistantEntrySave;

		private static MelonPreferences_Category mainModSettings;

		public static MelonPreferences_Entry<bool> Vsync;

		public static MelonPreferences_Entry<bool> SkipComputerScene;

		public static MelonPreferences_Entry<bool> SkipLoadingScreen;

		public static MelonPreferences_Entry<bool> SkipDayClockIn;

		public static MelonPreferences_Entry<bool> ShowDebugLogs;

		public static MelonPreferences_Entry<bool> ShowSkippedCallerDebugLog;

		public static MelonPreferences_Entry<bool> ShowThemeDebugLog;

		public static MelonPreferences_Entry<bool> ShowRingtoneDebugLog;

		public static MelonPreferences_Entry<bool> ShowEmailDebugLog;

		public static MelonPreferences_Entry<bool> ShowVideoDebugLog;

		public static MelonPreferences_Entry<bool> ShowEntryDebugLog;

		public static MelonPreferences_Entry<bool> ShowTextFileDebugLog;

		public static MelonPreferences_Entry<bool> ShowCutsceneLog;

		public static MelonPreferences_Entry<bool> ShowMemoryLog;

		public static MelonPreferences_Entry<bool> ShowLinkAppLog;

		public static void InitializeMelonPreferences()
		{
			PersistantEntrySave = MelonPreferences.CreateCategory("EntryAlreadyCalled");
			mainModSettings = MelonPreferences.CreateCategory("MainModSettings");
			Vsync = mainModSettings.CreateEntry<bool>("Vsync", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			SkipComputerScene = mainModSettings.CreateEntry<bool>("SkipComputerScene", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			SkipLoadingScreen = mainModSettings.CreateEntry<bool>("SkipLoadingScreen", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			SkipDayClockIn = mainModSettings.CreateEntry<bool>("SkipDayClockIn", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowDebugLogs = mainModSettings.CreateEntry<bool>("ShowDebugLogs", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowSkippedCallerDebugLog = mainModSettings.CreateEntry<bool>("ShowSkippedCallerDebugLog", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowThemeDebugLog = mainModSettings.CreateEntry<bool>("ShowThemeDebugLog", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowRingtoneDebugLog = mainModSettings.CreateEntry<bool>("ShowRingtoneDebugLog", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowEmailDebugLog = mainModSettings.CreateEntry<bool>("ShowEmailDebugLog", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowVideoDebugLog = mainModSettings.CreateEntry<bool>("ShowVideoDebugLog", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowEntryDebugLog = mainModSettings.CreateEntry<bool>("ShowEntryDebugLog", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowTextFileDebugLog = mainModSettings.CreateEntry<bool>("ShowTextFileDebugLog", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowCutsceneLog = mainModSettings.CreateEntry<bool>("ShowCutsceneLog", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowMemoryLog = mainModSettings.CreateEntry<bool>("ShowMemoryLog", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ShowLinkAppLog = mainModSettings.CreateEntry<bool>("ShowLinkAppLog", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		}
	}
	public static class InGameSettingHelper
	{
		public static GameObject GetVideoOptionsSection()
		{
			GameObject contentSettings = GetContentSettings();
			if ((Object)(object)contentSettings != (Object)null)
			{
				return ((Component)contentSettings.transform.Find("VideoOptions")).gameObject;
			}
			return null;
		}

		private static GameObject GetPhobiasTogglesSection()
		{
			GameObject contentSettings = GetContentSettings();
			if ((Object)(object)contentSettings != (Object)null)
			{
				GameObject gameObject = ((Component)contentSettings.transform.Find("PhobiaToggles")).gameObject;
				if ((Object)(object)gameObject != (Object)null)
				{
					return gameObject;
				}
			}
			return null;
		}

		private static GameObject GetOptionsPopup()
		{
			return ((Component)GameObject.Find("MainMenuCanvas").transform.Find("OptionsPopup")).gameObject;
		}

		private static GameObject GetCloseButton()
		{
			return ((Component)GetOptionsPopup().transform.Find("WindowsBar").Find("CloseButton")).gameObject;
		}

		private static GameObject GetContentSettings()
		{
			return ((Component)GetOptionsPopup().transform.Find("OptionsScrollRect").Find("Viewport").Find("Content")).gameObject;
		}

		public static GameObject CreateNewToggle(GameObject parentGameObject, Func<bool, bool> eventOnLabelChange, string newToggleName = "New Toggle Name", bool startingState = false)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			GameObject phobiasTogglesSection = GetPhobiasTogglesSection();
			if ((Object)(object)phobiasTogglesSection != (Object)null)
			{
				GameObject gameObject = ((Component)phobiasTogglesSection.transform.Find("SpiderToggle")).gameObject;
				GameObject val = Object.Instantiate<GameObject>(gameObject, parentGameObject.transform);
				((Object)val).name = newToggleName;
				((TMP_Text)((Component)val.transform.Find("Label")).GetComponent<TextMeshProUGUI>()).text = newToggleName;
				Toggle component = val.GetComponent<Toggle>();
				((UnityEventBase)component.onValueChanged).RemoveAllListeners();
				component.onValueChanged = new ToggleEvent();
				component.isOn = startingState;
				((UnityEvent<bool>)(object)component.onValueChanged).AddListener((UnityAction<bool>)delegate(bool inputBool)
				{
					eventOnLabelChange(inputBool);
				});
				return val;
			}
			return null;
		}

		public static GameObject CreateButton(GameObject parentGameObject, Func<GameObject, GameObject> eventOnClick, string newButtonName = "New Toggle Name", string newButtonDescription = "New Toggle Description")
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			GameObject closeButton = GetCloseButton();
			if ((Object)(object)closeButton != (Object)null)
			{
				GameObject newButton = Object.Instantiate<GameObject>(closeButton, parentGameObject.transform);
				((Object)newButton).name = newButtonName;
				((TMP_Text)((Component)newButton.transform.Find("Text (TMP)")).GetComponent<TextMeshProUGUI>()).text = newButtonDescription;
				Button component = newButton.GetComponent<Button>();
				((UnityEventBase)component.onClick).RemoveAllListeners();
				component.onClick = new ButtonClickedEvent();
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					eventOnClick(newButton);
				});
				return newButton;
			}
			return null;
		}

		public static GameObject CreateNewSettingsSection(string newSectionName = "New Settings Section", string newSectionDescription = "New Settings Section Description")
		{
			GameObject phobiasTogglesSection = GetPhobiasTogglesSection();
			if ((Object)(object)phobiasTogglesSection != (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(phobiasTogglesSection, phobiasTogglesSection.transform.parent);
				((Object)val).name = newSectionName;
				((Component)val.transform.Find("Banner (2)")).gameObject.SetActive(false);
				GameObject gameObject = ((Component)val.transform.Find("Header")).gameObject;
				gameObject.SetActive(true);
				((TMP_Text)gameObject.GetComponent<TextMeshProUGUI>()).text = newSectionName;
				GameObject gameObject2 = ((Component)val.transform.Find("Description")).gameObject;
				((TMP_Text)gameObject2.GetComponent<TextMeshProUGUI>()).text = newSectionDescription;
				((Component)val.transform.Find("SpiderToggle")).gameObject.SetActive(false);
				((Component)val.transform.Find("InsectToggle")).gameObject.SetActive(false);
				((Component)val.transform.Find("DarkToggle")).gameObject.SetActive(false);
				((Component)val.transform.Find("HoleToggle")).gameObject.SetActive(false);
				((Component)val.transform.Find("WatchedToggle")).gameObject.SetActive(false);
				((Component)val.transform.Find("TightSpaceToggle")).gameObject.SetActive(false);
				((Component)val.transform.Find("DogToggle")).gameObject.SetActive(false);
				return val;
			}
			return null;
		}
	}
	public static class ToggleButtonFunctions
	{
		public static bool OnDebugLogToggle(bool toggleValue)
		{
			GlobalPreferences.ShowDebugLogs.Value = toggleValue;
			LoggingHelper.InfoLog($"Debug Log Toggle changed to '{toggleValue}'.");
			return toggleValue;
		}

		public static bool OnSkipComputerSceneToggle(bool toggleValue)
		{
			GlobalPreferences.SkipComputerScene.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnShowSkippedCallerLogToggle(bool toggleValue)
		{
			GlobalPreferences.ShowSkippedCallerDebugLog.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnThemeLogToggle(bool toggleValue)
		{
			GlobalPreferences.ShowThemeDebugLog.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnRingtoneLogToggle(bool toggleValue)
		{
			GlobalPreferences.ShowRingtoneDebugLog.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnEmailLogToggle(bool toggleValue)
		{
			GlobalPreferences.ShowEmailDebugLog.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnVideoLogToggle(bool toggleValue)
		{
			GlobalPreferences.ShowVideoDebugLog.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnSkipLoadingScreenToggle(bool toggleValue)
		{
			GlobalPreferences.SkipLoadingScreen.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnEntryLogToggle(bool toggleValue)
		{
			GlobalPreferences.ShowEntryDebugLog.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnTextFileLogToggle(bool toggleValue)
		{
			GlobalPreferences.ShowTextFileDebugLog.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnCutsceneLogToggle(bool toggleValue)
		{
			GlobalPreferences.ShowCutsceneLog.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnMemoryLogToggle(bool toggleValue)
		{
			GlobalPreferences.ShowMemoryLog.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnLinkApp(bool toggleValue)
		{
			GlobalPreferences.ShowLinkAppLog.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnSkipDayClockInToggle(bool toggleValue)
		{
			GlobalPreferences.SkipDayClockIn.Value = toggleValue;
			return toggleValue;
		}

		public static bool OnVsyncToggle(bool toggleValue)
		{
			GlobalPreferences.Vsync.Value = toggleValue;
			if (GlobalPreferences.Vsync.Value)
			{
				QualitySettings.vSyncCount = 1;
			}
			else
			{
				QualitySettings.vSyncCount = 0;
			}
			return toggleValue;
		}
	}
}
namespace NewSafetyHelp.ImportFiles
{
	public static class FileImporter
	{
		public static string GetUserDataFolderPath()
		{
			string text = Path.Combine(MelonEnvironment.UserDataDirectory, "NewSafetyHelp");
			if (!Directory.Exists(text))
			{
				LoggingHelper.InfoLog("No UserData/NewSafetyHelp folder found, creating the directory.");
				Directory.CreateDirectory(text);
			}
			return text;
		}
	}
	public static class ImageImport
	{
		[CanBeNull]
		public static Sprite LoadImage(string imagePath)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (!File.Exists(imagePath))
			{
				LoggingHelper.ErrorLog("Image file not found at path: '" + imagePath + "'.");
				return null;
			}
			byte[] array = File.ReadAllBytes(imagePath);
			Texture2D val = new Texture2D(2, 2);
			if (!ImageConversion.LoadImage(val, array))
			{
				Object.Destroy((Object)(object)val);
				LoggingHelper.ErrorLog("Failed to load image '" + imagePath + "' data into texture.");
				return null;
			}
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
		}

		[CanBeNull]
		public static Sprite LoadEmbeddedImage(string imageName)
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			imageName = imageName.Trim();
			if (string.IsNullOrEmpty(imageName))
			{
				LoggingHelper.ErrorLog("Empty embedded image provided. Unable of loading embedded image.");
				return null;
			}
			LoggingHelper.InfoLog("Attempting to load embedded image '" + imageName + "'.");
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string fileName = imageName;
			imageName = executingAssembly.GetManifestResourceNames().SingleOrDefault((string str) => str.EndsWith(fileName, StringComparison.Ordinal));
			if (string.IsNullOrEmpty(imageName))
			{
				LoggingHelper.ErrorLog("Could not find embedded resource '" + fileName + "'. Unable of loading the provided embedded resource.");
				return null;
			}
			using Stream stream = executingAssembly.GetManifestResourceStream(imageName);
			if (stream == null)
			{
				LoggingHelper.ErrorLog("Could not find embedded resource '" + fileName + "'. Unable of loading the provided embedded resource.");
				return null;
			}
			using BinaryReader binaryReader = new BinaryReader(stream);
			byte[] array = binaryReader.ReadBytes((int)stream.Length);
			Texture2D val = new Texture2D(2, 2);
			if (!ImageConversion.LoadImage(val, array))
			{
				Object.Destroy((Object)(object)val);
				LoggingHelper.ErrorLog("Failed to load image '" + imageName + "' data into texture.");
				return null;
			}
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
		}

		[CanBeNull]
		public static Sprite LoadImage(string imagePath, string fallbackImagePath)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (!File.Exists(imagePath) && !File.Exists(fallbackImagePath))
			{
				LoggingHelper.ErrorLog("Image file could not be found in either: '" + imagePath + "' or '" + fallbackImagePath + "'.");
				return null;
			}
			string text = imagePath;
			if (!File.Exists(imagePath))
			{
				text = fallbackImagePath;
			}
			byte[] array = File.ReadAllBytes(text);
			Texture2D val = new Texture2D(2, 2);
			if (!ImageConversion.LoadImage(val, array))
			{
				Object.Destroy((Object)(object)val);
				LoggingHelper.ErrorLog("Failed to load image '" + text + "' data into texture.");
				return null;
			}
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
		}
	}
}
namespace NewSafetyHelp.HelperFunctions
{
	public static class DebugHelper
	{
		public static void CallerOfFunction(string functionName = "NO_FUNCTION_NAME_PROVIDED", int functionDepth = 3, int plusDepth = 2)
		{
			StackTrace stackTrace = new StackTrace();
			LoggingHelper.DebugLog("-----", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Magenta);
			LoggingHelper.DebugLog("", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Magenta);
			for (int num = functionDepth + plusDepth; num >= 0; num--)
			{
				StackFrame frame = stackTrace.GetFrame(num);
				MethodBase method = frame.GetMethod();
				LoggingHelper.DebugLog($"{num}: '{functionName}' (FD: {functionDepth}) was called by: '{method.Name}'.", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Magenta);
			}
			LoggingHelper.DebugLog("-----", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Magenta);
		}

		public static void PrintClickLocationNames()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (!Input.GetMouseButtonDown(0))
			{
				return;
			}
			PointerEventData val = new PointerEventData(EventSystem.current)
			{
				position = Vector2.op_Implicit(Input.mousePosition)
			};
			List<RaycastResult> list = new List<RaycastResult>();
			EventSystem.current.RaycastAll(val, list);
			foreach (RaycastResult item in list)
			{
				RaycastResult result = item;
				LoggingHelper.DebugLog(() => $"Hit: {((Object)((RaycastResult)(ref result)).gameObject).name} | Depth: {result.depth} | Distance: {result.distance}");
			}
		}

		public static void CopyLatestLogs()
		{
			string text = Path.Combine(MelonEnvironment.MelonLoaderDirectory, "Latest.log");
			if (!File.Exists(text))
			{
				LoggingHelper.ErrorLog("Log file does not exist at '" + text + "'. Unable of copying log files!");
				return;
			}
			try
			{
				FileStream stream = new FileStream(text, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
				string text2;
				using (StreamReader streamReader = new StreamReader(stream))
				{
					text2 = streamReader.ReadToEnd();
				}
				if (!string.IsNullOrEmpty(text2))
				{
					GUIUtility.systemCopyBuffer = text2;
				}
			}
			catch (IOException arg)
			{
				LoggingHelper.ErrorLog("Unable of reading log file, possibly already opened? Please close any application that has the log files opened. " + $"For more details:\n'{arg}'.");
				return;
			}
			LoggingHelper.InfoLog("Copied log files to clipboard.", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Green);
		}
	}
	public static class EmbedHelpers
	{
		public const string NewSafetyHelpPrefix = "NewSafetyHelp_";

		[CanBeNull]
		public static string ExtractEmbeddedResourceToTempFile(string resourceName, bool findResource = true)
		{
			if (string.IsNullOrEmpty(resourceName))
			{
				LoggingHelper.ErrorLog("Provided resource name is null or empty. Unable of loading the provided embedded resource.");
				return null;
			}
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			if (findResource)
			{
				string fileName = resourceName;
				resourceName = executingAssembly.GetManifestResourceNames().SingleOrDefault((string str) => str.EndsWith(fileName, StringComparison.Ordinal));
				if (string.IsNullOrEmpty(resourceName))
				{
					LoggingHelper.ErrorLog("Could not find embedded resource '" + fileName + "'. Unable of loading the provided embedded resource.");
					return null;
				}
			}
			using Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
			if (stream == null)
			{
				LoggingHelper.ErrorLog("Could not find embedded resource '" + resourceName + "'. Unable of loading the provided embedded resource.");
				return null;
			}
			string extension = Path.GetExtension(resourceName);
			string text = Path.Combine(Path.GetTempPath(), string.Format("{0}{1}_{2}{3}", "NewSafetyHelp_", Path.GetFileNameWithoutExtension(resourceName), Guid.NewGuid(), extension));
			using (FileStream destination = File.Create(text))
			{
				stream.CopyTo(destination);
			}
			return text;
		}

		public static void DeleteTempFiles()
		{
			string tempPath = Path.GetTempPath();
			string[] files = Directory.GetFiles(tempPath, "NewSafetyHelp_*");
			if (files.Length == 0)
			{
				LoggingHelper.DebugLog("No temporary files found. Thus no deletion required.");
				return;
			}
			string[] array = files;
			foreach (string text in array)
			{
				try
				{
					if (!string.IsNullOrEmpty(text))
					{
						LoggingHelper.DebugLog("Deleting temporary file '" + text + "'.");
						File.Delete(text);
					}
				}
				catch (Exception ex)
				{
					LoggingHelper.ErrorLog("Was unable to delete temporary file '" + text + "' with the following error: '" + ex.Message + "'.");
				}
			}
			LoggingHelper.DebugLog("Finished deleting temporary files.");
		}
	}
	public static class URLVerification
	{
		private static readonly List<string> DangerousExtensions = new List<string>
		{
			".exe", ".msi", ".bat", ".cmd", ".com", ".ps1", ".vbs", ".js", ".zip", ".rar",
			".7z", ".tar", ".gz", ".docm", ".xlsm", ".pptm", ".dll", ".iso", ".dmg", ".sh"
		};

		public static bool SetClickURL(string stringURL, ref Uri clickURI)
		{
			if (!Uri.TryCreate(stringURL, UriKind.Absolute, out Uri result))
			{
				LoggingHelper.ErrorLog("Given URL '" + stringURL[..Math.Min(10, stringURL.Length)] + "[...]' is not a valid URL. Unable of setting URL. Make sure it is in a valid format: 'http://' or 'https://'.");
				return false;
			}
			if (!IsURLAndNotUnsafe(result))
			{
				LoggingHelper.ErrorLog("Given URL '" + stringURL[..Math.Min(10, stringURL.Length)] + "[...]' is not a accepted URL. Unable of setting URL. Make sure it is in a valid format: 'http://' or 'https://'.");
				return false;
			}
			if (IsADangerousFileUrl(result))
			{
				LoggingHelper.ErrorLog("Given URL '" + stringURL[..Math.Min(10, stringURL.Length)] + "[...]' is not a accepted URL. Unable of setting URL. Please provide an URL that is not a unsafe file type.");
				return false;
			}
			clickURI = result;
			return true;
		}

		public static bool OpenURIInBrowser(Uri clickURL)
		{
			if (clickURL == null)
			{
				return false;
			}
			bool flag = false;
			if (!clickURL.IsAbsoluteUri)
			{
				flag = true;
			}
			if (!IsURLAndNotUnsafe(clickURL))
			{
				flag = true;
			}
			if (IsADangerousFileUrl(clickURL))
			{
				flag = true;
			}
			if (flag)
			{
				LoggingHelper.ErrorLog("Given URL has been marked as unsafe and will not opened.");
				return false;
			}
			int stringMaxPrintLength = Math.Min(10, clickURL.AbsoluteUri.Length);
			LoggingHelper.DebugLog(() => "Opening URI in browser: '" + clickURL.AbsoluteUri.Substring(0, stringMaxPrintLength) + "[...]'.");
			Process.Start(new ProcessStartInfo
			{
				FileName = clickURL.AbsoluteUri,
				UseShellExecute = true
			});
			return true;
		}

		private static bool IsADangerousFileUrl(Uri uri)
		{
			string extension = Path.GetExtension(uri.AbsolutePath);
			if (DangerousExtensions.Contains(extension.ToLowerInvariant()))
			{
				return true;
			}
			return false;
		}

		public static bool IsURLAndNotUnsafe(Uri uri)
		{
			if (uri.IsFile || uri.IsLoopback)
			{
				return false;
			}
			if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)
			{
				return false;
			}
			return true;
		}
	}
}
namespace NewSafetyHelp.ErrorDebugging
{
	public static class UnityLogHook
	{
		public static void HandleUnityLog(string logString, string stackTrace, LogType type)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected I4, but got Unknown
			switch ((int)type)
			{
			case 0:
				LoggingHelper.ErrorLog("[Unity Error] " + logString + "\nStackTrace:\n" + stackTrace);
				break;
			case 4:
				LoggingHelper.ErrorLog("[Unity Error] " + logString + "\nStackTrace:\n" + stackTrace);
				break;
			case 2:
				LoggingHelper.ErrorLog("[Unity Warning] " + logString + "\nStackTrace:\n" + stackTrace);
				break;
			default:
				LoggingHelper.DebugLog("[Unity Log] " + logString);
				break;
			}
		}
	}
}
namespace NewSafetyHelp.EntryManager
{
	public static class EntryManager
	{
		public static void AddEntryToTheProfile(MonsterProfile newProfile, ref MonsterProfile[] monsterProfiles, string profileName, bool isPermissionAdd = false)
		{
			if (monsterProfiles == null)
			{
				monsterProfiles = (MonsterProfile[])(object)new MonsterProfile[1] { newProfile };
				return;
			}
			if (profileName != "NO_PRINT")
			{
				LoggingHelper.DebugLog(() => "Adding (New Name: " + newProfile.monsterName + ", " + $"New ID: {newProfile.monsterID}) to profile: {profileName}.", LoggingHelper.LoggingCategory.ENTRY);
			}
			int monsterID = newProfile.monsterID;
			if (profileName != "NO_PRINT")
			{
				LoggingHelper.DebugLog($"Checking IDs with monster profile array of size {monsterProfiles.Length}.", LoggingHelper.LoggingCategory.ENTRY);
			}
			if (!isPermissionAdd && monsterProfiles.Length != 0 && monsterID != -1)
			{
				for (int num = 0; num < monsterProfiles.Length; num++)
				{
					if (monsterProfiles[num].monsterID == monsterID)
					{
						if (profileName != "NONE" && profileName != "NO_PRINT")
						{
							LoggingHelper.WarningLog("An existing entry was overriden (Old Name: " + ((Object)monsterProfiles[num]).name + ", " + $"Old ID: {monsterProfiles[num].monsterID})" + "(New Name: " + newProfile.monsterName + ", " + $"New ID: {newProfile.monsterID}).\n " + "If this was intentional, you can safely ignore it.");
						}
						monsterProfiles[num] = newProfile;
						return;
					}
				}
			}
			MonsterProfile[] array = (MonsterProfile[])(object)new MonsterProfile[monsterProfiles.Length + 1];
			for (int num2 = 0; num2 < monsterProfiles.Length; num2++)
			{
				array[num2] = monsterProfiles[num2];
			}
			array[^1] = newProfile;
			monsterProfiles = array;
			switch (profileName)
			{
			case "firstTierUnlocks":
				EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierOne.Add(newProfile);
				break;
			case "secondTierUnlocks":
				EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierTwo.Add(newProfile);
				break;
			case "thirdTierUnlocks":
				EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierThree.Add(newProfile);
				break;
			case "fourthTierUnlocks":
				EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierFour.Add(newProfile);
				break;
			case "fifthTierUnlocks":
				EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierFive.Add(newProfile);
				break;
			case "sixthTierUnlocks":
				EntryUnlockerPatcher.FixPermissionOverride.EntriesReaddTierSix.Add(newProfile);
				break;
			}
		}

		public static void DeleteEntryProfile(ref MonsterProfile[] monsterProfiles, MonsterProfile profileToDelete = null, string entryName = "NOT_PROVIDED")
		{
			if (monsterProfiles == null)
			{
				LoggingHelper.WarningLog("Profile to be deleted was not found! Empty entry.");
				return;
			}
			int num;
			if ((Object)(object)profileToDelete != (Object)null)
			{
				num = Array.FindIndex(monsterProfiles, (MonsterProfile p) => (Object)(object)p == (Object)(object)profileToDelete);
			}
			else
			{
				if (!(entryName != "NOT_PROVIDED"))
				{
					LoggingHelper.WarningLog("No name and no profile provided. Unable of deleting.");
					return;
				}
				num = Array.FindIndex(monsterProfiles, (MonsterProfile p) => p.monsterName == entryName);
			}
			if (num < 0)
			{
				LoggingHelper.WarningLog("Profile to be deleted was not found! Unknown entry.");
				return;
			}
			MonsterProfile[] array = (MonsterProfile[])(object)new MonsterProfile[monsterProfiles.Length - 1];
			for (int num2 = 0; num2 < num; num2++)
			{
				array[num2] = monsterProfiles[num2];
			}
			for (int num3 = num + 1; num3 < monsterProfiles.Length; num3++)
			{
				array[num3 - 1] = monsterProfiles[num3];
			}
			monsterProfiles = array;
		}

		public static MonsterProfile CreateEntry(string entryName = "NO_NAME", string entryDescription = "NO_DESCRIPTION", int entryID = -1, Sprite entryPortrait = null, RichAudioClip entryAudioClip = null, string[] arcadeCalls = null, bool spiderPhobia = false, bool darknessPhobia = false, bool dogPhobia = false, bool holesPhobia = false, bool insectPhobia = false, bool watchingPhobia = false, bool tightSpacePhobia = false)
		{
			MonsterProfile val = ScriptableObject.CreateInstance<MonsterProfile>();
			((Object)val).name = entryName;
			val.monsterName = entryName;
			val.monsterDescription = entryDescription;
			val.monsterID = entryID;
			val.monsterPortrait = entryPortrait;
			val.monsterAudioClip = entryAudioClip;
			val.spider = spiderPhobia;
			val.dark = darknessPhobia;
			val.dog = dogPhobia;
			val.holes = holesPhobia;
			val.insect = insectPhobia;
			val.watching = watchingPhobia;
			val.tightSpace = tightSpacePhobia;
			val.arcadeCalls = arcadeCalls;
			return val;
		}

		public static void ReplaceEntryImage(ref MonsterProfile[] monsterProfiles, string entryName, Sprite entryImage, int entryID = -1)
		{
			MonsterProfile[] array = monsterProfiles;
			foreach (MonsterProfile val in array)
			{
				if (val.monsterName == entryName || (val.monsterID == entryID && entryID >= 0))
				{
					val.monsterPortrait = entryImage;
				}
			}
		}

		public static MonsterProfile FindEntry(ref MonsterProfile[] monsterProfiles, string entryName = "SKIP_MONSTER_NAME_TO_SEARCH", int entryID = -1)
		{
			MonsterProfile[] array = monsterProfiles;
			foreach (MonsterProfile val in array)
			{
				if ((val.monsterName == entryName && entryName != "SKIP_MONSTER_NAME_TO_SEARCH") || (val.monsterID == entryID && entryID >= 0))
				{
					return val;
				}
			}
			return null;
		}

		public static void ReplaceEntry(ref MonsterProfile[] monsterProfiles, string entryName, MonsterProfile replaceProfile, int entryID = -1)
		{
			for (int i = 0; i < monsterProfiles.Length; i++)
			{
				if (monsterProfiles[i].monsterName == entryName || (monsterProfiles[i].monsterID == entryID && entryID >= 0))
				{
					monsterProfiles[i] = replaceProfile;
				}
			}
		}

		public static void SortEntryProfiles(ref MonsterProfile[] monsterProfiles)
		{
			Array.Sort(monsterProfiles, (MonsterProfile x, MonsterProfile y) => string.Compare(x.monsterName, y.monsterName, StringComparison.InvariantCulture));
		}
	}
}
namespace NewSafetyHelp.EntryManager.EntryUnlocker
{
	public static class EntryUnlockerPatcher
	{
		[HarmonyPatch(typeof(EntryUnlockController), "Awake")]
		public static class FixPermissionOverride
		{
			public static List<MonsterProfile> EntriesReaddTierOne = new List<MonsterProfile>();

			public static List<MonsterProfile> EntriesReaddTierTwo = new List<MonsterProfile>();

			public static List<MonsterProfile> EntriesReaddTierThree = new List<MonsterProfile>();

			public static List<MonsterProfile> EntriesReaddTierFour = new List<MonsterProfile>();

			public static List<MonsterProfile> EntriesReaddTierFive = new List<MonsterProfile>();

			public static List<MonsterProfile> EntriesReaddTierSix = new List<MonsterProfile>();

			private static void Postfix(EntryUnlockController __instance)
			{
				LoggingHelper.DebugLog("If tier/permission levels for extra entries were lost, they will now be readded.");
				for (int i = 0; i < EntriesReaddTierOne.Count; i++)
				{
					if (!__instance.firstTierUnlocks.monsterProfiles.Contains(EntriesReaddTierOne[i]))
					{
						EntryManager.AddEntryToTheProfile(EntriesReaddTierOne[i], ref __instance.firstTierUnlocks.monsterProfiles, "NONE", isPermissionAdd: true);
					}
				}
				for (int j = 0; j < EntriesReaddTierTwo.Count; j++)
				{
					if (!__instance.secondTierUnlocks.monsterProfiles.Contains(EntriesReaddTierTwo[j]))
					{
						EntryManager.AddEntryToTheProfile(EntriesReaddTierTwo[j], ref __instance.secondTierUnlocks.monsterProfiles, "NONE", isPermissionAdd: true);
					}
				}
				for (int k = 0; k < EntriesReaddTierThree.Count; k++)
				{
					if (!__instance.thirdTierUnlocks.monsterProfiles.Contains(EntriesReaddTierThree[k]))
					{
						EntryManager.AddEntryToTheProfile(EntriesReaddTierThree[k], ref __instance.thirdTierUnlocks.monsterProfiles, "NONE", isPermissionAdd: true);
					}
				}
				for (int l = 0; l < EntriesReaddTierFour.Count; l++)
				{
					if (!__instance.fourthTierUnlocks.monsterProfiles.Contains(EntriesReaddTierFour[l]))
					{
						EntryManager.AddEntryToTheProfile(EntriesReaddTierFour[l], ref __instance.fourthTierUnlocks.monsterProfiles, "NONE", isPermissionAdd: true);
					}
				}
				for (int m = 0; m < EntriesReaddTierFive.Count; m++)
				{
					if (!__instance.fifthTierUnlocks.monsterProfiles.Contains(EntriesReaddTierFive[m]))
					{
						EntryManager.AddEntryToTheProfile(EntriesReaddTierFive[m], ref __instance.fifthTierUnlocks.monsterProfiles, "NONE", isPermissionAdd: true);
					}
				}
				for (int n = 0; n < EntriesReaddTierSix.Count; n++)
				{
					if (!__instance.sixthTierUnlocks.monsterProfiles.Contains(EntriesReaddTierSix[n]))
					{
						EntryManager.AddEntryToTheProfile(EntriesReaddTierSix[n], ref __instance.sixthTierUnlocks.monsterProfiles, "NONE", isPermissionAdd: true);
					}
				}
			}
		}

		[HarmonyPatch(typeof(EntryUnlockController), "CheckMonsterIsUnlocked", new Type[] { typeof(MonsterProfile) })]
		public static class CheckMonsterIsUnlockedPatch
		{
			private static void Postfix(ref MonsterProfile profileToCheck, ref bool __result)
			{
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					return;
				}
				if ((Object)(object)profileToCheck == (Object)null)
				{
					LoggingHelper.ErrorLog("Profile to check is empty!");
					return;
				}
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null || activeCustomCampaign.RemoveExistingEntries || !activeCustomCampaign.ResetDefaultEntriesPermission)
				{
					return;
				}
				if (MainClassForMonsterEntries.CopyMonsterProfiles != null)
				{
					if (MainClassForMonsterEntries.CopyMonsterProfiles.Contains(profileToCheck))
					{
						__result = true;
					}
					if (activeCustomCampaign.UseDLCEntries && GlobalVariables.entryUnlockScript.allXmasEntries.monsterProfiles.Contains(profileToCheck))
					{
						__result = true;
					}
				}
				else
				{
					LoggingHelper.ErrorLog("Copy of entry profiles does not exist! Possibly called before initialization.");
				}
			}
		}
	}
}
namespace NewSafetyHelp.EntryManager.EntryListing
{
	public static class EntryListingPatches
	{
		[HarmonyPatch(typeof(EntryListingBehavior), "ShowEntryInfo")]
		public static class ShowEntryInfoPatch
		{
			private static void Postfix(EntryListingBehavior __instance)
			{
				if (HasClickedField == null)
				{
					LoggingHelper.ReflectionError("HasClickedField");
				}
				else
				{
					if (!CustomCampaignGlobal.InCustomCampaign)
					{
						return;
					}
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign != null && !activeCustomCampaign.RemoveExistingEntries && activeCustomCampaign.ResetDefaultEntriesPermission && !activeCustomCampaign.DoShowNewTagForMainGameEntries)
					{
						if (activeCustomCampaign.UseDLCEntries && GlobalVariables.entryUnlockScript.allXmasEntries.monsterProfiles.Contains(__instance.myProfile))
						{
							HasClickedField.SetValue(__instance, true);
							((TMP_Text)__instance.myText).text = __instance.myProfile.monsterName;
						}
						if (MainClassForMonsterEntries.CopyMonsterProfiles.Contains(__instance.myProfile))
						{
							HasClickedField.SetValue(__instance, true);
							((TMP_Text)__instance.myText).text = __instance.myProfile.monsterName;
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(EntryListingBehavior), "DelayedStart")]
		public static class DelayedStartPatch
		{
			private static readonly FieldInfo HasClicked = typeof(EntryListingBehavior).GetField("hasClicked", BindingFlags.Instance | BindingFlags.NonPublic);

			private static readonly MethodInfo DetermineLocked = typeof(EntryListingBehavior).GetMethod("DetermineLocked", BindingFlags.Instance | BindingFlags.NonPublic);

			private static bool Prefix(EntryListingBehavior __instance, [UsedImplicitly] ref IEnumerator __result)
			{
				__result = DelayedStartCoroutine(__instance);
				return false;
			}

			private static IEnumerator DelayedStartCoroutine(EntryListingBehavior __instance)
			{
				yield return null;
				if (HasClicked == null || DetermineLocked == null)
				{
					LoggingHelper.ReflectionError("HasClicked", "DetermineLocked");
					yield break;
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					if (GlobalVariables.entryUnlockScript.CheckMonsterIsUnlocked(__instance.myProfile) && GlobalVariables.currentDay >= GlobalVariables.entryUnlockScript.currentTier + 1)
					{
						HasClicked.SetValue(__instance, true);
					}
					DetermineLocked.Invoke(__instance, null);
					yield break;
				}
				CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (customCampaign == null)
				{
					yield break;
				}
				EntryMetadata entryFound = CustomCampaignGlobal.GetEntryFromActiveCampaign(__instance.myProfile.monsterName);
				if (entryFound != null)
				{
					if (GlobalVariables.entryUnlockScript.CheckMonsterIsUnlocked(__instance.myProfile))
					{
						if (GlobalVariables.entryUnlockScript.currentTier - 1 > entryFound.PermissionLevel)
						{
							HasClicked.SetValue(__instance, true);
						}
						if (GlobalVariables.currentDay >= GlobalVariables.entryUnlockScript.currentTier + 1)
						{
							HasClicked.SetValue(__instance, true);
						}
					}
				}
				else if (GlobalVariables.entryUnlockScript.CheckMonsterIsUnlocked(__instance.myProfile) && GlobalVariables.currentDay >= GlobalVariables.entryUnlockScript.currentTier + 1)
				{
					HasClicked.SetValue(__instance, true);
				}
				DetermineLocked.Invoke(__instance, null);
			}
		}

		private static readonly FieldInfo HasClickedField = typeof(EntryListingBehavior).GetField("hasClicked", BindingFlags.Instance | BindingFlags.NonPublic);
	}
}
namespace NewSafetyHelp.EntryManager.EntryData
{
	public class EntryMetadata : CustomCampaignElementBase
	{
		public int? ID;

		public string EntryDescription;

		public RichAudioClip CallerClip = null;

		public string CallTranscript = "NO_TRANSCRIPT";

		public string CallerName = "NO_CALLER_NAME";

		public Sprite CallerImage = null;

		public float CallerReplaceChance = 0.1f;

		public bool AllowCallAgainOverRestart = true;

		public bool Replace = false;

		public bool InMainCampaign = false;

		public int PermissionLevel = 0;

		public bool OnlyDLC = false;

		public bool IncludeInDlc = false;

		public bool AlreadyCalledOnce = false;

		public bool CurrentlySelected = false;

		public MonsterProfile ReferenceCopyEntry = null;

		public string ReferenceProfileNameInternal = null;

		public string ConsequenceName = "NO_CONSEQUENCE_CALLER_NAME";

		public string ConsequenceTranscript = "NO_CONSEQUENCE_TRANSCRIPT";

		public RichAudioClip ConsequenceCallerClip = null;

		public Sprite ConsequenceCallerImage = null;

		public bool OnlyCustomCampaign = false;

		public bool DeleteEntry = false;

		public string VideoUrlPortrait = string.Empty;

		public bool IsVideoPortrait = false;

		public VariableChanged<bool> VideoPortraitShouldLoop = new VariableChanged<bool>
		{
			Data = true
		};

		public string Name { get; }

		public EntryMetadata(string name, int id)
		{
			Name = name;
			ID = id;
		}
	}
}
namespace NewSafetyHelp.EndingPatches
{
	public class CutsceneSkipInput : MonoBehaviour
	{
		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)32) || Input.GetKeyDown((KeyCode)271))
			{
				LoggingHelper.InfoLog("Skipping cutscene.");
				GameEndCutscene.EndingCutsceneRoutinePatch.StopCutsceneAndReturn();
			}
		}
	}
	public static class GameEndCutscene
	{
		[HarmonyPatch(typeof(MainCanvasBehavior), "EndingCutsceneRoutine")]
		public static class EndingCutsceneRoutinePatch
		{
			private static readonly MethodInfo SaveCallerAnswers = typeof(MainCanvasBehavior).GetMethod("SaveCallerAnswers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo AchievedHundredPercentAccuracyRating = typeof(MainCanvasBehavior).GetMethod("AchievedHundredPercentAccuracyRating", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(MainCanvasBehavior __instance, ref IEnumerator __result)
			{
				__result = EndingCutsceneRoutineChanged(__instance);
				return false;
			}

			private static IEnumerator EndingCutsceneRoutineChanged(MainCanvasBehavior __instance)
			{
				if ((Object)(object)Camera.main == (Object)null)
				{
					LoggingHelper.CriticalErrorLog("Camera was null. Catastrophic failure!");
					yield break;
				}
				if (__instance.videoPlayer.isPlaying || ((Component)Camera.main).gameObject.GetComponent<Animator>().GetBool(Shake))
				{
					LoggingHelper.InfoLog("Ending cutscene is already playing. Not calling again.");
					yield break;
				}
				if (!GlobalVariables.isXmasDLC)
				{
					if (CustomCampaignGlobal.InCustomCampaign)
					{
						(bool foundModifier, VariableChanged<bool> value) finalCutsceneShouldShake = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneShake, (VariableChanged<bool> vCb) => vCb.HasChanged);
						bool shouldCutsceneShake = true;
						if (finalCutsceneShouldShake.foundModifier)
						{
							shouldCutsceneShake = finalCutsceneShouldShake.value.Data;
						}
						if (shouldCutsceneShake)
						{
							((Component)Camera.main).gameObject.GetComponent<Animator>().SetBool(Shake, true);
						}
						(bool foundModifier, VariableChanged<bool> value) finalCutsceneGlitchSoundEffect = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneGlitchSounds, (VariableChanged<bool> vCb) => vCb.HasChanged);
						(bool foundModifier, VariableChanged<RichAudioClip> value) finalCutsceneAudio = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneAudio, (VariableChanged<RichAudioClip> vCb) => vCb.HasChanged);
						bool shouldPlayGlitchSound = true;
						bool playCustomSound = false;
						if (finalCutsceneGlitchSoundEffect.foundModifier)
						{
							shouldPlayGlitchSound = finalCutsceneGlitchSoundEffect.value.Data;
						}
						if (finalCutsceneAudio.foundModifier && (Object)(object)finalCutsceneAudio.value.Data != (Object)null)
						{
							shouldPlayGlitchSound = false;
							playCustomSound = true;
						}
						if (playCustomSound)
						{
							((MonoBehaviour)__instance).StartCoroutine(GlobalVariables.UISoundControllerScript.FadeInLoopingSound(finalCutsceneAudio.value.Data, GlobalVariables.UISoundControllerScript.myScreenShakeLoopingSource, 0.7f));
						}
						else if (shouldPlayGlitchSound)
						{
							((MonoBehaviour)__instance).StartCoroutine(GlobalVariables.UISoundControllerScript.FadeInLoopingSound(GlobalVariables.UISoundControllerScript.screenShakeLoop, GlobalVariables.UISoundControllerScript.myScreenShakeLoopingSource, 0.7f));
							yield return (object)new WaitForSeconds(6f);
							((MonoBehaviour)__instance).StartCoroutine(GlobalVariables.UISoundControllerScript.FadeOutLoopingSound(GlobalVariables.UISoundControllerScript.myScreenShakeLoopingSource, 0.3f));
						}
					}
					else
					{
						((Component)Camera.main).gameObject.GetComponent<Animator>().SetBool(Shake, true);
						((MonoBehaviour)__instance).StartCoroutine(GlobalVariables.UISoundControllerScript.FadeInLoopingSound(GlobalVariables.UISoundControllerScript.screenShakeLoop, GlobalVariables.UISoundControllerScript.myScreenShakeLoopingSource, 0.7f));
						yield return (object)new WaitForSeconds(6f);
						((MonoBehaviour)__instance).StartCoroutine(GlobalVariables.UISoundControllerScript.FadeOutLoopingSound(GlobalVariables.UISoundControllerScript.myScreenShakeLoopingSource, 0.3f));
					}
					GlobalVariables.musicControllerScript.StopTrialMusic();
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					GlobalVariables.saveManagerScript.savedGameFinished = 1;
					GlobalVariables.saveManagerScript.savedGameFinishedDisplay = 1;
					if (SaveCallerAnswers == null)
					{
						LoggingHelper.ReflectionError("SaveCallerAnswers");
						yield break;
					}
					SaveCallerAnswers.Invoke(__instance, null);
				}
				else
				{
					CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign == null)
					{
						yield break;
					}
					customCampaign.SavedGameFinished = 1;
					customCampaign.SavedGameFinishedDisplay = 1;
					List<bool> flagArray = new List<bool>();
					int index = 0;
					while (index < GlobalVariables.callerControllerScript.callers.Length)
					{
						flagArray.Add(item: false);
						int num = index + 1;
						index = num;
					}
					int index2 = 0;
					while (index2 < GlobalVariables.callerControllerScript.callers.Length)
					{
						flagArray[index2] = GlobalVariables.callerControllerScript.callers[index2].answeredCorrectly;
						int num = index2 + 1;
						index2 = num;
					}
					customCampaign.SavedCallersCorrectAnswer = flagArray;
					customCampaign.SavedCallerArrayLength = GlobalVariables.callerControllerScript.callers.Length;
				}
				GlobalVariables.saveManagerScript.SaveGameProgress();
				GlobalVariables.saveManagerScript.SaveGameFinished();
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					(bool foundModifier, VariableChanged<bool> value) finalCutsceneFadeToBlack = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneFadeToBlack, (VariableChanged<bool> vCb) => vCb.HasChanged);
					bool shouldPlayFadeToBlack = true;
					if (finalCutsceneFadeToBlack.foundModifier)
					{
						shouldPlayFadeToBlack = finalCutsceneFadeToBlack.value.Data;
					}
					(bool foundModifier, VariableChanged<float> value) finalCutsceneFadeDuration = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneFadeDuration, (VariableChanged<float> vCb) => vCb.HasChanged);
					(bool foundModifier, VariableChanged<float> value) finalCutsceneFadePaddingDuration = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneFadePaddingDuration, (VariableChanged<float> vCb) => vCb.HasChanged);
					(bool foundModifier, VariableChanged<bool> value) finalCutsceneStopAudioAfterFade = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneStopAudioAfterFade, (VariableChanged<bool> vCb) => vCb.HasChanged);
					float fadeDuration = 3f;
					float fadeOutPadding = 1f;
					bool stopAudioAfterFade = true;
					if (finalCutsceneFadeDuration.foundModifier)
					{
						fadeDuration = finalCutsceneFadeDuration.value.Data;
					}
					if (finalCutsceneFadePaddingDuration.foundModifier)
					{
						fadeOutPadding = finalCutsceneFadePaddingDuration.value.Data;
					}
					if (finalCutsceneStopAudioAfterFade.foundModifier)
					{
						stopAudioAfterFade = finalCutsceneStopAudioAfterFade.value.Data;
					}
					if (shouldPlayFadeToBlack)
					{
						GlobalVariables.fade.FadeIn(fadeDuration, (string)null);
						yield return (object)new WaitForSeconds(fadeDuration + fadeOutPadding);
						if (stopAudioAfterFade)
						{
							((MonoBehaviour)__instance).StartCoroutine(GlobalVariables.UISoundControllerScript.FadeOutLoopingSound(GlobalVariables.UISoundControllerScript.myScreenShakeLoopingSource, 0.3f));
						}
						GlobalVariables.fade.FadeOut(0.5f);
					}
				}
				else
				{
					GlobalVariables.fade.FadeIn(3f, (string)null);
					yield return (object)new WaitForSeconds(4f);
					GlobalVariables.fade.FadeOut(0.5f);
				}
				__instance.cutsceneCanvas.SetActive(true);
				yield return (object)new WaitForSeconds(0.5f);
				bool isPlayingCustomVideo = false;
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					__instance.videoPlayer.clip = __instance.endClip;
					if (GlobalVariables.isXmasDLC)
					{
						__instance.videoPlayer.clip = __instance.xmasEndClip;
					}
				}
				else
				{
					CustomCampaign customCampaign2 = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign2 == null)
					{
						yield break;
					}
					string endCutsceneVideoURL = null;
					if (!string.IsNullOrEmpty(customCampaign2.EndCutsceneVideoName))
					{
						endCutsceneVideoURL = customCampaign2.EndCutsceneVideoName;
					}
					if (customCampaign2.CustomCutscenes != null && customCampaign2.CustomCutscenes.Count > 0)
					{
						foreach (CustomCutscene customCutscene in customCampaign2.CustomCutscenes)
						{
							if (AccuracyCutsceneHelper.CheckCutsceneAccuracy(customCutscene) && !string.IsNullOrEmpty(customCutscene.CutsceneVideoPath))
							{
								LoggingHelper.DebugLog("Picked cutscene with the path: '" + customCutscene.CutsceneVideoPath + "'.", LoggingHelper.LoggingCategory.CUTSCENE);
								endCutsceneVideoURL = customCutscene.CutsceneVideoPath;
								break;
							}
						}
					}
					if (!string.IsNullOrEmpty(endCutsceneVideoURL))
					{
						isPlayingCustomVideo = true;
						__instance.videoPlayer.url = endCutsceneVideoURL;
					}
					else
					{
						__instance.videoPlayer.clip = __instance.endClip;
					}
					(bool foundModifier, VariableChanged<bool> value) finalCutsceneDisableSkippingKeys = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneDisableSkippingKeys, (VariableChanged<bool> vCb) => vCb.HasChanged);
					if ((Object)(object)((Component)__instance.videoPlayer).gameObject.GetComponent<CutsceneSkipInput>() == (Object)null)
					{
						if (finalCutsceneDisableSkippingKeys.foundModifier)
						{
							if (!finalCutsceneDisableSkippingKeys.value.Data)
							{
								((Component)__instance.videoPlayer).gameObject.AddComponent<CutsceneSkipInput>();
							}
						}
						else
						{
							((Component)__instance.videoPlayer).gameObject.AddComponent<CutsceneSkipInput>();
						}
					}
				}
				__instance.videoPlayer.Play();
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					yield return (object)new WaitForSeconds((float)__instance.videoPlayer.clip.length);
				}
				else
				{
					CustomCampaign customCampaign3 = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign3 == null)
					{
						LoggingHelper.CampaignNullError();
						yield break;
					}
					bool prepareVideo = false;
					if (isPlayingCustomVideo)
					{
						prepareVideo = true;
					}
					if (prepareVideo)
					{
						__instance.videoPlayer.Prepare();
						while (__instance.videoPlayer.isPlaying)
						{
							yield return null;
						}
						(bool foundModifier, VariableChanged<bool> value) finalCutsceneStayInCustomCampaign = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneStayInCustomCampaign, (VariableChanged<bool> vCb) => vCb.HasChanged);
						if (finalCutsceneStayInCustomCampaign.foundModifier && finalCutsceneStayInCustomCampaign.value.Data)
						{
							CustomCampaignSceneSwitcher.SaveAndLoadDesktopScene(alsoLoadMainMenu: false);
						}
						else
						{
							CustomCampaignSceneSwitcher.BackToMainGame(alsoLoadMainMenu: false);
						}
					}
					else
					{
						yield return (object)new WaitForSeconds((float)__instance.videoPlayer.clip.length);
					}
				}
				if (SteamManager.Initialized && !GlobalVariables.isXmasDLC && !CustomCampaignGlobal.InCustomCampaign)
				{
					SteamUserStats.SetAchievement("GameFinished");
					if (AchievedHundredPercentAccuracyRating == null)
					{
						LoggingHelper.ReflectionError("AchievedHundredPercentAccuracyRating");
						yield break;
					}
					if ((bool)AchievedHundredPercentAccuracyRating.Invoke(__instance, null))
					{
						SteamUserStats.SetAchievement("PerfectGame");
						LoggingHelper.DebugLog("[UNITY] PerfectGame Achievement unlocked.");
					}
					SteamUserStats.StoreStats();
				}
				yield return (object)new WaitForSeconds(2f);
				LoggingHelper.DebugLog("Finished game end cutscene.");
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					__instance.ExitToStartMenu();
					yield break;
				}
				CustomCampaign customCampaign4 = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (customCampaign4 == null)
				{
					LoggingHelper.CampaignNullError();
					yield break;
				}
				(bool foundModifier, VariableChanged<bool> value) finalCutsceneReturnTo3DScreen = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneReturnTo3DScreen, (VariableChanged<bool> vCb) => vCb.HasChanged);
				(bool foundModifier, VariableChanged<bool> value) finalCutsceneStayInCustomCampaign2 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneStayInCustomCampaign, (VariableChanged<bool> vCb) => vCb.HasChanged);
				if (finalCutsceneReturnTo3DScreen.foundModifier && finalCutsceneReturnTo3DScreen.value.Data)
				{
					__instance.ExitToStartMenu();
				}
				else if (finalCutsceneStayInCustomCampaign2.foundModifier && finalCutsceneStayInCustomCampaign2.value.Data)
				{
					CustomCampaignSceneSwitcher.SaveAndLoadDesktopScene();
				}
				else
				{
					CustomCampaignSceneSwitcher.BackToMainGame();
				}
			}

			public static void StopCutsceneAndReturn()
			{
				GlobalVariables.mainCanvasScript.videoPlayer.Stop();
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					LoggingHelper.CampaignNullError();
					return;
				}
				(bool, VariableChanged<bool>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneReturnTo3DScreen, (VariableChanged<bool> vCb) => vCb.HasChanged);
				(bool, VariableChanged<bool>) activeModifierValue2 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutsceneStayInCustomCampaign, (VariableChanged<bool> vCb) => vCb.HasChanged);
				if (activeModifierValue.Item1 && activeModifierValue.Item2.Data)
				{
					if (activeModifierValue2.Item1 && activeModifierValue2.Item2.Data)
					{
						CustomCampaignSceneSwitcher.SaveAndLoadDesktopScene(alsoLoadMainMenu: false);
					}
					else
					{
						CustomCampaignSceneSwitcher.BackToMainGame(alsoLoadMainMenu: false);
					}
					GlobalVariables.mainCanvasScript.ExitToStartMenu();
				}
				else if (activeModifierValue2.Item1 && activeModifierValue2.Item2.Data)
				{
					CustomCampaignSceneSwitcher.SaveAndLoadDesktopScene();
				}
				else
				{
					CustomCampaignSceneSwitcher.BackToMainGame();
				}
			}
		}

		private static readonly int Shake = Animator.StringToHash("shake");
	}
	public static class GameOverPatches
	{
		[HarmonyPatch(typeof(CallerController), "TriggerGameOver")]
		public static class TriggerGameOverPatch
		{
			private static bool Prefix(CallerController __instance)
			{
				//IL_0267: Unknown result type (might be due to invalid IL or missing references)
				//IL_0271: Expected O, but got Unknown
				//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e1: Expected O, but got Unknown
				LoggingHelper.DebugLog("Triggering GameOver Call + GameOver Cutscene.");
				if (AnswerDynamicCall == null || TriggerGameOver == null)
				{
					LoggingHelper.ReflectionError("AnswerDynamicCall", "TriggerGameOver");
					return true;
				}
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					if (activeCustomCampaign.CustomGameOverCallersInCampaign.Count > 0)
					{
						CustomCCaller customCCaller = null;
						if (activeCustomCampaign.CustomGameOverCallersInCampaign.Exists((CustomCCaller customCaller) => customCaller.GameOverCallDay <= -1))
						{
							customCCaller = activeCustomCampaign.CustomGameOverCallersInCampaign.FindAll((CustomCCaller customCaller) => customCaller.GameOverCallDay <= -1)[Random.Range(0, activeCustomCampaign.CustomGameOverCallersInCampaign.Count)];
						}
						if (activeCustomCampaign.CustomGameOverCallersInCampaign.Exists((CustomCCaller customCaller) => customCaller.GameOverCallDay == GlobalVariables.currentDay))
						{
							customCCaller = activeCustomCampaign.CustomGameOverCallersInCampaign.FindAll((CustomCCaller customCaller) => customCaller.GameOverCallDay == GlobalVariables.currentDay)[Random.Range(0, activeCustomCampaign.CustomGameOverCallersInCampaign.Count)];
						}
						if (customCCaller != null)
						{
							LoggingHelper.DebugLog("WE are replacing the gameover caller with: " + customCCaller.CallerName + ".");
							CallerProfile val = ScriptableObject.CreateInstance<CallerProfile>();
							val.callerName = customCCaller.CallerName;
							val.callTranscription = customCCaller.CallTranscript;
							if (GetRandomPicMethod == null || GetRandomClip == null)
							{
								LoggingHelper.ReflectionError("GetRandomPicMethod", "GetRandomClip");
								return true;
							}
							if ((Object)(object)customCCaller.CallerImage != (Object)null)
							{
								val.callerPortrait = customCCaller.CallerImage;
							}
							else
							{
								LoggingHelper.WarningLog("GameOver-Caller has no caller image, using random image.");
								val.callerPortrait = (Sprite)GetRandomPicMethod.Invoke(__instance, null);
							}
							if ((Object)(object)customCCaller.CallerClip != (Object)null)
							{
								val.callerClip = customCCaller.CallerClip;
							}
							else
							{
								if (AudioImport.CurrentLoadingAudios.Count > 0)
								{
									LoggingHelper.WarningLog("GameOver-Caller audio is still loading! Using fallback for now. If this happens often, please check if the audio is too large!");
								}
								else
								{
									LoggingHelper.WarningLog("GameOver-Caller has no audio! Using audio fallback. If you provided an audio but this error shows up, check for any errors before!");
								}
								val.callerClip = (RichAudioClip)GetRandomClip.Invoke(__instance, null);
							}
							if (!string.IsNullOrEmpty(customCCaller.EntryNameAttached) || customCCaller.EntryIDAttached != -1)
							{
								LoggingHelper.WarningLog("A entry (monster) was provided for the GameOver caller, but GameOver callers do not use any entries! Will default to none.");
							}
							val.callerMonster = null;
							if (customCCaller.CallerIncreasesTier)
							{
								LoggingHelper.WarningLog("Increase tier was provided for a GameOver caller! It will be set to false!");
							}
							val.increaseTier = false;
							if (customCCaller.ConsequenceCallerID != -1)
							{
								LoggingHelper.WarningLog("GameOver Callers cannot be consequence caller, ignoring option.");
							}
							val.consequenceCallerProfile = null;
							__instance.gameOverCall = val;
						}
					}
				}
				AnswerDynamicCall.Invoke(__instance, new object[1] { __instance.gameOverCall });
				TriggerGameOver.SetValue(__instance, true);
				return false;
			}
		}

		[HarmonyPatch(typeof(MainCanvasBehavior), "GameOverCutsceneRoutine")]
		public static class GameOverCutsceneRoutinePatch
		{
			private static readonly FieldInfo ShakeAnimationString = typeof(MainCanvasBehavior).GetField("shakeAnimationString", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(MainCanvasBehavior __instance, ref IEnumerator __result)
			{
				__result = GameOverCutsceneRoutineChanged(__instance);
				return false;
			}

			private static IEnumerator GameOverCutsceneRoutineChanged(MainCanvasBehavior __instance)
			{
				if (ShakeAnimationString == null)
				{
					LoggingHelper.ReflectionError("ShakeAnimationString");
					yield break;
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					__instance.cameraAnimator.SetBool((string)ShakeAnimationString.GetValue(__instance), true);
				}
				else
				{
					__instance.cameraAnimator.SetBool((string)ShakeAnimationString.GetValue(__instance), true);
				}
				((MonoBehaviour)__instance).StartCoroutine(GlobalVariables.UISoundControllerScript.FadeInLoopingSound(GlobalVariables.UISoundControllerScript.screenShakeLoop, GlobalVariables.UISoundControllerScript.myScreenShakeLoopingSource, 0.7f));
				GlobalVariables.fade.FadeIn(6f, (string)null);
				if (GlobalVariables.musicControllerScript.myTrialMusicSource.isPlaying)
				{
					GlobalVariables.musicControllerScript.StopTrialMusic();
				}
				yield return (object)new WaitForSeconds(6f);
				((MonoBehaviour)__instance).StartCoroutine(GlobalVariables.UISoundControllerScript.FadeOutLoopingSound(GlobalVariables.UISoundControllerScript.myScreenShakeLoopingSource, 0.3f));
				yield return (object)new WaitForSeconds(1f);
				__instance.cutsceneCanvas.SetActive(true);
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					__instance.videoPlayer.clip = __instance.gameOverClip;
					if (GlobalVariables.isXmasDLC)
					{
						__instance.videoPlayer.clip = __instance.xmasGameOverClip;
					}
				}
				else
				{
					CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign == null)
					{
						yield break;
					}
					if (!string.IsNullOrEmpty(customCampaign.GameOverCutsceneVideoName))
					{
						__instance.videoPlayer.url = customCampaign.GameOverCutsceneVideoName;
					}
					else
					{
						__instance.videoPlayer.clip = __instance.gameOverClip;
					}
				}
				__instance.videoPlayer.Play();
				yield return (object)new WaitForSeconds(1f);
				GlobalVariables.fade.FadeOut(3f);
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					yield return (object)new WaitForSeconds((float)__instance.videoPlayer.clip.length);
				}
				else
				{
					CustomCampaign customCampaign2 = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign2 == null)
					{
						yield break;
					}
					if (!string.IsNullOrEmpty(customCampaign2.GameOverCutsceneVideoName))
					{
						__instance.videoPlayer.Prepare();
						while (__instance.videoPlayer.isPlaying)
						{
							yield return null;
						}
					}
					else
					{
						yield return (object)new WaitForSeconds((float)__instance.videoPlayer.clip.length);
					}
				}
				if (SteamManager.Initialized && !GlobalVariables.isXmasDLC && !CustomCampaignGlobal.InCustomCampaign)
				{
					SteamUserStats.SetAchievement("Fired");
					SteamUserStats.StoreStats();
				}
				GlobalVariables.fade.FadeIn(2f, (string)null);
				yield return (object)new WaitForSeconds(2f);
				__instance.RestartDay();
			}
		}

		private static readonly MethodInfo AnswerDynamicCall = typeof(CallerController).GetMethod("AnswerDynamicCall", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

		private static readonly FieldInfo TriggerGameOver = typeof(CallerController).GetField("triggerGameOver", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

		private static readonly MethodInfo GetRandomPicMethod = typeof(CallerController).GetMethod("PickRandomPic", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly MethodInfo GetRandomClip = typeof(CallerController).GetMethod("PickRandomClip", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
	}
}
namespace NewSafetyHelp.Emails
{
	public class CustomEmail : CustomCampaignElementBase
	{
		public string EmailSubject = "";

		public string SenderName = "";

		public string EmailBody = "";

		[CanBeNull]
		public Sprite EmailImage = null;

		[CanBeNull]
		public string EmailAnimatedVideo = null;

		public bool HasAnimatedVideo = false;

		public VariableChanged<bool> EmailAnimatedVideoShouldLoop = new VariableChanged<bool>
		{
			Data = true
		};

		[CanBeNull]
		public Uri EmailClickURL;

		public int UnlockDay = 0;

		public int EmailPriority = 0;

		public float UnlockThreshold = 0f;

		[CanBeNull]
		public List<GeneralAccuracyType> UnlockAccuracy = null;

		public bool UseOldAccuracyChecks = true;

		[CanBeNull]
		public List<CallerRequirement> UnlockRequiredCallers = null;

		public bool UnlockWhenGameFinished = false;

		public bool InMainCampaign = false;

		[CanBeNull]
		public Email ReferenceToEmailObject = null;
	}
}
namespace NewSafetyHelp.CustomVideos
{
	public class CustomVideo : CustomCampaignElementBase
	{
		public string DesktopName = "NO_DESKTOP_NAME";

		public string VideoURL = null;

		public int UnlockDay = 1;

		public int OrderPriority = 0;

		public VariableChanged<int> GameObjectOrder = new VariableChanged<int>
		{
			Data = 0
		};

		public GameObject ReferenceToCreatedVideo = null;

		public bool IgnoreAccuracyChecks = true;

		[CanBeNull]
		public List<GeneralAccuracyType> UnlockAccuracy = null;

		[CanBeNull]
		public List<CallerRequirement> UnlockRequiredCallers = null;

		public bool UnlockWhenGameFinished = false;
	}
	public static class VideoHelper
	{
		private static readonly FieldInfo DayUnlockScript = typeof(VideoExecutableFile).GetField("dayUnlockScript", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

		public static GameObject CreateCustomVideoFileProgram(CustomVideo customVideo)
		{
			GameObject gameObject = ((Component)CustomDesktopHelper.GetLeftPrograms().transform.Find("TrailerFile")).gameObject;
			GameObject val = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent);
			if (string.IsNullOrEmpty(customVideo.DesktopName))
			{
				LoggingHelper.ErrorLog("No filename provided for video to be created!");
			}
			((Object)val).name = customVideo.DesktopName + customVideo.VideoURL;
			if (customVideo.GameObjectOrder.HasChanged)
			{
				val.transform.SetSiblingIndex(customVideo.GameObjectOrder.Data);
			}
			TextMeshProUGUI component = ((Component)((Component)val.transform.Find("TextBackground")).transform.Find("ExecutableName")).gameObject.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = customVideo.DesktopName;
			OnDayUnlock component2 = val.GetComponent<OnDayUnlock>();
			component2.unlockDay = customVideo.UnlockDay;
			if (customVideo.IgnoreAccuracyChecks)
			{
				if (customVideo.UnlockDay <= GlobalVariables.currentDay)
				{
					val.SetActive(true);
				}
			}
			else if (AccuracyVideoHelper.CheckIfVideoAccuracyType(customVideo))
			{
				val.SetActive(true);
			}
			VideoExecutableFile component3 = val.GetComponent<VideoExecutableFile>();
			component3.videoClip = null;
			if (DayUnlockScript == null)
			{
				LoggingHelper.ReflectionError("DayUnlockScript");
				customVideo.ReferenceToCreatedVideo = null;
				return null;
			}
			DayUnlockScript.SetValue(component3, component2);
			customVideo.ReferenceToCreatedVideo = val;
			return val;
		}
	}
	public static class VideoPatches
	{
		[HarmonyPatch(typeof(VideoExecutableFile), "PlayVideoRoutine")]
		public static class PlayVideoRoutinePatch
		{
			private static readonly FieldInfo MyClearScript = typeof(VideoExecutableFile).GetField("myClearScript", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

			private static MethodInfo refreshVideo;

			private static bool Prefix(VideoExecutableFile __instance, ref IEnumerator __result)
			{
				__result = PlayVideoRoutineCoroutine(__instance);
				return false;
			}

			private static IEnumerator PlayVideoRoutineCoroutine(VideoExecutableFile __instance)
			{
				__instance.notification.SetActive(false);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign == null)
					{
						yield break;
					}
					if ((Object)(object)__instance.videoClip != (Object)null)
					{
						__instance.videoPlayer.clip = __instance.videoClip;
					}
					else
					{
						CustomVideo customVideo = CustomCampaignGlobal.GetCustomVideoFromActiveCampaign(((Component)__instance).gameObject);
						if (customVideo == null)
						{
							LoggingHelper.CriticalErrorLog("Unable of finding the video show! Critical error.");
							yield break;
						}
						__instance.videoPlayer.url = customVideo.VideoURL;
					}
				}
				else
				{
					__instance.videoPlayer.clip = __instance.videoClip;
				}
				if (MyClearScript == null)
				{
					LoggingHelper.ReflectionError("MyClearScript");
					yield break;
				}
				object myClearScript = MyClearScript.GetValue(__instance);
				if (myClearScript == null)
				{
					LoggingHelper.CriticalErrorLog("MyClearScript was not able to get value. Critical error.");
					yield break;
				}
				refreshVideo = myClearScript.GetType().GetMethod("RefreshVideo", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (refreshVideo == null)
				{
					LoggingHelper.ReflectionError("refreshVideo");
				}
				else
				{
					refreshVideo.Invoke(myClearScript, null);
					yield return (object)new WaitForSeconds(0.5f);
					__instance.videoPopup.SetActive(true);
				}
			}
		}

		[HarmonyPatch(typeof(AudioSamplePlayer), "PlayOrPauseVideo")]
		public static class PlayOrPauseVideoPatch
		{
			private static readonly FieldInfo PlayerCurrentPosition = typeof(AudioSamplePlayer).GetField("playerCurrentPosition", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

			private static bool Prefix(AudioSamplePlayer __instance)
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)__instance.myVideoPlayer))
				{
					return false;
				}
				if (PlayerCurrentPosition == null)
				{
					LoggingHelper.ReflectionError("PlayerCurrentPosition");
					return true;
				}
				if (__instance.myVideoPlayer.isPlaying)
				{
					__instance.myVideoPlayer.Pause();
					PlayerCurrentPosition.SetValue(__instance, __instance.playerTracker.transform.localPosition);
					((MonoBehaviour)__instance).StopAllCoroutines();
				}
				else
				{
					MelonCoroutines.Start(HandleURLVideoBetter(__instance, PlayerCurrentPosition));
				}
				return false;
			}

			private static IEnumerator HandleURLVideoBetter(AudioSamplePlayer __instance, FieldInfo playerCurrentPosition)
			{
				__instance.myVideoPlayer.Play();
				if (__instance.myVideoPlayer.time == 0.0 && __instance.playerTracker.transform.localPosition == __instance.playerStartPosition)
				{
					if ((Object)(object)__instance.myVideoPlayer.clip != (Object)null)
					{
						yield return ((MonoBehaviour)__instance).StartCoroutine(__instance.MoveOverSeconds(__instance.playerTracker, __instance.playerStartPosition, __instance.playerEndPosition, (float)__instance.myVideoPlayer.clip.length));
					}
					else if (!string.IsNullOrEmpty(__instance.myVideoPlayer.url))
					{
						yield return WaitForPrepare(__instance.myVideoPlayer);
						float duration = (float)__instance.myVideoPlayer.frameCount / __instance.myVideoPlayer.frameRate;
						yield return ((MonoBehaviour)__instance).StartCoroutine(__instance.MoveOverSeconds(__instance.playerTracker, __instance.playerStartPosition, __instance.playerEndPosition, duration));
					}
					else
					{
						LoggingHelper.ErrorLog("Unable of playing video as the URL and the Clip are null.");
					}
				}
				else if ((Object)(object)__instance.myVideoPlayer.clip != (Object)null)
				{
					yield return ((MonoBehaviour)__instance).StartCoroutine(__instance.MoveOverSeconds(__instance.playerTracker, (Vector3)playerCurrentPosition.GetValue(__instance), __instance.playerEndPosition, (float)__instance.myVideoPlayer.clip.length - (float)__instance.myVideoPlayer.time));
				}
				else if (!string.IsNullOrEmpty(__instance.myVideoPlayer.url))
				{
					yield return WaitForPrepare(__instance.myVideoPlayer);
					float duration2 = (float)__instance.myVideoPlayer.frameCount / __instance.myVideoPlayer.frameRate;
					yield return ((MonoBehaviour)__instance).StartCoroutine(__instance.MoveOverSeconds(__instance.playerTracker, (Vector3)playerCurrentPosition.GetValue(__instance), __instance.playerEndPosition, duration2 - (float)__instance.myVideoPlayer.time));
				}
				else
				{
					LoggingHelper.ErrorLog("Unable of playing video as the URL and the Clip are null.");
				}
			}

			private static IEnumerator WaitForPrepare(VideoPlayer vp)
			{
				vp.Prepare();
				while (!vp.isPrepared)
				{
					yield return null;
				}
			}
		}

		[HarmonyPatch(typeof(AudioSamplePlayer), "Update")]
		public static class UpdatePatch
		{
			private static readonly FieldInfo PlayerCurrentPosition = typeof(AudioSamplePlayer).GetField("playerCurrentPosition", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

			private static bool Prefix(AudioSamplePlayer __instance)
			{
				//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_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_020c: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
				if ((Object.op_Implicit((Object)(object)__instance.myAudioSource) && __instance.myAudioSource.isPlaying) || (Object.op_Implicit((Object)(object)__instance.myVideoPlayer) && __instance.myVideoPlayer.isPlaying))
				{
					__instance.myImage.sprite = __instance.stopSprite;
					__instance.audioLabelText.SetActive(false);
				}
				else
				{
					__instance.myImage.sprite = __instance.playSprite;
					__instance.audioLabelText.SetActive(true);
					if (Object.op_Implicit((Object)(object)__instance.myAudioSource) && __instance.playerTracker.transform.localPosition != __instance.playerStartPosition)
					{
						((MonoBehaviour)__instance).StopAllCoroutines();
						__instance.playerTracker.transform.localPosition = __instance.playerStartPosition;
					}
				}
				if (!__instance.scrubbing)
				{
					return false;
				}
				if (Object.op_Implicit((Object)(object)__instance.myVideoPlayer) && __instance.myVideoPlayer.isPlaying)
				{
					((MonoBehaviour)__instance).StopAllCoroutines();
					__instance.myVideoPlayer.Pause();
				}
				if ((Object)(object)Camera.main == (Object)null)
				{
					LoggingHelper.ErrorLog("Camera missing! Calling original function!");
					return true;
				}
				__instance.playerTracker.transform.position = new Vector3(Camera.main.ScreenToWorldPoint(Input.mousePosition).x, __instance.playerTracker.transform.position.y, __instance.playerTracker.transform.position.z);
				if (__instance.playerTracker.transform.localPosition.x < __instance.playerStartPosition.x)
				{
					__instance.playerTracker.transform.localPosition = __instance.playerStartPosition;
				}
				if (__instance.playerTracker.transform.localPosition.x > __instance.playerEndPosition.x)
				{
					__instance.playerTracker.transform.localPosition = __instance.playerEndPosition;
				}
				float num = (__instance.playerTracker.transform.localPosition.x - __instance.playerStartPosition.x) / (__instance.playerEndPosition.x - __instance.playerStartPosition.x);
				if (Object.op_Implicit((Object)(object)__instance.myVideoPlayer))
				{
					MelonCoroutines.Start(HandleURLVideoBetter(__instance, PlayerCurrentPosition, num));
				}
				if (Object.op_Implicit((Object)(object)__instance.myAudioSource))
				{
					__instance.myAudioSource.time = __instance.myAudioSource.clip.length * num;
					PlayerCurrentPosition.SetValue(__instance, __instance.playerTracker.transform.localPosition);
				}
				return false;
			}

			private static IEnumerator HandleURLVideoBetter(AudioSamplePlayer __instance, FieldInfo playerCurrentPosition, float computedDistanceFactor)
			{
				if ((Object)(object)__instance.myVideoPlayer.clip != (Object)null)
				{
					__instance.myVideoPlayer.time = __instance.myVideoPlayer.clip.length * (double)computedDistanceFactor;
				}
				else
				{
					if (string.IsNullOrEmpty(__instance.myVideoPlayer.url))
					{
						LoggingHelper.ErrorLog("No URL or Clip provided for video player in update function! Critical error!");
						yield break;
					}
					yield return WaitForPrepare(__instance.myVideoPlayer);
					float duration = (float)__instance.myVideoPlayer.frameCount / __instance.myVideoPlayer.frameRate;
					__instance.myVideoPlayer.time = duration * computedDistanceFactor;
				}
				playerCurrentPosition.SetValue(__instance, __instance.playerTracker.transform.localPosition);
			}

			private static IEnumerator WaitForPrepare(VideoPlayer vp)
			{
				vp.Prepare();
				while (!vp.isPrepared)
				{
					yield return null;
				}
			}
		}
	}
}
namespace NewSafetyHelp.CustomThemes
{
	public static class ColorHelper
	{
		public static float GetConvertedColorFloat(float currentColorValue)
		{
			currentColorValue = Math.Abs(currentColorValue);
			if (currentColorValue <= 1f)
			{
				return currentColorValue;
			}
			return currentColorValue / 255f;
		}
	}
}
namespace NewSafetyHelp.CustomDesktop
{
	public static class CustomDesktop
	{
		[HarmonyPatch(typeof(MainMenuCanvasBehavior), "Start")]
		public static class StartPatch
		{
			private static bool Prefix(MainMenuCanvasBehavior __instance)
			{
				//IL_09da: Unknown result type (might be due to invalid IL or missing references)
				//IL_09df: Unknown result type (might be due to invalid IL or missing references)
				//IL_09f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a4a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a54: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a68: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a72: Unknown result type (might be due to invalid IL or missing references)
				LoggingHelper.DebugLog("Start of Main Menu Canvas Behavior.");
				if (!GlobalVariables.isXmasDLC)
				{
					GameObject gameObject = CustomDesktopHelper.GetMainMenuCanvas().gameObject;
					if ((Object)(object)gameObject != (Object)null)
					{
						GameObject gameObject2 = ((Component)gameObject.transform.Find("TextPopup")).gameObject;
						if ((Object)(object)gameObject2 != (Object)null)
						{
							GameObject gameObject3 = ((Component)gameObject2.transform.Find("WindowsBar")).gameObject;
							if ((Object)(object)gameObject3 != (Object)null)
							{
								GameObject gameObject4 = ((Component)gameObject3.transform.Find("CloseButton")).gameObject;
								if (gameObject4.GetComponents<Button>().Length >= 2)
								{
									Object.Destroy((Object)(object)gameObject4.GetComponent<Button>());
								}
							}
						}
					}
				}
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					EmailHelper.SetAnimatedEmail(AnimatedImageHelper.CreateAnimatedPortrait(EmailHelper.GetEmailImageGameObject()));
					EmailHelper.CreateClickableEmail();
					if (activeCustomCampaign.LoadingTexts[0].Count > 0 && !string.IsNullOrEmpty(activeCustomCampaign.LoadingTexts[0][0]))
					{
						((TMP_Text)__instance.loginText.GetComponent<TextMeshProUGUI>()).text = activeCustomCampaign.LoadingTexts[0][0];
						AnimatedText component = __instance.loginText.GetComponent<AnimatedText>();
						component.textFrames = new string[activeCustomCampaign.LoadingTexts[0].Count];
						for (int i = 0; i < activeCustomCampaign.LoadingTexts[0].Count; i++)
						{
							component.textFrames[i] = activeCustomCampaign.LoadingTexts[0][i];
						}
					}
					if (activeCustomCampaign.LoadingTexts[1].Count > 0 && !string.IsNullOrEmpty(activeCustomCampaign.LoadingTexts[1][0]))
					{
						((TMP_Text)__instance.loginText2.GetComponent<TextMeshProUGUI>()).text = activeCustomCampaign.LoadingTexts[1][0];
						AnimatedText component2 = __instance.loginText2.GetComponent<AnimatedText>();
						component2.textFrames = new string[activeCustomCampaign.LoadingTexts[1].Count];
						for (int j = 0; j < activeCustomCampaign.LoadingTexts[1].Count; j++)
						{
							component2.textFrames[j] = activeCustomCampaign.LoadingTexts[1][j];
						}
					}
					if (activeCustomCampaign.DisablePickingThemeOption)
					{
						ThemeProgramHelper.DisableThemeDropdownDesktop();
					}
				}
				if (!GlobalVariables.isXmasDLC)
				{
					InGameSettingHelper.CreateNewToggle(InGameSettingHelper.GetVideoOptionsSection(), ToggleButtonFunctions.OnVsyncToggle, "Enable VSYNC", GlobalPreferences.Vsync.Value);
					GameObject parentGameObject = InGameSettingHelper.CreateNewSettingsSection("Debug Settings", "Mod settings to show more information and also allow skipping the initial load scene.");
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnSkipComputerSceneToggle, "Skip 3D Computer Scene on Startup", GlobalPreferences.SkipComputerScene.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnSkipLoadingScreenToggle, "Skip Desktop Loading Screen", GlobalPreferences.SkipLoadingScreen.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnSkipDayClockInToggle, "Skip Clock In Screen", GlobalPreferences.SkipDayClockIn.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnDebugLogToggle, "Enable Debug Logs", GlobalPreferences.ShowDebugLogs.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnShowSkippedCallerLogToggle, "Enable Skipped Callers Logs", GlobalPreferences.ShowSkippedCallerDebugLog.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnThemeLogToggle, "Enable Theme Logs", GlobalPreferences.ShowThemeDebugLog.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnRingtoneLogToggle, "Enable Ringtone Logs", GlobalPreferences.ShowRingtoneDebugLog.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnEmailLogToggle, "Enable Email Logs", GlobalPreferences.ShowEmailDebugLog.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnVideoLogToggle, "Enable Video Logs", GlobalPreferences.ShowVideoDebugLog.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnTextFileLogToggle, "Enable Text File Logs", GlobalPreferences.ShowTextFileDebugLog.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnEntryLogToggle, "Enable Entry Logs", GlobalPreferences.ShowEntryDebugLog.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnCutsceneLogToggle, "Enable Cutscene Logs", GlobalPreferences.ShowCutsceneLog.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnMemoryLogToggle, "Enable Memory Usage Logs", GlobalPreferences.ShowMemoryLog.Value);
					InGameSettingHelper.CreateNewToggle(parentGameObject, ToggleButtonFunctions.OnLinkApp, "Enable Link App Logs", GlobalPreferences.ShowLinkAppLog.Value);
					InGameSettingHelper.CreateButton(parentGameObject, delegate(GameObject e)
					{
						LoggingHelper.InfoLog("Hot reloading all JSON files. Please note, this is in beta and may break some features. ", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Green);
						ReloadJSONParsing.ReloadAllJSONFiles(e);
						return e;
					}, "Reload all JSON files", "Reload all JSON files");
					InGameSettingHelper.CreateButton(parentGameObject, delegate(GameObject o)
					{
						DebugHelper.CopyLatestLogs();
						return o;
					}, "Copy Log File", "Copies the log file for debug purposes");
				}
				((MonoBehaviour)__instance).StartCoroutine(StartupRoutine(__instance));
				if (!CustomCampaignGlobal.InCustomCampaign && !GlobalVariables.isXmasDLC)
				{
					foreach (CustomCampaign item in CustomCampaignGlobal.CustomCampaignsAvailable)
					{
						CustomCampaignProgramHelper.CreateCustomProgramIcon(item.CampaignDesktopName, item.CampaignName, item.CampaignIcon);
					}
					if (GlobalParsingVariables.MainCampaignEmails.Count > 0)
					{
						foreach (CustomEmail mainCampaignEmail in GlobalParsingVariables.MainCampaignEmails)
						{
							if (mainCampaignEmail.InMainCampaign)
							{
								mainCampaignEmail.ReferenceToEmailObject = EmailHelper.CreateEmail(mainCampaignEmail);
							}
						}
					}
					CustomDesktopHelper.EnableWinterDlcProgram();
				}
				else if (CustomCampaignGlobal.InCustomCampaign && !GlobalVariables.isXmasDLC)
				{
					CustomCampaignProgramHelper.CreateBackToMainGameButton();
					CustomDesktopHelper.DisableWinterDlcProgram();
				}
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign2 = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign2 == null)
					{
						return true;
					}
					ARGHelper.CreateInputCapture();
					DesktopModifierSnapshot modifierDesktopSnapshot = CustomCampaignGlobal.GetModifierDesktopSnapshot();
					string text = null;
					bool flag = false;
					if (!string.IsNullOrEmpty(activeCustomCampaign2.DesktopUsernameText))
					{
						flag = true;
						text = activeCustomCampaign2.DesktopUsernameText;
					}
					if (modifierDesktopSnapshot.UsernameText.found)
					{
						text = modifierDesktopSnapshot.UsernameText.value.Data;
					}
					if (modifierDesktopSnapshot.UsernameText.found || flag)
					{
						((TMP_Text)CustomDesktopHelper.GetUsernameObject().GetComponent<TextMeshProUGUI>()).text = text;
					}
					if (activeCustomCampaign2.Emails.Count > 0)
					{
						foreach (CustomEmail email in activeCustomCampaign2.Emails)
						{
							email.ReferenceToEmailObject = EmailHelper.CreateEmail(email);
						}
					}
					if (activeCustomCampaign2.RemoveDefaultEmails)
					{
						EmailHelper.RemoveMainGameEmails();
					}
					string text2 = string.Empty;
					if (!string.IsNullOrEmpty(activeCustomCampaign2.RenameMainGameDesktopIcon))
					{
						text2 = activeCustomCampaign2.RenameMainGameDesktopIcon;
					}
					if (modifierDesktopSnapshot.RenameMainGameDesktopIcon.found)
					{
						text2 = modifierDesktopSnapshot.RenameMainGameDesktopIcon.value.Data;
					}
					if (!string.IsNullOrEmpty(text2))
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetMainGameProgram().transform.Find("TextBackground/ExecutableName")).GetComponent<TextMeshProUGUI>()).text = text2;
					}
					Sprite val = null;
					if ((Object)(object)activeCustomCampaign2.ChangeMainGameDesktopIcon != (Object)null)
					{
						val = activeCustomCampaign2.ChangeMainGameDesktopIcon;
					}
					if (modifierDesktopSnapshot.MainGameDesktopIcon.found)
					{
						val = modifierDesktopSnapshot.MainGameDesktopIcon.value.Data;
					}
					if ((Object)(object)val != (Object)null)
					{
						CustomDesktopHelper.GetMainGameProgram().GetComponent<Image>().sprite = val;
					}
					bool flag2 = false;
					bool flag3 = false;
					Sprite val2 = null;
					if (activeCustomCampaign2.DisableDesktopLogo)
					{
						flag2 = true;
					}
					else if ((Object)(object)activeCustomCampaign2.CustomDesktopLogo != (Object)null)
					{
						val2 = activeCustomCampaign2.CustomDesktopLogo;
					}
					if (modifierDesktopSnapshot.DisableDesktopLogo.found && modifierDesktopSnapshot.DisableDesktopLogo.value.Data)
					{
						flag2 = modifierDesktopSnapshot.DisableDesktopLogo.value.Data;
					}
					else if (modifierDesktopSnapshot.CustomBackgroundLogo.found)
					{
						flag3 = true;
						val2 = modifierDesktopSnapshot.CustomBackgroundLogo.value.Data;
					}
					if (flag2 && !flag3)
					{
						CustomDesktopHelper.GetLogo().SetActive(false);
					}
					else if ((Object)(object)val2 != (Object)null)
					{
						CustomDesktopHelper.GetLogo().GetComponent<Image>().sprite = val2;
					}
					float a = 0.2627f;
					if (!activeCustomCampaign2.CustomDesktopLogoTransparency.Equals(0.2627f))
					{
						a = activeCustomCampaign2.CustomDesktopLogoTransparency;
					}
					if (modifierDesktopSnapshot.BackgroundLogoTransparency.found)
					{
						a = modifierDesktopSnapshot.BackgroundLogoTransparency.value.Data;
					}
					if (!a.Equals(0.2627f))
					{
						Color color = ((Graphic)CustomDesktopHelper.GetLogo().GetComponent<Image>()).color;
						color.a = a;
						((Graphic)CustomDesktopHelper.GetLogo().GetComponent<Image>()).color = color;
					}
					if (modifierDesktopSnapshot.VideoPlayerDesktopIsWideMode.found && modifierDesktopSnapshot.VideoPlayerDesktopIsWideMode.value.Data)
					{
						RectTransform component3 = ((Component)CustomDesktopHelper.GetMainMenuCanvas().transform.Find("VideoPopup/WindowsBar/Video")).GetComponent<RectTransform>();
						component3.offsetMax = new Vector2(0f, component3.offsetMax.y);
						component3.offsetMin = new Vector2(0f, component3.offsetMin.y);
					}
					if (modifierDesktopSnapshot.MailboxIcon.found)
					{
						CustomDesktopHelper.GetMailboxGameObject().GetComponent<Image>().sprite = modifierDesktopSnapshot.MailboxIcon.value.Data;
					}
					if (modifierDesktopSnapshot.MailboxRename.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetMailboxGameObject().transform.GetChild(0).GetChild(0)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.MailboxRename.value.Data;
					}
					if (modifierDesktopSnapshot.ApplicationMailboxTitle.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetMainMenuCanvas().transform.Find("EmailPopup").GetChild(0).GetChild(3)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.ApplicationMailboxTitle.value.Data;
					}
					if (modifierDesktopSnapshot.ApplicationMailboxIcon.found)
					{
						((Component)CustomDesktopHelper.GetMainMenuCanvas().transform.Find("EmailPopup").GetChild(0).GetChild(2)).GetComponent<Image>().sprite = modifierDesktopSnapshot.ApplicationMailboxIcon.value.Data;
					}
					if (modifierDesktopSnapshot.DisplayMailboxOnDesktop.found && !modifierDesktopSnapshot.DisplayMailboxOnDesktop.value.Data)
					{
						CustomDesktopHelper.GetMailboxGameObject().gameObject.SetActive(false);
					}
					if (modifierDesktopSnapshot.EntryBrowserIcon.found)
					{
						CustomDesktopHelper.GetEntryBrowserGameObject().GetComponent<Image>().sprite = modifierDesktopSnapshot.EntryBrowserIcon.value.Data;
					}
					if (modifierDesktopSnapshot.EntryBrowserRename.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetEntryBrowserGameObject().transform.GetChild(0).GetChild(0)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.EntryBrowserRename.value.Data;
					}
					if (modifierDesktopSnapshot.ApplicationEntryBrowserTitle.found)
					{
						((TMP_Text)((Component)((Component)GlobalVariables.entryCanvasScript).gameObject.transform.GetChild(0).GetChild(0).GetChild(2)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.ApplicationEntryBrowserTitle.value.Data;
					}
					if (modifierDesktopSnapshot.ApplicationEntryBrowserIcon.found)
					{
						((Component)((Component)GlobalVariables.entryCanvasScript).gameObject.transform.GetChild(0).GetChild(0).GetChild(1)).GetComponent<Image>().sprite = modifierDesktopSnapshot.ApplicationEntryBrowserIcon.value.Data;
					}
					if (modifierDesktopSnapshot.OptionsIcon.found)
					{
						CustomDesktopHelper.GetOptionsGameObject().GetComponent<Image>().sprite = modifierDesktopSnapshot.OptionsIcon.value.Data;
					}
					if (modifierDesktopSnapshot.OptionsRename.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetOptionsGameObject().transform.GetChild(0).GetChild(0)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.OptionsRename.value.Data;
					}
					if (modifierDesktopSnapshot.ApplicationOptionsTitle.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetMainMenuCanvas().transform.Find("OptionsPopup").GetChild(0).GetChild(3)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.ApplicationOptionsTitle.value.Data;
					}
					if (modifierDesktopSnapshot.ApplicationOptionsIcon.found)
					{
						((Component)CustomDesktopHelper.GetMainMenuCanvas().transform.Find("OptionsPopup").GetChild(0).GetChild(2)).GetComponent<Image>().sprite = modifierDesktopSnapshot.ApplicationOptionsIcon.value.Data;
					}
					if (modifierDesktopSnapshot.ArtbookIcon.found)
					{
						CustomDesktopHelper.GetArtbookGameObject().GetComponent<Image>().sprite = modifierDesktopSnapshot.ArtbookIcon.value.Data;
					}
					if (modifierDesktopSnapshot.ArtbookRename.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetArtbookGameObject().transform.GetChild(0).GetChild(0)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.ArtbookRename.value.Data;
					}
					if (modifierDesktopSnapshot.ApplicationArtbookTitle.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetMainMenuCanvas().transform.Find("ArtbookPopup").GetChild(0).GetChild(3)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.ApplicationArtbookTitle.value.Data;
					}
					if (modifierDesktopSnapshot.ApplicationArtbookIcon.found)
					{
						((Component)CustomDesktopHelper.GetMainMenuCanvas().transform.Find("ArtbookPopup").GetChild(0).GetChild(2)).GetComponent<Image>().sprite = modifierDesktopSnapshot.ApplicationArtbookIcon.value.Data;
					}
					if (modifierDesktopSnapshot.ArtbookPages.found)
					{
						ArtbookPage[] artbookPages = modifierDesktopSnapshot.ArtbookPages.value.ToArray();
						((Component)CustomDesktopHelper.GetMainMenuCanvas().transform.Find("ArtbookPopup")).GetComponent<ArtbookPopupBehavior>().artbookPages = artbookPages;
					}
					if (modifierDesktopSnapshot.ArcadeIcon.found)
					{
						CustomDesktopHelper.GetArcadeGameObject().GetComponent<Image>().sprite = modifierDesktopSnapshot.ArcadeIcon.value.Data;
					}
					if (modifierDesktopSnapshot.ArcadeRename.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetArcadeGameObject().transform.GetChild(0).GetChild(0)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.ArcadeRename.value.Data;
					}
					if (modifierDesktopSnapshot.ScorecardIcon.found)
					{
						CustomDesktopHelper.GetScorecardGameObject().GetComponent<Image>().sprite = modifierDesktopSnapshot.ScorecardIcon.value.Data;
					}
					if (modifierDesktopSnapshot.ScorecardRename.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetScorecardGameObject().transform.GetChild(0).GetChild(0)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.ScorecardRename.value.Data;
					}
					if (modifierDesktopSnapshot.ApplicationScorecardTitle.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetMainMenuCanvas().transform.Find("ScorecardPopup").GetChild(0).GetChild(3)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.ApplicationScorecardTitle.value.Data;
					}
					if (modifierDesktopSnapshot.ApplicationScorecardIcon.found)
					{
						((Component)CustomDesktopHelper.GetMainMenuCanvas().transform.Find("ScorecardPopup").GetChild(0).GetChild(2)).GetComponent<Image>().sprite = modifierDesktopSnapshot.ApplicationScorecardIcon.value.Data;
					}
					if ((Object)(object)CustomTextFileHelper.TextFileIcon == (Object)null)
					{
						CustomTextFileHelper.TextFileIcon = CustomDesktopHelper.GetCreditsGameObject().GetComponent<Image>().sprite;
					}
					if (modifierDesktopSnapshot.DesktopCredits.found)
					{
						CustomDesktopHelper.GetCreditsGameObject().GetComponent<TextFileExecutable>().myContent = modifierDesktopSnapshot.DesktopCredits.value.Data;
					}
					if (modifierDesktopSnapshot.CreditsRename.found)
					{
						((TMP_Text)((Component)CustomDesktopHelper.GetCreditsGameObject().transform.GetChild(0).GetChild(0)).GetComponent<TextMeshProUGUI>()).text = modifierDesktopSnapshot.CreditsRename.value.Data;
					}
					if (modifierDesktopSnapshot.CreditsIcon.found)
					{
						CustomDesktopHelper.GetCreditsGameObject().GetComponent<Image>().sprite = modifierDesktopSnapshot.CreditsIcon.value.Data;
					}
					if (modifierDesktopSnapshot.HideDesktopCredits.found)
					{
						CustomDesktopHelper.GetCreditsGameObject().SetActive(!modifierDesktopSnapshot.HideDesktopCredits.value.Data);
					}
					if (modifierDesktopSnapshot.HideDiscordProgram.found)
					{
						CustomDesktopHelper.GetNSEDiscordProgram().SetActive(!modifierDesktopSnapshot.HideDiscordProgram.value.Data);
					}
					if (activeCustomCampaign2.DisableAllDefaultVideos)
					{
						CustomDesktopHelper.DisableDefaultVideos();
					}
					if (activeCustomCampaign2.CustomVideos.Count > 0)
					{
						foreach (CustomVideo customVideo in activeCustomCampaign2.CustomVideos)
						{
							VideoHelper.CreateCustomVideoFileProgram(customVideo);
						}
					}
					if (activeCustomCampaign2.CustomTextProgramFiles.Count > 0)
					{
						foreach (CustomTextFile customTextProgramFile in activeCustomCampaign2.CustomTextProgramFiles)
						{
							CustomTextFileHelper.CreateCustomTextFile(customTextProgramFile);
						}
					}
					if (activeCustomCampaign2.LinkApps.Count > 0)
					{
						foreach (LinkApp linkApp in activeCustomCampaign2.LinkApps)
						{
							LinkAppHelper.CreateCustomLinkApp(linkApp);
						}
					}
				}
				if (MainClassForMonsterEntries.ShowUpdateMessage)
				{
					MainClassForMonsterEntries.ShowUpdateMessage = false;
					AsyncVersionChecker.ShowUpdateMessage();
				}
				return false;
			}

			private static IEnumerator StartupRoutine(MainMenuCanvasBehavior __instance)
			{
				while ((Object)(object)GlobalVariables.UISoundControllerScript == (Object)null)
				{
					yield return null;
				}
				if (GlobalPreferences.SkipLoadingScreen.Value)
				{
					GlobalVariables.fade.FadeOut(0.0001f);
					yield break;
				}
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign == null)
					{
						yield break;
					}
					(bool foundModifier, bool value) disableDesktopLoading = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DisableDesktopLoading);
					if (disableDesktopLoading.foundModifier && disableDesktopLoading.value)
					{
						GlobalVariables.fade.FadeOut(0.0001f);
						yield break;
					}
				}
				GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.computerStartup, (AudioSource)null);
				yield return (object)new WaitForSeconds(1.3f);
				__instance.loginText.SetActive(true);
				yield return (object)new WaitForSeconds(2f);
				GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.computerFanSpin, GlobalVariables.UISoundControllerScript.myFanSpinLoopingSource);
				__instance.loginText2.SetActive(true);
				yield return (object)new WaitForSeconds(3f);
				__instance.loginText.SetActive(false);
				__instance.loginText2.SetActive(false);
				GlobalVariables.fade.FadeOut(0.0001f);
				yield return (object)new WaitForSeconds(0.1f);
				GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.connectionSuccess, (AudioSource)null);
			}
		}

		[HarmonyPatch(typeof(DateTextController), "Start")]
		public static class StartDateTextPatch
		{
			private static readonly FieldInfo MyText = typeof(DateTextController).GetField("myText", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(DateTextController __instance)
			{
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Expected O, but got Unknown
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0196: Expected O, but got Unknown
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Expected O, but got Unknown
				LoggingHelper.DebugLog("Handling day format.");
				if (MyText == null)
				{
					LoggingHelper.ReflectionError("MyText");
					return true;
				}
				MyText.SetValue(__instance, ((Component)__instance).GetComponent<TextMeshProUGUI>());
				if (!GlobalVariables.isXmasDLC && !CustomCampaignGlobal.InCustomCampaign)
				{
					TextMeshProUGUI val = (TextMeshProUGUI)MyText.GetValue(__instance);
					string text = 4 + "/" + (23 + GlobalVariables.currentDay) + "/" + 1996;
					((TMP_Text)val).text = text;
				}
				else if (!CustomCampaignGlobal.InCustomCampaign)
				{
					TextMeshProUGUI val2 = (TextMeshProUGUI)MyText.GetValue(__instance);
					string text2 = 12 + "/" + (21 + GlobalVariables.currentDay) + "/" + 1996;
					((TMP_Text)val2).text = text2;
				}
				else
				{
					LoggingHelper.DebugLog("Handling custom day format..");
					TextMeshProUGUI val3 = (TextMeshProUGUI)MyText.GetValue(__instance);
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return false;
					}
					(bool, VariableChanged<string>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier m) => m.DateLabelOverwritten, (VariableChanged<string> vCs) => vCs.HasChanged);
					if (activeModifierValue.Item1)
					{
						((TMP_Text)val3).text = activeModifierValue.Item2.Data;
						return false;
					}
					List<int> list = new List<int> { 4, 23, 1996 };
					if (activeCustomCampaign.DesktopDateStartDay != -1)
					{
						list[0] = activeCustomCampaign.DesktopDateStartDay;
					}
					if (activeCustomCampaign.DesktopDateStartMonth != -1)
					{
						list[1] = activeCustomCampaign.DesktopDateStartMonth;
					}
					if (activeCustomCampaign.DesktopDateStartYear != -1)
					{
						list[2] = activeCustomCampaign.DesktopDateStartYear;
					}
					LoggingHelper.DebugLog($"Current day format: {list[0]} / {list[1]} / {list[2]}.");
					list = DateUtil.FixDayMonthYear(list[0] + GlobalVariables.currentDay, list[1], list[2]);
					LoggingHelper.DebugLog($"Day format after fix: {list[0]} / {list[1]} / {list[2]}.");
					string[] array = new string[5];
					int num = (activeCustomCampaign.UseEuropeDateFormat ? 2 : 0);
					int num2 = ((!activeCustomCampaign.UseEuropeDateFormat) ? 2 : 0);
					array[num] = list[1].ToString();
					array[1] = "/";
					array[num2] = list[0].ToString();
					array[3] = "/";
					array[4] = list[2].ToString();
					string text3 = string.Concat(array);
					((TMP_Text)val3).text = text3;
				}
				return false;
			}
		}
	}
	public static class CustomDesktopHelper
	{
		public static GameObject GetMainMenuCanvas()
		{
			GameObject val = GameObject.Find("MainMenuCanvas");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			LoggingHelper.ErrorLog("Failed to find MainMenuCanvas. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		private static GameObject GetDesktop()
		{
			GameObject gameObject = ((Component)GetMainMenuCanvas().transform.Find("Desktop")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find Desktop from Main Menu. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetLogo()
		{
			GameObject gameObject = ((Component)GetDesktop().transform.Find("Logo")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find Logo from Desktop. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetEmailList()
		{
			GameObject gameObject = ((Component)GetMainMenuCanvas().transform.Find("EmailPopup/EmailsScrollview").Find("Viewport").Find("Content")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find email list from Main Menu Canvas. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		private static GameObject GetWindowsBar()
		{
			GameObject gameObject = ((Component)GetDesktop().transform.Find("WindowsBar (1)")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			gameObject = ((Component)GetDesktop().transform.Find("WindowsBar")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				LoggingHelper.ErrorLog("Failed to find windows bar from Main Menu. Possibly called outside of MainMenuCanvas?");
				return null;
			}
			return gameObject;
		}

		public static GameObject GetCreditsGameObject()
		{
			GameObject gameObject = ((Component)GetLeftPrograms().transform.Find("Readme")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find credits from the program list. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetMailboxGameObject()
		{
			GameObject gameObject = ((Component)GetLeftPrograms().transform.Find("Email-Executable")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find mailbox from the program list. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetOptionsGameObject()
		{
			GameObject gameObject = ((Component)GetLeftPrograms().transform.Find("Options-Executable")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find Options from the program list. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetEntryBrowserGameObject()
		{
			GameObject gameObject = ((Component)GetLeftPrograms().transform.Find("EntryBrowser-Executable")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find EntryBrowser from the program list. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetArtbookGameObject()
		{
			GameObject gameObject = ((Component)GetLeftPrograms().transform.Find("Artbook-Executable")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find Artbook from the program list. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetArcadeGameObject()
		{
			GameObject gameObject = ((Component)GetLeftPrograms().transform.Find("Arcade-Executable")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find Arcade from the program list. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetScorecardGameObject()
		{
			GameObject gameObject = ((Component)GetLeftPrograms().transform.Find("Scorecard")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find Scorecard from the program list. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetUsernameObject()
		{
			GameObject gameObject = ((Component)GetWindowsBar().transform.Find("Username")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find username from window bar. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetCallSkipButton()
		{
			GameObject gameObject = GameObject.Find("MainCanvas/Panel/CallWindow/LargeCallerPortrait/CallSkipButton").gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find next caller button. Possibly called outside of MainCanvas?");
			return null;
		}

		public static GameObject GetLeftPrograms()
		{
			GameObject gameObject = ((Component)GetDesktop().transform.Find("Programs")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find left sided Programs from Desktop. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetRightPrograms()
		{
			GameObject gameObject = ((Component)GetDesktop().transform.Find("RightHandPrograms")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find right sided Programs from Desktop. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetWinterDlcProgram()
		{
			GameObject gameObject = ((Component)GetLeftPrograms().transform.Find("DLC-Executable")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				LoggingHelper.DebugLog("Found the DLC Icon.");
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find the winter DLC program. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static void DisableDefaultVideos()
		{
			((Component)GetLeftPrograms().transform.Find("TrailerFile")).gameObject.SetActive(false);
			((Component)GetLeftPrograms().transform.Find("RealEstateVideo")).gameObject.SetActive(false);
			((Component)GetLeftPrograms().transform.Find("ScienceVideo")).gameObject.SetActive(false);
			((Component)GetLeftPrograms().transform.Find("HikingVideo")).gameObject.SetActive(false);
		}

		public static void DisableWinterDlcProgram()
		{
			GetWinterDlcProgram().SetActive(false);
		}

		public static void EnableWinterDlcProgram()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!SteamManager.Initialized || !SteamApps.BIsDlcInstalled(new AppId_t(2914730u)))
			{
				LoggingHelper.DebugLog("DLC is not installed. Not activating DLC.");
				DisableWinterDlcProgram();
			}
			else
			{
				LoggingHelper.DebugLog("DLC is installed. Activating DLC!");
				GetWinterDlcProgram().SetActive(true);
			}
		}

		public static GameObject GetMainGameProgram()
		{
			GameObject gameObject = ((Component)GetLeftPrograms().transform.Find("HSH-Executable")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find the main game program. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static GameObject GetNSEDiscordProgram()
		{
			GameObject gameObject = ((Component)GetRightPrograms().transform.Find("Discord-Executable")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				return gameObject;
			}
			LoggingHelper.ErrorLog("Failed to find the discord program. Possibly called outside of MainMenuCanvas?");
			return null;
		}
	}
}
namespace NewSafetyHelp.CustomDesktop.Utils
{
	public static class CustomCampaignProgramHelper
	{
		public static void CreateCustomProgramIcon(string customProgramName, string customCampaignName, Sprite customIcon = null)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(CustomDesktopHelper.GetWinterDlcProgram(), CustomDesktopHelper.GetLeftPrograms().transform);
			Object.Destroy((Object)(object)val.GetComponent<HSHExecutableBehavior>());
			TextMeshProUGUI component = ((Component)val.transform.Find("TextBackground").Find("ExecutableName")).GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = customProgramName;
			Image component2 = val.GetComponent<Image>();
			if ((Object)(object)customIcon != (Object)null)
			{
				component2.sprite = customIcon;
			}
			((Graphic)component2).color = Color.white;
			Button component3 = val.GetComponent<Button>();
			DoubleClickButton doubleClickButton = val.AddComponent<DoubleClickButton>();
			((UnityEventBase)component3.onClick).RemoveAllListeners();
			((UnityEvent)component3.onClick).AddListener((UnityAction)delegate
			{
				doubleClickButton.DoubleClickCustomCampaign(customCampaignName);
			});
			((Object)val).name = customProgramName;
			val.SetActive(true);
		}

		public static void CreateBackToMainGameButton()
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(CustomDesktopHelper.GetNSEDiscordProgram(), CustomDesktopHelper.GetRightPrograms().transform);
			Object.Destroy((Object)(object)val.GetComponent<LinkExecutable>());
			((TMP_Text)((Component)val.transform.Find("TextBackground").Find("ExecutableName")).GetComponent<TextMeshProUGUI>()).text = "Back to Main Game.";
			val.GetComponent<Image>().sprite = CustomDesktopHelper.GetMainGameProgram().GetComponent<Image>().sprite;
			((Graphic)val.GetComponent<Image>()).color = Color.white;
			Button component = val.GetComponent<Button>();
			DoubleClickButton doubleClickButton = val.AddComponent<DoubleClickButton>();
			((UnityEventBase)component.onClick).RemoveAllListeners();
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				doubleClickButton.DoubleClickBackToMainGameAlsoLoad();
			});
			((Object)val).name = "BackToMainGameButton";
		}
	}
	public static class CustomCampaignSceneSwitcher
	{
		public static IEnumerator ChangeToCustomCampaignSettings(string customCampaignName, bool inHotReload)
		{
			LoggingHelper.InfoLog("Changing to custom campaign: " + customCampaignName + ".", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Green);
			CustomCampaignGlobal.ActivateCustomCampaign(customCampaignName);
			CustomCampaignSaving.LoadFromFileCustomCampaignInfo();
			CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (customCampaign != null && customCampaign.FadeInCustomCampaign.HasChanged && customCampaign.FadeInCustomCampaign.Data && !inHotReload)
			{
				GlobalVariables.fade.FadeIn(0.5f, (string)null);
				yield return (object)new WaitForSeconds(1f);
			}
			if (customCampaign != null && customCampaign.Skip3DComputerScreenForCustomCampaign.HasChanged && !customCampaign.Skip3DComputerScreenForCustomCampaign.Data)
			{
				SceneManager.LoadScene("Computer3DScene");
			}
			else
			{
				SceneManager.LoadScene("MainMenuScene");
			}
			LoggingHelper.DebugLog("Finished changing into custom campaign.");
		}

		public static void BackToMainGame(bool alsoLoadMainMenu = true)
		{
			LoggingHelper.InfoLog("Going back to the main game.", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Green);
			CustomCampaignSaving.SaveCustomCampaignInfo();
			CustomCampaignGlobal.DeactivateCustomCampaign();
			GlobalVariables.saveManagerScript.Load();
			if (alsoLoadMainMenu)
			{
				SceneManager.LoadScene("MainMenuScene");
			}
		}

		public static void SaveAndLoadDesktopScene(bool alsoLoadMainMenu = true)
		{
			CustomCampaignSaving.SaveCustomCampaignInfo();
			if (alsoLoadMainMenu)
			{
				SceneManager.LoadScene("MainMenuScene");
			}
		}
	}
	public static class DateUtil
	{
		public static List<int> NextDay(int day, int month, int year)
		{
			day++;
			while (true)
			{
				int num = DaysInMonth(month, year);
				if (day <= num)
				{
					break;
				}
				day -= num;
				month++;
				if (month > 12)
				{
					month = 1;
					year++;
				}
			}
			return new List<int> { day, month, year };
		}

		public static List<int> FixDayMonthYear(int day, int month, int year)
		{
			while (true)
			{
				int num = DaysInMonth(month, year);
				if (day <= num)
				{
					break;
				}
				day -= num;
				month++;
				if (month > 12)
				{
					month = 1;
					year++;
				}
			}
			return new List<int> { day, month, year };
		}

		private static int DaysInMonth(int month, int year)
		{
			switch (month)
			{
			case 0:
				return DaysInMonth(1, year);
			case 1:
			case 3:
			case 5:
			case 7:
			case 8:
			case 10:
			case 12:
				return 31;
			case 4:
			case 6:
			case 9:
			case 11:
				return 30;
			case 2:
				if (IsLeapYear(year))
				{
					return 29;
				}
				return 28;
			default:
				return DaysInMonth(1, year);
			}
		}

		private static bool IsLeapYear(int year)
		{
			return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
		}
	}
	public static class EmailHelper
	{
		private static GameObject animatedEmail;

		private static Button imageButtonComponent;

		private static Button animatedImageButtonComponent;

		private static SwapCursorHoverDisplayer imageSwapCursorHoverDisplayer;

		private static SwapCursorHoverDisplayer animatedImageSwapCursorHoverDisplayer;

		public static void SetAnimatedEmail(GameObject email)
		{
			animatedEmail = email;
		}

		public static void CreateClickableEmail(bool enableClickingImage = false, bool enableClickingAnimatedImage = false)
		{
			GameObject emailImageGameObject = GetEmailImageGameObject();
			SwapCursorHoverDisplayer closeButtonOnHoverScript = GetCloseButtonOnHoverScript();
			if (!((Object)(object)emailImageGameObject == (Object)null) && !((Object)(object)animatedEmail == (Object)null) && !((Object)(object)closeButtonOnHoverScript == (Object)null))
			{
				((Graphic)GetEmailLoadingHider().GetComponent<Image>()).raycastTarget = false;
				Texture2D defaultCursor = closeButtonOnHoverScript.defaultCursor;
				Texture2D hoverCursor = closeButtonOnHoverScript.hoverCursor;
				imageButtonComponent = emailImageGameObject.AddComponent<Button>();
				imageSwapCursorHoverDisplayer = emailImageGameObject.AddComponent<SwapCursorHoverDisplayer>();
				((Behaviour)imageSwapCursorHoverDisplayer).enabled = false;
				imageSwapCursorHoverDisplayer.defaultCursor = defaultCursor;
				imageSwapCursorHoverDisplayer.hoverCursor = hoverCursor;
				animatedImageButtonComponent = animatedEmail.AddComponent<Button>();
				animatedImageSwapCursorHoverDisplayer = animatedEmail.AddComponent<SwapCursorHoverDisplayer>();
				((Behaviour)animatedImageSwapCursorHoverDisplayer).enabled = false;
				animatedImageSwapCursorHoverDisplayer.defaultCursor = defaultCursor;
				animatedImageSwapCursorHoverDisplayer.hoverCursor = hoverCursor;
				if (enableClickingImage)
				{
					((Graphic)emailImageGameObject.GetComponent<Image>()).raycastTarget = true;
					((Behaviour)animatedImageSwapCursorHoverDisplayer).enabled = true;
				}
				else
				{
					((Graphic)emailImageGameObject.GetComponent<Image>()).raycastTarget = false;
					((Behaviour)animatedImageSwapCursorHoverDisplayer).enabled = false;
				}
				if (enableClickingAnimatedImage)
				{
					((Graphic)animatedEmail.GetComponent<RawImage>()).raycastTarget = true;
					((Behaviour)imageSwapCursorHoverDisplayer).enabled = true;
				}
				else
				{
					((Graphic)animatedEmail.GetComponent<RawImage>()).raycastTarget = false;
					((Behaviour)imageSwapCursorHoverDisplayer).enabled = false;
				}
			}
		}

		public static void SetLoopInAnimatedImage(bool shouldLoop)
		{
			if (!((Object)(object)animatedEmail == (Object)null))
			{
				if (shouldLoop)
				{
					AnimatedImageHelper.EnableVideoLoop(animatedEmail);
				}
				else
				{
					AnimatedImageHelper.DisableVideoLoop(animatedEmail);
				}
			}
		}

		public static void SetClickUrlToOpen(bool hasNoURL, Uri urlToOpen, bool hasAnimatedVideo)
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			if ((Object)(object)imageButtonComponent == (Object)null || (Object)(object)animatedImageButtonComponent == (Object)null)
			{
				return;
			}
			((UnityEventBase)imageButtonComponent.onClick).RemoveAllListeners();
			((UnityEventBase)animatedImageButtonComponent.onClick).RemoveAllListeners();
			GameObject emailImageGameObject = GetEmailImageGameObject();
			if ((Object)(object)emailImageGameObject == (Object)null || (Object)(object)animatedEmail == (Object)null)
			{
				DisableEmailImageCursorHover();
				return;
			}
			if (!hasNoURL)
			{
				((Graphic)emailImageGameObject.GetComponent<Image>()).raycastTarget = true;
				((Graphic)animatedEmail.GetComponent<RawImage>()).raycastTarget = true;
			}
			else
			{
				((Graphic)emailImageGameObject.GetComponent<Image>()).raycastTarget = false;
				((Graphic)animatedEmail.GetComponent<RawImage>()).raycastTarget = false;
			}
			if (hasNoURL)
			{
				DisableEmailImageCursorHover();
			}
			else if (urlToOpen != null && URLVerification.IsURLAndNotUnsafe(urlToOpen))
			{
				((UnityEvent)imageButtonComponent.onClick).AddListener((UnityAction)delegate
				{
					URLVerification.OpenURIInBrowser(urlToOpen);
				});
				((UnityEvent)animatedImageButtonComponent.onClick).AddListener((UnityAction)delegate
				{
					URLVerification.OpenURIInBrowser(urlToOpen);
				});
				SetWhichImageGetsTheCursorHover(hasAnimatedVideo);
			}
			else
			{
				DisableEmailImageCursorHover();
			}
		}

		private static void SetWhichImageGetsTheCursorHover(bool showForAnimatedVideo = false)
		{
			if (showForAnimatedVideo)
			{
				((Behaviour)imageSwapCursorHoverDisplayer).enabled = false;
				((Behaviour)animatedImageSwapCursorHoverDisplayer).enabled = true;
			}
			else
			{
				((Behaviour)imageSwapCursorHoverDisplayer).enabled = true;
				((Behaviour)animatedImageSwapCursorHoverDisplayer).enabled = false;
			}
		}

		public static void DisableEmailImageCursorHover()
		{
			((Behaviour)imageSwapCursorHoverDisplayer).enabled = false;
			((Behaviour)animatedImageSwapCursorHoverDisplayer).enabled = false;
		}

		public static GameObject GetEmailImageGameObject()
		{
			return ((Component)((Component)((Component)((Component)((Component)((Component)GameObject.Find("MainMenuCanvas").transform.Find("EmailPopup")).transform.Find("EmailContentScrollview")).transform.Find("Viewport")).transform.Find("Content")).transform.Find("EmailImageBorder")).transform.Find("EmailImage")).gameObject;
		}

		public static SwapCursorHoverDisplayer GetCloseButtonOnHoverScript()
		{
			return ((Component)GameObject.Find("MainMenuCanvas").transform.Find("EmailPopup").Find("WindowsBar").Find("CloseButton")).GetComponent<SwapCursorHoverDisplayer>();
		}

		private static GameObject GetEmailLoadingHider()
		{
			return ((Component)((Component)((Component)((Component)GameObject.Find("MainMenuCanvas").transform.Find("EmailPopup")).transform.Find("EmailContentScrollview")).transform.Find("Viewport")).transform.Find("LoadingHider")).gameObject;
		}

		public static void SetVideoUrlEmail(string url)
		{
			UpdateVisibilityOfNormalEmailPortrait();
			AnimatedImageHelper.SetVideoUrl(url, animatedEmail);
		}

		public static void RestoreEmailPortrait()
		{
			UpdateVisibilityOfNormalEmailPortrait(showImage: true);
			VideoPlayer component = animatedEmail.GetComponent<VideoPlayer>();
			component.Stop();
			if ((Object)(object)component.targetTexture != (Object)null)
			{
				component.targetTexture.Release();
				Object.Destroy((Object)(object)component.targetTexture);
			}
			animatedEmail.SetActive(false);
		}

		private static void UpdateVisibilityOfNormalEmailPortrait(bool showImage = false)
		{
			((Behaviour)GetEmailImageGameObject().GetComponent<Image>()).enabled = showImage;
		}

		public static Email CreateEmail(CustomEmail emailToCreate)
		{
			GameObject gameObject = ((Component)CustomDesktopHelper.GetEmailList().transform.Find("EmailListing (14)")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent);
				EmailListingBehavior component = val.GetComponent<EmailListingBehavior>();
				Email result = (component.myEmail = ScriptableObject.CreateInstance<Email>());
				component.mySubjectText = ((Component)val.transform.Find("SubjectText")).GetComponent<TextMeshProUGUI>();
				component.mySenderText = ((Component)val.transform.Find("FromText")).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component == (Object)null)
				{
					LoggingHelper.ErrorLog("Failed to find email listing behavior for EmailListing.");
					Object.Destroy((Object)(object)gameObject);
					return null;
				}
				if (emailToCreate.EmailSubject != "")
				{
					((Object)val).name = emailToCreate.EmailSubject.Replace("EmailListing", "");
					((Object)component.myEmail).name = emailToCreate.EmailSubject.Replace("EmailListing", "");
					((TMP_Text)component.mySubjectText).text = emailToCreate.EmailSubject;
					component.myEmail.subjectLine = emailToCreate.EmailSubject;
				}
				else
				{
					((Object)val).name = "UnnamedEmail";
					((Object)component.myEmail).name = "UnnamedEmail";
					((TMP_Text)component.mySubjectText).text = "UnnamedEmail";
					component.myEmail.subjectLine = "UnnamedEmail";
				}
				if (emailToCreate.SenderName != "")
				{
					((TMP_Text)component.mySenderText).text = emailToCreate.SenderName;
					component.myEmail.sender = emailToCreate.SenderName;
				}
				else
				{
					((TMP_Text)component.mySenderText).text = "SenderNameNotProvided";
					component.myEmail.sender = "SenderNameNotProvided";
				}
				component.myEmail.emailBody = emailToCreate.EmailBody;
				component.myEmail.imageAttachment = emailToCreate.EmailImage;
				OnDayUnlock component2 = val.GetComponent<OnDayUnlock>();
				component2.unlockDay = emailToCreate.UnlockDay;
				if (emailToCreate.UseOldAccuracyChecks)
				{
					component2.scoreThresholdToUnlock = emailToCreate.UnlockThreshold;
				}
				else
				{
					component2.scoreThresholdToUnlock = 2f;
				}
				FieldInfo field = typeof(EmailListingBehavior).GetField("hasClicked", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				if (field == null)
				{
					LoggingHelper.WarningLog("HasClicked Field could not be found (null).");
				}
				else
				{
					field.SetValue(component, false);
				}
				return result;
			}
			LoggingHelper.ErrorLog("Failed to find email to copy from in the Email List. Possibly called outside of MainMenuCanvas?");
			return null;
		}

		public static void RemoveMainGameEmails()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			GameObject emailList = CustomDesktopHelper.GetEmailList();
			if ((Object)(object)emailList != (Object)null)
			{
				foreach (Transform item in emailList.transform)
				{
					Transform val = item;
					if (((Object)((Component)val).gameObject).name.Contains("EmailListing"))
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
				}
				return;
			}
			LoggingHelper.ErrorLog("Failed to find email list from Main Menu Canvas. Possibly called outside of MainMenuCanvas?");
		}
	}
	public static class ThemeProgramHelper
	{
		public static void DisableThemeDropdownDesktop()
		{
			GameObject gameObject = ((Component)((Component)((Component)((Component)((Component)GameObject.Find("MainMenuCanvas").transform.Find("OptionsPopup")).transform.Find("OptionsScrollRect")).transform.Find("Viewport")).transform.Find("Content")).transform.Find("VideoOptions")).gameObject;
			if (!((Object)(object)gameObject == (Object)null))
			{
				GameObject gameObject2 = ((Component)gameObject.transform.Find("ColorPaletteHeader")).gameObject;
				GameObject gameObject3 = ((Component)gameObject.transform.Find("ColorDropdown")).gameObject;
				if ((Object)(object)gameObject2 != (Object)null)
				{
					gameObject2.SetActive(false);
				}
				if ((Object)(object)gameObject3 != (Object)null)
				{
					gameObject3.SetActive(false);
				}
			}
		}

		public static void DisableThemeDropdownInGame()
		{
			GameObject val = GameObject.Find("MainCanvas");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameObject gameObject = ((Component)val.transform.Find("OptionsPopup")).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			GameObject gameObject2 = ((Component)gameObject.transform.Find("OptionsScrollRect")).gameObject;
			if ((Object)(object)gameObject2 == (Object)null)
			{
				return;
			}
			GameObject gameObject3 = ((Component)gameObject2.transform.Find("Viewport")).gameObject;
			if ((Object)(object)gameObject3 == (Object)null)
			{
				return;
			}
			GameObject gameObject4 = ((Component)gameObject3.transform.Find("Content")).gameObject;
			if ((Object)(object)gameObject4 == (Object)null)
			{
				return;
			}
			GameObject gameObject5 = ((Component)gameObject4.transform.Find("VideoOptions")).gameObject;
			if (!((Object)(object)gameObject5 == (Object)null))
			{
				GameObject gameObject6 = ((Component)gameObject5.transform.Find("ColorPaletteHeader")).gameObject;
				GameObject gameObject7 = ((Component)gameObject5.transform.Find("ColorDropdown")).gameObject;
				if ((Object)(object)gameObject6 != (Object)null)
				{
					gameObject6.SetActive(false);
				}
				if ((Object)(object)gameObject7 != (Object)null)
				{
					gameObject7.SetActive(false);
				}
			}
		}
	}
}
namespace NewSafetyHelp.CustomDesktop.Programs
{
	public static class ScorecardPatches
	{
		[HarmonyPatch(typeof(ScorecardBehavior), "PopulateList")]
		public static class ScorecardPatch
		{
			private static bool Prefix(ScorecardBehavior __instance)
			{
				Type typeFromHandle = typeof(ScorecardBehavior);
				MethodInfo method = typeFromHandle.GetMethod("ClearList", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null)
				{
					LoggingHelper.ErrorLog("clearListMethod is null!");
					return true;
				}
				method.Invoke(__instance, new object[0]);
				Object.Instantiate<GameObject>(__instance.dayListing, __instance.contentHolder);
				int num = 1;
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					Caller[] callers = GlobalVariables.callerControllerScript.callers;
					foreach (Caller val in callers)
					{
						if (val.callerProfile.increaseTier)
						{
							num++;
							((TMP_Text)Object.Instantiate<GameObject>(__instance.dayListing, __instance.contentHolder).GetComponentInChildren<TextMeshProUGUI>()).text = "Day " + num;
						}
						else if ((Object)(object)val.callerProfile.callerMonster != (Object)null)
						{
							GameObject val2 = Object.Instantiate<GameObject>(__instance.callerListing, __instance.contentHolder);
							((TMP_Text)val2.GetComponentInChildren<TextMeshProUGUI>()).text = val.callerProfile.callerName;
							val2.GetComponentInChildren<Toggle>().isOn = val.answeredCorrectly;
						}
					}
				}
				else
				{
					int num2 = 0;
					Caller[] callers2 = GlobalVariables.callerControllerScript.callers;
					foreach (Caller val3 in callers2)
					{
						if (val3 == null)
						{
							LoggingHelper.WarningLog("There seems to be an empty custom caller." + $" Possible missing caller? (Index {num2})");
							continue;
						}
						CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(num2);
						if (customCallerFromActiveCampaign == null)
						{
							LoggingHelper.WarningLog("There seems to be an empty custom caller." + $" Possible missing caller? (Index {num2})");
							continue;
						}
						LoggingHelper.DebugLog($"Adding: {customCallerFromActiveCampaign.CallerName}. (Info: {val3.answeredCorrectly})");
						if (customCallerFromActiveCampaign.LastDayCaller)
						{
							if ((Object)(object)val3.callerProfile.callerMonster != (Object)null)
							{
								GameObject val4 = Object.Instantiate<GameObject>(__instance.callerListing, __instance.contentHolder);
								((TMP_Text)val4.GetComponentInChildren<TextMeshProUGUI>()).text = val3.callerProfile.callerName;
								val4.GetComponentInChildren<Toggle>().isOn = val3.answeredCorrectly;
							}
							num++;
							if (num2 + 1 != GlobalVariables.callerControllerScript.callers.Length)
							{
								((TMP_Text)Object.Instantiate<GameObject>(__instance.dayListing, __instance.contentHolder).GetComponentInChildren<TextMeshProUGUI>()).text = "Day " + num;
							}
							LoggingHelper.DebugLog("Scorecard: Caller is last day caller.");
						}
						else if ((Object)(object)val3.callerProfile.callerMonster != (Object)null)
						{
							GameObject val5 = Object.Instantiate<GameObject>(__instance.callerListing, __instance.contentHolder);
							((TMP_Text)val5.GetComponentInChildren<TextMeshProUGUI>()).text = val3.callerProfile.callerName;
							val5.GetComponentInChildren<Toggle>().isOn = val3.answeredCorrectly;
						}
						num2++;
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(ScorecardBehavior), "LoadCallerAnswers")]
		public static class LoadCallerAnswersPatch
		{
			private static bool Prefix()
			{
				if (GlobalVariables.saveManagerScript.savedCallerCorrectAnswers.Length != GlobalVariables.callerControllerScript.callers.Length)
				{
					return false;
				}
				for (int i = 0; i < GlobalVariables.callerControllerScript.callers.Length; i++)
				{
					if (GlobalVariables.callerControllerScript.callers[i] != null)
					{
						GlobalVariables.callerControllerScript.callers[i].answeredCorrectly = GlobalVariables.saveManagerScript.savedCallerCorrectAnswers[i];
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(ScorecardBehavior), "OnEnable")]
		public static class OnEnablePatch
		{
			private static void Prefix(ScorecardBehavior __instance)
			{
				GameObject gameObject = ((Component)((Component)__instance).transform).gameObject;
				GameObject gameObject2 = ((Component)gameObject.transform.Find("WindowsBar").Find("CloseButton")).gameObject;
				if (gameObject2.GetComponents<Button>().Length >= 2)
				{
					Object.Destroy((Object)(object)gameObject2.GetComponent<Button>());
				}
			}
		}
	}
}
namespace NewSafetyHelp.CustomDesktop.CustomDoubleClickButton
{
	public class DoubleClickButton : MonoBehaviour
	{
		private float lastClickTime;

		private const float DoubleClickThreshold = 0.3f;

		public void DoubleClickCustomCampaign(string customCampaignName)
		{
			float num = Time.time - lastClickTime;
			if (num <= 0.3f)
			{
				MelonCoroutines.Start(CustomCampaignSceneSwitcher.ChangeToCustomCampaignSettings(customCampaignName, inHotReload: false));
			}
			lastClickTime = Time.time;
		}

		public void DoubleClickBackToMainGameAlsoLoad()
		{
			float num = Time.time - lastClickTime;
			if (num <= 0.3f)
			{
				CustomCampaignSceneSwitcher.BackToMainGame();
			}
			lastClickTime = Time.time;
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem
{
	public static class CustomCampaignGlobal
	{
		public static readonly List<CustomCampaign> CustomCampaignsAvailable = new List<CustomCampaign>();

		private static CustomCampaign currentCustomCampaign;

		public static bool InCustomCampaign => currentCustomCampaign != null;

		public static void ActivateCustomCampaign(string customCampaignName)
		{
			currentCustomCampaign = CustomCampaignsAvailable.Find((CustomCampaign customCampaign) => customCampaign.CampaignName == customCampaignName);
		}

		public static void DeactivateCustomCampaign()
		{
			currentCustomCampaign = null;
		}

		public static CustomCampaign GetActiveCustomCampaign()
		{
			if (currentCustomCampaign == null)
			{
				LoggingHelper.CampaignNullError();
			}
			return currentCustomCampaign;
		}

		public static CustomCampaign GetNamedCustomCampaign(string customCampaignName)
		{
			return CustomCampaignsAvailable.Find((CustomCampaign customCampaignSearch) => customCampaignSearch.CampaignName == customCampaignName);
		}

		[CanBeNull]
		public static CustomCCaller GetCustomCallerFromActiveCampaign(int orderID)
		{
			return GetActiveCustomCampaign()?.CustomCallersInCampaign.Find((CustomCCaller customCaller) => customCaller.OrderInCampaign == orderID);
		}

		[CanBeNull]
		public static CustomMusic GetCustomMusicFromActiveCampaign(RichAudioClip musicToFind)
		{
			return GetActiveCustomCampaign()?.CustomMusic.Find((CustomMusic customMusic) => (Object)(object)customMusic.MusicClip == (Object)(object)musicToFind);
		}

		[CanBeNull]
		public static CustomVideo GetCustomVideoFromActiveCampaign(GameObject videoGameObject)
		{
			return GetActiveCustomCampaign()?.CustomVideos.Find((CustomVideo customVideo) => (Object)(object)customVideo.ReferenceToCreatedVideo == (Object)(object)videoGameObject);
		}

		[CanBeNull]
		public static CustomEmail GetCustomEmailFromActiveCampaign(Email emailToFind)
		{
			return GetActiveCustomCampaign()?.Emails.Find((CustomEmail customEmail) => (Object)(object)customEmail.ReferenceToEmailObject == (Object)(object)emailToFind);
		}

		[CanBeNull]
		public static LinkApp GetLinkAppFromActiveCampaign(GameObject linkAppGameObject)
		{
			return GetActiveCustomCampaign()?.LinkApps.Find((LinkApp linkApp) => (Object)(object)linkApp.GameObjectReference == (Object)(object)linkAppGameObject);
		}

		public static EntryMetadata GetEntryFromActiveCampaign(string entryName)
		{
			return GetActiveCustomCampaign()?.EntriesOnlyInCampaign.Find((EntryMetadata customEntry) => customEntry.Name == entryName);
		}

		private static int GetThemeID(CustomTheme theme, bool removeDefaultThemes)
		{
			CustomCampaign activeCustomCampaign = GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				LoggingHelper.CampaignNullError();
				return -1;
			}
			if (activeCustomCampaign.CustomThemesGeneral != null)
			{
				int num = activeCustomCampaign.CustomThemesGeneral.IndexOf(theme);
				if (num != -1)
				{
					if (removeDefaultThemes)
					{
						return num;
					}
					return num + 4;
				}
			}
			if (activeCustomCampaign.CustomThemesDays != null)
			{
				int num2 = activeCustomCampaign.CustomThemesDays.IndexOf(theme);
				if (num2 != -1)
				{
					if (activeCustomCampaign.CustomThemesGeneral != null)
					{
						num2 += activeCustomCampaign.CustomThemesGeneral.Count;
					}
					if (removeDefaultThemes)
					{
						return num2;
					}
					return num2 + 4;
				}
			}
			return -1;
		}

		[CanBeNull]
		public static CustomTheme GetThemeFromID(int themeID, bool removeDefaultThemes)
		{
			CustomCampaign activeCustomCampaign = GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return null;
			}
			int num = 0;
			if (removeDefaultThemes)
			{
				if (activeCustomCampaign.CustomThemesGeneral != null && activeCustomCampaign.CustomThemesGeneral.Count > 0)
				{
					foreach (CustomTheme item in activeCustomCampaign.CustomThemesGeneral)
					{
						num++;
						if (item != null && num == themeID)
						{
							return item;
						}
					}
				}
				if (activeCustomCampaign.CustomThemesDays != null && activeCustomCampaign.CustomThemesDays.Count > 0)
				{
					foreach (CustomTheme customThemesDay in activeCustomCampaign.CustomThemesDays)
					{
						num++;
						if (customThemesDay != null && num == themeID)
						{
							return customThemesDay;
						}
					}
				}
				return null;
			}
			if (themeID <= 3)
			{
				return null;
			}
			num = 3;
			if (activeCustomCampaign.CustomThemesGeneral != null && activeCustomCampaign.CustomThemesGeneral.Count > 0)
			{
				foreach (CustomTheme item2 in activeCustomCampaign.CustomThemesGeneral)
				{
					num++;
					if (item2 != null && num == themeID)
					{
						return item2;
					}
				}
			}
			if (activeCustomCampaign.CustomThemesDays != null && activeCustomCampaign.CustomThemesDays.Count > 0)
			{
				foreach (CustomTheme customThemesDay2 in activeCustomCampaign.CustomThemesDays)
				{
					num++;
					if (customThemesDay2 != null && num == themeID)
					{
						return customThemesDay2;
					}
				}
			}
			return null;
		}

		public static int GetThemeIDFromName(string themeName, bool removeDefaultThemes)
		{
			CustomCampaign activeCustomCampaign = GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return -1;
			}
			int num = -1;
			if (removeDefaultThemes)
			{
				if (activeCustomCampaign.CustomThemesGeneral != null && activeCustomCampaign.CustomThemesGeneral.Count > 0)
				{
					foreach (CustomTheme item in activeCustomCampaign.CustomThemesGeneral)
					{
						num++;
						if (item != null && item.ThemeName.Equals(themeName, StringComparison.OrdinalIgnoreCase))
						{
							return num;
						}
					}
				}
				if (activeCustomCampaign.CustomThemesDays != null && activeCustomCampaign.CustomThemesDays.Count > 0)
				{
					foreach (CustomTheme customThemesDay in activeCustomCampaign.CustomThemesDays)
					{
						num++;
						if (customThemesDay != null && customThemesDay.ThemeName.Equals(themeName, StringComparison.OrdinalIgnoreCase))
						{
							return num;
						}
					}
				}
				return -1;
			}
			num = 3;
			if (activeCustomCampaign.CustomThemesGeneral != null && activeCustomCampaign.CustomThemesGeneral.Count > 0)
			{
				foreach (CustomTheme item2 in activeCustomCampaign.CustomThemesGeneral)
				{
					num++;
					if (item2 != null && item2.ThemeName.Equals(themeName, StringComparison.OrdinalIgnoreCase))
					{
						return num;
					}
				}
			}
			if (activeCustomCampaign.CustomThemesDays != null && activeCustomCampaign.CustomThemesDays.Count > 0)
			{
				foreach (CustomTheme customThemesDay2 in activeCustomCampaign.CustomThemesDays)
				{
					num++;
					if (customThemesDay2 != null && customThemesDay2.ThemeName.Equals(themeName, StringComparison.OrdinalIgnoreCase))
					{
						return num;
					}
				}
			}
			return -1;
		}

		public static int CheckIfConditionalTheme(bool removeDefaultThemes)
		{
			CustomCampaign activeCustomCampaign = GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				LoggingHelper.CampaignNullError();
				return -1;
			}
			bool isCustomTheme = false;
			CustomTheme activeTheme = GetActiveTheme(ref isCustomTheme, removeDefaultThemes);
			if (activeTheme == null)
			{
				return -1;
			}
			if (activeCustomCampaign.CustomThemesDays != null && activeCustomCampaign.CustomThemesDays.Count > 0)
			{
				foreach (CustomTheme customThemesDay in activeCustomCampaign.CustomThemesDays)
				{
					if (customThemesDay != null && customThemesDay.AttachedToTheme.Equals(activeTheme.ThemeName) && customThemesDay.UnlockDays.Contains(GlobalVariables.currentDay))
					{
						int themeID = GetThemeID(customThemesDay, removeDefaultThemes);
						if (themeID >= 0)
						{
							return themeID;
						}
					}
				}
			}
			return -1;
		}

		[CanBeNull]
		public static CustomTheme GetActiveTheme(ref bool isCustomTheme, bool removeDefaultThemes)
		{
			CustomCampaign activeCustomCampaign = GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return null;
			}
			if (removeDefaultThemes)
			{
				int activeTheme = activeCustomCampaign.ActiveTheme;
				if (activeTheme >= 0 && activeCustomCampaign.CustomThemesGeneral != null && activeTheme < activeCustomCampaign.CustomThemesGeneral.Count)
				{
					isCustomTheme = true;
					return activeCustomCampaign.CustomThemesGeneral[activeTheme];
				}
				int num = activeCustomCampaign.ActiveTheme;
				if (activeCustomCampaign.CustomThemesGeneral != null)
				{
					num -= activeCustomCampaign.CustomThemesGeneral.Count;
				}
				if (num >= 0 && activeCustomCampaign.CustomThemesDays != null && num < activeCustomCampaign.CustomThemesDays.Count)
				{
					isCustomTheme = true;
					return activeCustomCampaign.CustomThemesDays[num];
				}
				return null;
			}
			isCustomTheme = false;
			if (activeCustomCampaign.ActiveTheme <= 3)
			{
				return null;
			}
			int num2 = activeCustomCampaign.ActiveTheme - 4;
			if (num2 >= 0 && activeCustomCampaign.CustomThemesGeneral != null && num2 < activeCustomCampaign.CustomThemesGeneral.Count)
			{
				isCustomTheme = true;
				return activeCustomCampaign.CustomThemesGeneral[num2];
			}
			int num3 = activeCustomCampaign.ActiveTheme - 4;
			if (activeCustomCampaign.CustomThemesGeneral != null)
			{
				num3 -= activeCustomCampaign.CustomThemesGeneral.Count;
			}
			if (num3 >= 0 && activeCustomCampaign.CustomThemesDays != null && num3 < activeCustomCampaign.CustomThemesDays.Count)
			{
				isCustomTheme = true;
				return activeCustomCampaign.CustomThemesDays[num3];
			}
			return null;
		}

		public static DesktopModifierSnapshot GetModifierDesktopSnapshot()
		{
			CustomCampaign activeCustomCampaign = GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return null;
			}
			DesktopModifierSnapshot desktopModifierSnapshot = new DesktopModifierSnapshot();
			foreach (ModifierSource modifierSource in activeCustomCampaign.ModifierSources)
			{
				if (modifierSource == null || modifierSource.Modifiers == null || modifierSource.Modifiers.Count == 0 || !modifierSource.SourceCondition(activeCustomCampaign))
				{
					continue;
				}
				foreach (CustomModifier modifier in modifierSource.Modifiers)
				{
					if (modifier.UsernameText.HasChanged)
					{
						desktopModifierSnapshot.UsernameText = (found: true, value: modifier.UsernameText);
					}
					if (modifier.RenameMainGameDesktopIcon.HasChanged)
					{
						desktopModifierSnapshot.RenameMainGameDesktopIcon = (found: true, value: modifier.RenameMainGameDesktopIcon);
					}
					if (modifier.MainGameDesktopIcon.HasChanged)
					{
						desktopModifierSnapshot.MainGameDesktopIcon = (found: true, value: modifier.MainGameDesktopIcon);
					}
					if (modifier.DisableDesktopLogo.HasChanged)
					{
						desktopModifierSnapshot.DisableDesktopLogo = (found: true, value: modifier.DisableDesktopLogo);
					}
					if (modifier.CustomBackgroundLogo.HasChanged)
					{
						desktopModifierSnapshot.CustomBackgroundLogo = (found: true, value: modifier.CustomBackgroundLogo);
					}
					if (modifier.BackgroundLogoTransparency.HasChanged)
					{
						desktopModifierSnapshot.BackgroundLogoTransparency = (found: true, value: modifier.BackgroundLogoTransparency);
					}
					if (modifier.VideoPlayerDesktopIsWideMode.HasChanged)
					{
						desktopModifierSnapshot.VideoPlayerDesktopIsWideMode = (found: true, value: modifier.VideoPlayerDesktopIsWideMode);
					}
					if (modifier.MailboxIcon.HasChanged)
					{
						desktopModifierSnapshot.MailboxIcon = (found: true, value: modifier.MailboxIcon);
					}
					if (modifier.MailboxRename.HasChanged)
					{
						desktopModifierSnapshot.MailboxRename = (found: true, value: modifier.MailboxRename);
					}
					if (modifier.ApplicationMailboxTitle.HasChanged)
					{
						desktopModifierSnapshot.ApplicationMailboxTitle = (found: true, value: modifier.ApplicationMailboxTitle);
					}
					if (modifier.ApplicationMailboxIcon.HasChanged)
					{
						desktopModifierSnapshot.ApplicationMailboxIcon = (found: true, value: modifier.ApplicationMailboxIcon);
					}
					if (modifier.DisplayMailboxOnDesktop.HasChanged)
					{
						desktopModifierSnapshot.DisplayMailboxOnDesktop = (found: true, value: modifier.DisplayMailboxOnDesktop);
					}
					if (modifier.EntryBrowserIcon.HasChanged)
					{
						desktopModifierSnapshot.EntryBrowserIcon = (found: true, value: modifier.EntryBrowserIcon);
					}
					if (modifier.EntryBrowserRename.HasChanged)
					{
						desktopModifierSnapshot.EntryBrowserRename = (found: true, value: modifier.EntryBrowserRename);
					}
					if (modifier.ApplicationEntryBrowserTitle.HasChanged)
					{
						desktopModifierSnapshot.ApplicationEntryBrowserTitle = (found: true, value: modifier.ApplicationEntryBrowserTitle);
					}
					if (modifier.ApplicationEntryBrowserIcon.HasChanged)
					{
						desktopModifierSnapshot.ApplicationEntryBrowserIcon = (found: true, value: modifier.ApplicationEntryBrowserIcon);
					}
					if (modifier.OptionsIcon.HasChanged)
					{
						desktopModifierSnapshot.OptionsIcon = (found: true, value: modifier.OptionsIcon);
					}
					if (modifier.OptionsRename.HasChanged)
					{
						desktopModifierSnapshot.OptionsRename = (found: true, value: modifier.OptionsRename);
					}
					if (modifier.ApplicationOptionsTitle.HasChanged)
					{
						desktopModifierSnapshot.ApplicationOptionsTitle = (found: true, value: modifier.ApplicationOptionsTitle);
					}
					if (modifier.ApplicationOptionsIcon.HasChanged)
					{
						desktopModifierSnapshot.ApplicationOptionsIcon = (found: true, value: modifier.ApplicationOptionsIcon);
					}
					if (modifier.ArtbookIcon.HasChanged)
					{
						desktopModifierSnapshot.ArtbookIcon = (found: true, value: modifier.ArtbookIcon);
					}
					if (modifier.ArtbookRename.HasChanged)
					{
						desktopModifierSnapshot.ArtbookRename = (found: true, value: modifier.ArtbookRename);
					}
					if (modifier.ApplicationArtbookTitle.HasChanged)
					{
						desktopModifierSnapshot.ApplicationArtbookTitle = (found: true, value: modifier.ApplicationArtbookTitle);
					}
					if (modifier.ApplicationArtbookIcon.HasChanged)
					{
						desktopModifierSnapshot.ApplicationArtbookIcon = (found: true, value: modifier.ApplicationArtbookIcon);
					}
					if (modifier.ArtbookPages != null && modifier.ArtbookPages.Count > 0)
					{
						desktopModifierSnapshot.ArtbookPages = (found: true, value: modifier.ArtbookPages);
					}
					if (modifier.ArcadeIcon.HasChanged)
					{
						desktopModifierSnapshot.ArcadeIcon = (found: true, value: modifier.ArcadeIcon);
					}
					if (modifier.ArcadeRename.HasChanged)
					{
						desktopModifierSnapshot.ArcadeRename = (found: true, value: modifier.ArcadeRename);
					}
					if (modifier.ScorecardIcon.HasChanged)
					{
						desktopModifierSnapshot.ScorecardIcon = (found: true, value: modifier.ScorecardIcon);
					}
					if (modifier.ScorecardRename.HasChanged)
					{
						desktopModifierSnapshot.ScorecardRename = (found: true, value: modifier.ScorecardRename);
					}
					if (modifier.ApplicationScorecardTitle.HasChanged)
					{
						desktopModifierSnapshot.ApplicationScorecardTitle = (found: true, value: modifier.ApplicationScorecardTitle);
					}
					if (modifier.ApplicationScorecardIcon.HasChanged)
					{
						desktopModifierSnapshot.ApplicationScorecardIcon = (found: true, value: modifier.ApplicationScorecardIcon);
					}
					if (modifier.DesktopCredits.HasChanged)
					{
						desktopModifierSnapshot.DesktopCredits = (found: true, value: modifier.DesktopCredits);
					}
					if (modifier.CreditsRename.HasChanged)
					{
						desktopModifierSnapshot.CreditsRename = (found: true, value: modifier.CreditsRename);
					}
					if (modifier.CreditsIcon.HasChanged)
					{
						desktopModifierSnapshot.CreditsIcon = (found: true, value: modifier.CreditsIcon);
					}
					if (modifier.HideDesktopCredits.HasChanged)
					{
						desktopModifierSnapshot.HideDesktopCredits = (found: true, value: modifier.HideDesktopCredits);
					}
					if (modifier.HideDiscordProgram.HasChanged)
					{
						desktopModifierSnapshot.HideDiscordProgram = (found: true, value: modifier.HideDiscordProgram);
					}
				}
			}
			return desktopModifierSnapshot;
		}

		public static (bool foundModifier, TValue value) GetActiveModifierValue<TValue>(Func<CustomModifier, TValue> selector, Func<TValue, bool> predicate = null, Func<CustomModifier, bool> specialPredicate = null)
		{
			CustomCampaign activeCustomCampaign = GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return (foundModifier: false, value: default(TValue));
			}
			if (predicate == null)
			{
				predicate = (TValue _) => true;
			}
			if (specialPredicate == null)
			{
				specialPredicate = (CustomModifier _) => true;
			}
			TValue item = default(TValue);
			bool item2 = false;
			foreach (ModifierSource modifierSource in activeCustomCampaign.ModifierSources)
			{
				if (modifierSource != null && modifierSource.Modifiers != null && modifierSource.Modifiers.Count != 0 && modifierSource.SourceCondition(activeCustomCampaign))
				{
					(bool, TValue) modifierValueFromList = GetModifierValueFromList(modifierSource.Modifiers, selector, predicate, (CustomModifier modifier) => modifierSource.ModifierExtraSelectionCondition(modifier) && specialPredicate(modifier));
					if (modifierValueFromList.Item1)
					{
						item2 = true;
						item = modifierValueFromList.Item2;
					}
				}
			}
			return (foundModifier: item2, value: item);
		}

		private static (bool found, TValue value) GetModifierValueFromList<TValue>(List<CustomModifier> modifierList, Func<CustomModifier, TValue> selector, Func<TValue, bool> predicate, Func<CustomModifier, bool> specialPredicate)
		{
			if (modifierList == null)
			{
				return (found: false, value: default(TValue));
			}
			foreach (CustomModifier modifier in modifierList)
			{
				if (modifier != null)
				{
					TValue val = selector(modifier);
					if (predicate(val) && specialPredicate(modifier))
					{
						return (found: true, value: val);
					}
				}
			}
			return (found: false, value: default(TValue));
		}

		public static void AddAllCustomCampaignEntriesToArray(ref MonsterProfileList monsterProfileList)
		{
			CustomCampaign customCampaign = GetActiveCustomCampaign();
			if (customCampaign == null)
			{
				return;
			}
			LoggingHelper.DebugLog(() => $"Now adding all {customCampaign.EntriesOnlyInCampaign.Count} entries to the custom campaign.");
			foreach (EntryMetadata entryInCustomCampaign in customCampaign.EntriesOnlyInCampaign)
			{
				LoggingHelper.DebugLog(() => "Adding entry " + entryInCustomCampaign.Name + " to custom campaign.");
				NewSafetyHelp.EntryManager.EntryManager.AddEntryToTheProfile(entryInCustomCampaign.ReferenceCopyEntry, ref monsterProfileList.monsterProfiles, "allEntries");
			}
			NewSafetyHelp.EntryManager.EntryManager.SortEntryProfiles(ref monsterProfileList.monsterProfiles);
		}

		public static void ReplaceAllProvidedCampaignEntries(ref MonsterProfileList monsterProfileList)
		{
			CustomCampaign customCampaign = GetActiveCustomCampaign();
			if (!InCustomCampaign || customCampaign == null)
			{
				return;
			}
			LoggingHelper.DebugLog(() => $"Now replacing all {customCampaign.EntryReplaceOnlyInCampaign.Count} entries to the custom campaign.");
			if (monsterProfileList.monsterProfiles.Length == 0)
			{
				return;
			}
			for (int num = 0; num < monsterProfileList.monsterProfiles.Length; num++)
			{
				MonsterProfile realEntry = monsterProfileList.monsterProfiles[num];
				if ((Object)(object)realEntry == (Object)null)
				{
					LoggingHelper.WarningLog("realEntry is null! Unable of replacing entry for this entry!");
					break;
				}
				EntryMetadata entryFound = customCampaign.EntryReplaceOnlyInCampaign.Find((EntryMetadata replaceEntry) => replaceEntry.Name.Equals(realEntry.monsterName) || replaceEntry.ID.Equals(realEntry.monsterID));
				if (entryFound == null)
				{
					continue;
				}
				if (entryFound.DeleteEntry)
				{
					if (string.IsNullOrEmpty(entryFound.Name))
					{
						LoggingHelper.WarningLog("Monster entry was not found. Is is the correct name?");
						continue;
					}
					NewSafetyHelp.EntryManager.EntryManager.DeleteEntryProfile(ref monsterProfileList.monsterProfiles, null, entryFound.Name);
					LoggingHelper.DebugLog(() => "Deleting entry '" + entryFound.Name + "' in custom campaign.");
				}
				else if ((Object)(object)entryFound.ReferenceCopyEntry == (Object)null)
				{
					LoggingHelper.WarningLog("referenceCopyEntry of EntryFound is null. Was the entry initialized?");
				}
				else
				{
					monsterProfileList.monsterProfiles[num] = entryFound.ReferenceCopyEntry;
					LoggingHelper.DebugLog(() => "Replacing entry " + entryFound.Name + " with custom entry in custom campaign.");
				}
			}
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.TimedCaller
{
	public static class TimedCallerPatches
	{
		[HarmonyPatch(typeof(CallerController), "PlayCallAudio", new Type[] { typeof(CallerProfile) })]
		public static class PlayCallAudioPatch
		{
			private static Coroutine playCallAudioRoutine;

			private static readonly MethodInfo PlayCallAudioRoutineMethod = typeof(CallerController).GetMethod("PlayCallAudioRoutine", BindingFlags.Instance | BindingFlags.NonPublic);

			private static bool Prefix(CallerController __instance, CallerProfile profile)
			{
				IEnumerator enumerator = (IEnumerator)PlayCallAudioRoutineMethod.Invoke(__instance, new object[1] { profile });
				playCallAudioRoutine = ((MonoBehaviour)__instance).StartCoroutine(enumerator);
				GlobalVariables.UISoundControllerScript.myMonsterSampleAudioSource.Stop();
				return false;
			}

			public static void StopCallAudioRoutine()
			{
				if (playCallAudioRoutine != null)
				{
					((MonoBehaviour)GlobalVariables.callerControllerScript).StopCoroutine(playCallAudioRoutine);
				}
			}
		}

		[HarmonyPatch(typeof(CallWindowBehavior), "CloseButton", new Type[]
		{
			typeof(bool),
			typeof(bool)
		})]
		public static class HoldButtonClosePatch
		{
			private static bool Prefix(CallWindowBehavior __instance, ref bool playHoldSound, ref bool playHoldMusic)
			{
				GlobalVariables.callerControllerScript.StopCallAudio();
				PlayCallAudioPatch.StopCallAudioRoutine();
				if (playHoldSound)
				{
					GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.holdPlease, (AudioSource)null);
				}
				if (playHoldMusic)
				{
					GlobalVariables.musicControllerScript.StartRandomMusic();
					((Component)GlobalVariables.mainCanvasScript.largeCallerPortrait).gameObject.SetActive(false);
				}
				GlobalVariables.callerControllerScript.StopLargeWindowRoutine();
				((Component)__instance).gameObject.SetActive(false);
				GlobalVariables.callerControllerScript.StopCallAudio();
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(GlobalVariables.callerControllerScript.currentCallerID);
					CallerProfile currentCallerProfile = GlobalVariables.callerControllerScript.currentCallerProfile;
					bool flag = (Object)(object)currentCallerProfile == (Object)(object)GlobalVariables.callerControllerScript.warningCall || (Object)(object)currentCallerProfile == (Object)(object)GlobalVariables.callerControllerScript.gameOverCall;
					if (customCallerFromActiveCampaign != null && customCallerFromActiveCampaign.IsTimedCaller && !flag)
					{
						TimerCallerHelper.StartTimedCallerTimer(customCallerFromActiveCampaign.TimedCallerDuration);
					}
				}
				GlobalVariables.callerControllerScript.StopCallAudio();
				return false;
			}
		}
	}
	public static class TimerCallerHelper
	{
		private static object timerCallerRoutine;

		private static GameObject timerLabel;

		private static GameObject analogClock;

		private static GameObject clockHand;

		private static GameObject clockSymbol;

		private static Image clockFill;

		private static TextMeshProUGUI analogClockHoverText;

		private static RichAudioClip clockStart = EmbeddedTimerData.ClockStart;

		private static RichAudioClip clockHalfTime = EmbeddedTimerData.ClockHalfTime;

		private static RichAudioClip clockFivePercent = EmbeddedTimerData.ClockFivePercent;

		private static Sprite clockBaseSprite = EmbeddedTimerData.ClockBase;

		private static Sprite clockHandSprite = EmbeddedTimerData.ClockHand;

		private static readonly FieldInfo OnCallConcluded = typeof(CallerController).GetField("OnCallConcluded", BindingFlags.Static | BindingFlags.NonPublic);

		public static void StartTimedCallerTimer(float seconds)
		{
			if (timerCallerRoutine == null)
			{
				(bool, VariableChanged<RichAudioClip>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.TimedCallerStartSound, (VariableChanged<RichAudioClip> vCb) => vCb.HasChanged);
				if (activeModifierValue.Item1)
				{
					clockStart = activeModifierValue.Item2.Data;
				}
				else
				{
					clockStart = EmbeddedTimerData.ClockStart;
				}
				(bool, VariableChanged<RichAudioClip>) activeModifierValue2 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.TimedCallerHalfSound, (VariableChanged<RichAudioClip> vCb) => vCb.HasChanged);
				if (activeModifierValue2.Item1)
				{
					clockHalfTime = activeModifierValue2.Item2.Data;
				}
				else
				{
					clockHalfTime = EmbeddedTimerData.ClockHalfTime;
				}
				(bool, VariableChanged<RichAudioClip>) activeModifierValue3 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.TimedCallerCriticalSound, (VariableChanged<RichAudioClip> vCb) => vCb.HasChanged);
				if (activeModifierValue3.Item1)
				{
					clockFivePercent = activeModifierValue3.Item2.Data;
				}
				else
				{
					clockFivePercent = EmbeddedTimerData.ClockHalfTime;
				}
				(bool, VariableChanged<bool>) activeModifierValue4 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.UseClockInsteadOfTimer, (VariableChanged<bool> vCb) => vCb.HasChanged);
				if (activeModifierValue4.Item1 && activeModifierValue4.Item2.Data)
				{
					timerCallerRoutine = MelonCoroutines.Start(AnalogTimedCallerTimer(seconds));
				}
				else
				{
					timerCallerRoutine = MelonCoroutines.Start(DigitalTimedCallerTimer(seconds));
				}
				LoggingHelper.InfoLog($"Starting timed caller with a timer of '{seconds}'.");
			}
			else
			{
				LoggingHelper.DebugLog("Timer is already running. Not running again.");
			}
		}

		public static void StopTimedCallerTimer()
		{
			if (timerCallerRoutine != null)
			{
				LoggingHelper.DebugLog("Stopped timer caller coroutine.");
				MelonCoroutines.Stop(timerCallerRoutine);
				timerCallerRoutine = null;
			}
		}

		private static string GetTimerDisplay(float seconds)
		{
			int num = (int)(seconds / 60f);
			int num2 = (int)(seconds % 60f);
			return $"{num:D2}:{num2:D2}";
		}

		private static IEnumerator DigitalTimedCallerTimer(float seconds)
		{
			if ((Object)(object)timerLabel == (Object)null)
			{
				LoggingHelper.ErrorLog("TimerLabel is null and can't be updated.");
				yield break;
			}
			float tenPercentTimerCheckmark = seconds * 0.1f;
			bool playedTenPercent = false;
			float halfPercentTimerCheckmark = seconds * 0.5f;
			bool playedHalfPercent = false;
			TextMeshProUGUI textMeshComponent = ((Component)timerLabel.transform.GetChild(0)).GetComponent<TextMeshProUGUI>();
			((TMP_Text)textMeshComponent).text = GetTimerDisplay(seconds);
			GlobalVariables.UISoundControllerScript.PlayUISound(clockStart, (AudioSource)null);
			float tickRate = 1f;
			(bool modifierFound, VariableChanged<float> value) tickRateModifier = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DigitalClockTickRate, (VariableChanged<float> vCf) => vCf.HasChanged);
			if (tickRateModifier.modifierFound)
			{
				tickRate = tickRateModifier.value.Data;
			}
			while (seconds > tickRate)
			{
				yield return (object)new WaitForSeconds(tickRate);
				seconds -= tickRate;
				((TMP_Text)textMeshComponent).text = GetTimerDisplay(seconds);
				if (!playedHalfPercent && seconds <= halfPercentTimerCheckmark)
				{
					playedHalfPercent = true;
					GlobalVariables.UISoundControllerScript.PlayUISound(clockHalfTime, (AudioSource)null);
				}
				if (!playedTenPercent && seconds <= tenPercentTimerCheckmark)
				{
					playedTenPercent = true;
					GlobalVariables.UISoundControllerScript.PlayUISound(clockFivePercent, (AudioSource)null);
				}
			}
			yield return (object)new WaitForSeconds(seconds);
			((TMP_Text)textMeshComponent).text = "00:00";
			LoggingHelper.InfoLog($"Finished timer caller with a time of '{seconds}'.");
			yield return (object)new WaitForSeconds(0.1f);
			GlobalVariables.callerControllerScript.SubmitAnswer((MonsterProfile)null);
			GlobalVariables.musicControllerScript.StopMusic();
			GlobalVariables.UISoundControllerScript.StopUISoundLooping();
			FinishUpTimedCaller();
		}

		private static IEnumerator AnalogTimedCallerTimer(float seconds)
		{
			if ((Object)(object)clockHand == (Object)null)
			{
				LoggingHelper.ErrorLog("ClockHand of the Clock UI is null. (Possibly not set up correctly)?");
				yield break;
			}
			float startSeconds = seconds;
			float tenPercentTimerCheckmark = seconds * 0.1f;
			bool playedTenPercent = false;
			float halfPercentTimerCheckmark = seconds * 0.5f;
			bool playedHalfPercent = false;
			GlobalVariables.UISoundControllerScript.PlayUISound(clockStart, (AudioSource)null);
			float tickRate = 0.05f;
			(bool modifierFound, VariableChanged<float> value) tickRateModifier = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.AnalogClockTickRate, (VariableChanged<float> vCf) => vCf.HasChanged);
			if (tickRateModifier.modifierFound)
			{
				tickRate = tickRateModifier.value.Data;
				LoggingHelper.DebugLog($"Setting tick rate of analog timer to '{tickRate}'.");
			}
			while (seconds > tickRate)
			{
				yield return (object)new WaitForSeconds(tickRate);
				seconds -= tickRate;
				float rotationPercentage = (startSeconds - seconds) / startSeconds;
				float rotationValue = rotationPercentage * 360f;
				clockHand.transform.localRotation = Quaternion.Euler(0f, 0f, 0f - rotationValue);
				clockFill.fillAmount = rotationPercentage;
				((TMP_Text)analogClockHoverText).text = GetTimerDisplay(seconds);
				if (!playedHalfPercent && seconds <= halfPercentTimerCheckmark)
				{
					playedHalfPercent = true;
					GlobalVariables.UISoundControllerScript.PlayUISound(clockHalfTime, (AudioSource)null);
				}
				if (!playedTenPercent && seconds <= tenPercentTimerCheckmark)
				{
					playedTenPercent = true;
					GlobalVariables.UISoundControllerScript.PlayUISound(clockFivePercent, (AudioSource)null);
				}
			}
			yield return (object)new WaitForSeconds(seconds);
			LoggingHelper.InfoLog($"Finished timer caller with a time of '{seconds}'.");
			clockHand.transform.localRotation = Quaternion.Euler(0f, 0f, -360f);
			clockFill.fillAmount = 1f;
			yield return (object)new WaitForSeconds(0.1f);
			FinishUpTimedCaller();
		}

		private static void FinishUpTimedCaller()
		{
			GlobalVariables.callerControllerScript.SubmitAnswer((MonsterProfile)null);
			GlobalVariables.musicControllerScript.StopMusic();
			GlobalVariables.UISoundControllerScript.StopUISoundLooping();
			if (OnCallConcluded.GetValue(null) is MulticastDelegate multicastDelegate)
			{
				multicastDelegate.DynamicInvoke();
			}
			GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.disconnect, (AudioSource)null);
			timerCallerRoutine = null;
			HideCallerTimerUI();
			string text = "TIMES UP!\nCALL DISCONNECTED";
			(bool, VariableChanged<string>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.TimedCallerDisconnectedMessage, (VariableChanged<string> vCs) => vCs.HasChanged);
			if (activeModifierValue.Item1)
			{
				text = activeModifierValue.Item2.Data;
			}
			GlobalVariables.mainCanvasScript.CreateError(text);
			GlobalVariables.mainCanvasScript.inputBlocker.SetActive(false);
		}

		public static void ShowCallerTimerUI(MainCanvasBehavior __instance, CustomCCaller currentCaller)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Expected O, but got Unknown
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			(bool, VariableChanged<Sprite>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.TimedCallerBaseClock, (VariableChanged<Sprite> vCs) => vCs.HasChanged);
			if (activeModifierValue.Item1)
			{
				clockBaseSprite = activeModifierValue.Item2.Data;
			}
			else
			{
				clockBaseSprite = EmbeddedTimerData.ClockBase;
			}
			(bool, VariableChanged<Sprite>) activeModifierValue2 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.TimedCallerClockHand, (VariableChanged<Sprite> vCs) => vCs.HasChanged);
			if (activeModifierValue2.Item1)
			{
				clockHandSprite = activeModifierValue2.Item2.Data;
			}
			else
			{
				clockHandSprite = EmbeddedTimerData.ClockHand;
			}
			GameObject gameObject = ((Component)__instance.callWindow.transform.Find("CurrentCall/CallerPortrait")).gameObject;
			clockSymbol = new GameObject("ClockSymbol");
			clockSymbol.transform.SetParent(gameObject.transform, false);
			clockSymbol.AddComponent<CanvasRenderer>();
			Image val = clockSymbol.AddComponent<Image>();
			val.sprite = clockBaseSprite;
			RectTransform component = clockSymbol.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(1f, 0f);
			component.anchorMax = new Vector2(1f, 0f);
			component.pivot = new Vector2(1f, 0f);
			component.anchoredPosition = new Vector2(0f, 0f);
			float num = 57.5f;
			(bool, VariableChanged<float>) activeModifierValue3 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.TimedCallerProfileClockSize, (VariableChanged<float> vCs) => vCs.HasChanged);
			if (activeModifierValue3.Item1)
			{
				num = activeModifierValue3.Item2.Data;
			}
			(bool, VariableChanged<float>) activeModifierValue4 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.TimedCallerProfileClockSizeMultiplier, (VariableChanged<float> vCs) => vCs.HasChanged);
			if (activeModifierValue4.Item1)
			{
				num *= activeModifierValue4.Item2.Data;
			}
			component.offsetMax = new Vector2(0f, num);
			component.offsetMin = new Vector2(0f - num, 0f);
			Vector2 anchoredPosition = default(Vector2);
			((Vector2)(ref anchoredPosition))..ctor(5f, -5f);
			(bool, VariableChanged<float>) activeModifierValue5 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.TimedCallerProfileClockPadX, (VariableChanged<float> vCs) => vCs.HasChanged);
			(bool, VariableChanged<float>) activeModifierValue6 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.TimedCallerProfileClockPadY, (VariableChanged<float> vCs) => vCs.HasChanged);
			if (activeModifierValue5.Item1)
			{
				anchoredPosition.x = activeModifierValue5.Item2.Data;
			}
			if (activeModifierValue6.Item1)
			{
				anchoredPosition.y = 0f - activeModifierValue6.Item2.Data;
			}
			component.anchoredPosition = anchoredPosition;
			GameObject val2 = new GameObject("ClockSymbolHand");
			val2.transform.SetParent(clockSymbol.transform, false);
			val2.AddComponent<CanvasRenderer>();
			Image val3 = val2.AddComponent<Image>();
			val3.sprite = clockHandSprite;
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			val2.transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
			(bool, VariableChanged<bool>) activeModifierValue7 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.UseClockInsteadOfTimer, (VariableChanged<bool> vCb) => vCb.HasChanged);
			if (activeModifierValue7.Item1 && activeModifierValue7.Item2.Data)
			{
				ShowAnalogClockTimerUI(__instance, currentCaller);
			}
			else
			{
				ShowDigitTimerUI(__instance, currentCaller);
			}
		}

		private static void ShowDigitTimerUI(MainCanvasBehavior __instance, CustomCCaller currentCaller)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)((Component)__instance.callerNameText).gameObject.transform.parent.parent.Find("ReplayLabel")).GetComponent<RectTransform>();
			timerLabel = Object.Instantiate<GameObject>(((Component)component).gameObject, ((Component)component).gameObject.transform.parent);
			((Object)timerLabel).name = "Timer Label";
			((Transform)timerLabel.GetComponent<RectTransform>()).localPosition = new Vector3(135f, ((Transform)component).localPosition.y, ((Transform)component).localPosition.z);
			timerLabel.GetComponent<RectTransform>().offsetMax = new Vector2(100.465f, -40.7853f);
			((TMP_Text)((Component)timerLabel.transform.GetChild(0)).GetComponent<TextMeshProUGUI>()).text = GetTimerDisplay(currentCaller.TimedCallerDuration);
			((TMP_Text)((Component)timerLabel.transform.GetChild(0)).GetComponent<TextMeshProUGUI>()).alignment = (TextAlignmentOptions)514;
			component.offsetMax = new Vector2(60.838f, -40.7853f);
		}

		private static void ShowAnalogClockTimerUI(MainCanvasBehavior __instance, CustomCCaller currentCaller)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Expected O, but got Unknown
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Expected O, but got Unknown
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Expected O, but got Unknown
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Expected O, but got Unknown
			//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Expected O, but got Unknown
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)((Component)__instance.callerNameText).gameObject.transform.parent.parent.Find("ReplayLabel")).GetComponent<RectTransform>();
			analogClock = Object.Instantiate<GameObject>(((Component)component).gameObject, ((Component)component).gameObject.transform.parent);
			((Object)analogClock).name = "Timer Clock";
			((Transform)analogClock.GetComponent<RectTransform>()).localPosition = new Vector3(141f, ((Transform)component).localPosition.y - 5f, ((Transform)component).localPosition.z);
			analogClock.GetComponent<RectTransform>().offsetMax = new Vector2(105.465f, -30.7853f);
			((TMP_Text)((Component)analogClock.transform.GetChild(0)).GetComponent<TextMeshProUGUI>()).text = "";
			Object.Destroy((Object)(object)analogClock.GetComponent<AdhereToPalette>());
			Image component2 = analogClock.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)component2).raycastTarget = true;
			GameObject val = new GameObject("ClockBase");
			val.transform.SetParent(analogClock.transform, false);
			val.AddComponent<CanvasRenderer>();
			Image val2 = val.AddComponent<Image>();
			val2.sprite = clockBaseSprite;
			RectTransform component3 = val.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			GameObject val3 = new GameObject("ClockFill");
			val3.transform.SetParent(val.transform, false);
			val3.AddComponent<CanvasRenderer>();
			clockFill = val3.AddComponent<Image>();
			clockFill.sprite = clockBaseSprite;
			clockFill.type = (Type)3;
			clockFill.fillMethod = (FillMethod)4;
			clockFill.fillOrigin = 2;
			clockFill.fillCenter = true;
			clockFill.fillClockwise = true;
			((Graphic)clockFill).color = Color.gray;
			clockFill.fillAmount = 0f;
			RectTransform component4 = val3.GetComponent<RectTransform>();
			component4.anchorMin = Vector2.zero;
			component4.anchorMax = Vector2.one;
			component4.offsetMin = Vector2.zero;
			component4.offsetMax = Vector2.zero;
			clockHand = new GameObject("ClockHand");
			clockHand.transform.SetParent(val.transform, false);
			clockHand.AddComponent<CanvasRenderer>();
			Image val4 = clockHand.AddComponent<Image>();
			val4.sprite = clockHandSprite;
			RectTransform component5 = clockHand.GetComponent<RectTransform>();
			component5.anchorMin = Vector2.zero;
			component5.anchorMax = Vector2.one;
			component5.offsetMin = Vector2.zero;
			component5.offsetMax = Vector2.zero;
			clockHand.transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
			GameObject clockDigitOnAnalog = new GameObject("ClockDigitOnAnalog");
			clockDigitOnAnalog.transform.SetParent(analogClock.transform, false);
			clockDigitOnAnalog.AddComponent<CanvasRenderer>();
			Image val5 = clockDigitOnAnalog.AddComponent<Image>();
			val5.sprite = null;
			Color color = default(Color);
			((Color)(ref color))..ctor(0f, 0f, 0f, 0.5f);
			((Graphic)val5).color = color;
			RectTransform component6 = clockDigitOnAnalog.GetComponent<RectTransform>();
			component6.anchorMin = Vector2.zero;
			component6.anchorMax = Vector2.one;
			component6.offsetMin = Vector2.zero;
			component6.offsetMax = Vector2.zero;
			GameObject val6 = new GameObject("ClockDigitOnAnalogDigits");
			val6.transform.SetParent(clockDigitOnAnalog.transform, false);
			TextMeshProUGUI val7 = val6.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val7).text = GetTimerDisplay(currentCaller.TimedCallerDuration) ?? "";
			((TMP_Text)val7).fontSize = 12f;
			((TMP_Text)val7).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val7).font = ((TMP_Text)((Component)analogClock.transform.GetChild(0)).GetComponent<TextMeshProUGUI>()).font;
			analogClockHoverText = val7;
			RectTransform component7 = val6.GetComponent<RectTransform>();
			component7.anchorMin = Vector2.zero;
			component7.anchorMax = Vector2.one;
			component7.offsetMin = Vector2.zero;
			component7.offsetMax = Vector2.zero;
			clockDigitOnAnalog.SetActive(false);
			EventTrigger val8 = analogClock.AddComponent<EventTrigger>();
			Entry val9 = new Entry
			{
				eventID = (EventTriggerType)0
			};
			((UnityEvent<BaseEventData>)(object)val9.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				clockDigitOnAnalog.SetActive(true);
			});
			Entry val10 = new Entry
			{
				eventID = (EventTriggerType)1
			};
			((UnityEvent<BaseEventData>)(object)val10.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				clockDigitOnAnalog.SetActive(false);
			});
			val8.triggers.Add(val9);
			val8.triggers.Add(val10);
			component.offsetMax = new Vector2(60.838f, -40.7853f);
		}

		public static void HideCallerTimerUI()
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)timerLabel != (Object)null)
			{
				Object.Destroy((Object)(object)timerLabel);
			}
			if ((Object)(object)analogClock != (Object)null)
			{
				Object.Destroy((Object)(object)analogClock);
			}
			if ((Object)(object)clockHand != (Object)null)
			{
				Object.Destroy((Object)(object)clockHand);
			}
			if ((Object)(object)clockSymbol != (Object)null)
			{
				Object.Destroy((Object)(object)clockSymbol);
			}
			RectTransform component = ((Component)((TMP_Text)GlobalVariables.mainCanvasScript.callerNameText).transform.parent.parent.Find("ReplayLabel")).GetComponent<RectTransform>();
			component.offsetMax = new Vector2(100.838f, -40.7853f);
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.Themes
{
	public static class ThemePatches
	{
		[HarmonyPatch(typeof(OptionsMenuBehavior), "OnEnable")]
		public static class OptionsAddCustomSettings
		{
			private static void Prefix(OptionsMenuBehavior __instance)
			{
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Expected O, but got Unknown
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Expected O, but got Unknown
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					foreach (CustomTheme theme in GlobalParsingVariables.MainGameThemes)
					{
						if (theme != null && !__instance.colorDropdown.options.Any((OptionData o) => o.text == theme.ThemeName))
						{
							__instance.colorDropdown.options.Add(new OptionData(theme.ThemeName));
						}
					}
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return;
					}
					if (activeCustomCampaign.RemoveDefaultThemes.HasChanged && activeCustomCampaign.RemoveDefaultThemes.Data)
					{
						__instance.colorDropdown.options.Clear();
					}
					foreach (CustomTheme theme2 in activeCustomCampaign.CustomThemesGeneral)
					{
						if (theme2 != null && !__instance.colorDropdown.options.Any((OptionData o) => o.text == theme2.ThemeName))
						{
							__instance.colorDropdown.options.Add(new OptionData(theme2.ThemeName));
						}
					}
					if (activeCustomCampaign.DisablePickingThemeOption)
					{
						ThemeProgramHelper.DisableThemeDropdownInGame();
					}
					if (__instance.colorDropdown.options.Count == 1)
					{
						__instance.colorDropdown.value = 0;
						((UnityEvent<int>)(object)__instance.colorDropdown.onValueChanged).Invoke(0);
					}
				}
				__instance.colorDropdown.RefreshShownValue();
			}
		}

		[HarmonyPatch(typeof(ColorPaletteController), "UpdateColorTheme")]
		public static class UpdateColorThemePatch
		{
			private static bool Prefix(ColorPaletteController __instance)
			{
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					if (GlobalVariables.saveManagerScript.savedColorTheme <= 3)
					{
						NormalPaletteUpdate(__instance);
					}
					else
					{
						for (int i = 0; i < GlobalParsingVariables.MainGameThemes.Count; i++)
						{
							if (GlobalVariables.saveManagerScript.savedColorTheme == i + 4 && GlobalParsingVariables.MainGameThemes[i] != null && (Object)(object)GlobalParsingVariables.MainGameThemes[i].CustomThemePalette != (Object)null && GlobalParsingVariables.MainGameThemes[i].CustomThemePalette.colorSwatch != null)
							{
								__instance.colorPalette = GlobalParsingVariables.MainGameThemes[i].CustomThemePalette;
							}
						}
					}
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					LoggingHelper.DebugLog($"Called with saved color theme: '{GlobalVariables.saveManagerScript.savedColorTheme}' " + $"and custom campaign activeTheme: '{activeCustomCampaign.ActiveTheme}'.", LoggingHelper.LoggingCategory.THEME);
					bool flag = false;
					if (activeCustomCampaign.RemoveDefaultThemes.HasChanged)
					{
						flag = activeCustomCampaign.RemoveDefaultThemes.Data;
					}
					if (!string.IsNullOrEmpty(activeCustomCampaign.DefaultTheme) && !activeCustomCampaign.DefaultThemeAppliedOnce)
					{
						int themeIDFromName = CustomCampaignGlobal.GetThemeIDFromName(activeCustomCampaign.DefaultTheme, flag);
						if (themeIDFromName > 0)
						{
							LoggingHelper.DebugLog($"Setting first time default theme to: '{themeIDFromName}'.");
							activeCustomCampaign.DefaultThemeAppliedOnce = true;
							activeCustomCampaign.ActiveTheme = themeIDFromName;
						}
					}
					if (!flag && activeCustomCampaign.ActiveTheme <= 3)
					{
						NormalPaletteUpdate(__instance);
					}
					else
					{
						int num = CustomCampaignGlobal.CheckIfConditionalTheme(flag);
						if (num != -1)
						{
							CustomTheme themeFromID = CustomCampaignGlobal.GetThemeFromID(num, flag);
							if (themeFromID != null && (Object)(object)themeFromID.CustomThemePalette != (Object)null && themeFromID.CustomThemePalette.colorSwatch != null && themeFromID.CustomThemePalette.colorSwatch.Length != 0)
							{
								__instance.colorPalette = themeFromID.CustomThemePalette;
							}
							else
							{
								NormalPaletteUpdate(__instance);
							}
						}
						else
						{
							bool isCustomTheme = false;
							CustomTheme activeTheme = CustomCampaignGlobal.GetActiveTheme(ref isCustomTheme, flag);
							LoggingHelper.DebugLog($"Is the theme custom? '{isCustomTheme}'. " + $"Was theme valid? '{activeTheme != null}'. ");
							LoggingHelper.DebugLog($"How many general themes? '{activeCustomCampaign.CustomThemesGeneral.Count}'. " + $"How many conditional themes? '{activeCustomCampaign.CustomThemesDays.Count}'.");
							if (isCustomTheme && activeTheme != null && (Object)(object)activeTheme.CustomThemePalette != (Object)null && activeTheme.CustomThemePalette.colorSwatch != null && activeTheme.CustomThemePalette.colorSwatch.Length != 0)
							{
								__instance.colorPalette = activeTheme.CustomThemePalette;
							}
							else
							{
								NormalPaletteUpdate(__instance);
							}
						}
					}
				}
				AdhereToPalette[] array = Object.FindObjectsOfType<AdhereToPalette>(true);
				foreach (AdhereToPalette val in array)
				{
					val.ChangeColors();
				}
				return false;
			}

			private static void NormalPaletteUpdate(ColorPaletteController __instance)
			{
				switch (GlobalVariables.saveManagerScript.savedColorTheme)
				{
				case 0:
					__instance.colorPalette = __instance.defaultPalette;
					if (GlobalVariables.isXmasDLC)
					{
						__instance.colorPalette = __instance.xmasPalette;
					}
					break;
				case 1:
					__instance.colorPalette = __instance.windowsPalette;
					break;
				case 2:
					__instance.colorPalette = __instance.tirePalette;
					break;
				case 3:
					__instance.colorPalette = __instance.nightPalette;
					break;
				}
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "ColorThemeChanged")]
		public static class ColorThemeChangedPatch
		{
			private static bool Prefix(OptionsMenuBehavior __instance)
			{
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					GlobalVariables.saveManagerScript.savedColorTheme = __instance.colorDropdown.value;
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.ActiveTheme = __instance.colorDropdown.value;
					GlobalVariables.saveManagerScript.savedColorTheme = __instance.colorDropdown.value;
				}
				if (!Object.op_Implicit((Object)(object)GlobalVariables.colorPaletteController))
				{
					return false;
				}
				LoggingHelper.DebugLog($"Color Palette change called with ID: {__instance.colorDropdown.value}", LoggingHelper.LoggingCategory.THEME);
				GlobalVariables.colorPaletteController.UpdateColorTheme();
				return false;
			}
		}
	}
	public class CustomTheme : CustomCampaignElementBase
	{
		public string ThemeName = "NO THEME NAME SET";

		public bool InMainCampaign = false;

		public string AttachedToTheme = null;

		public List<int> UnlockDays = null;

		public ColorPalette CustomThemePalette = null;
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.Saving
{
	public static class CustomCampaignOptionSaving
	{
		private static void initializeCustomCampaignOptionsOnce(bool saveAfterInit = true)
		{
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign != null)
			{
				if (activeCustomCampaign.CampaignSaveCategory == null)
				{
					activeCustomCampaign.CampaignSaveCategory = MelonPreferences.CreateCategory(activeCustomCampaign.CampaignName + activeCustomCampaign.CampaignDesktopName + activeCustomCampaign.CampaignDays);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedImmunityToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedImmunityToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedAccuracyToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedAccuracyToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedCallSkipToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedCallSkipToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedScreenHeight") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedScreenHeight", 1080, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedScreenWidth") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedScreenWidth", 1920, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedRefreshRate") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedRefreshRate", 180, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedSpiderToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedSpiderToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedInsectToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedInsectToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedDarkToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedDarkToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedHoleToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedHoleToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedWatchToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedWatchToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedDogToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedDogToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedTightToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedTightToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedDyslexiaToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedDyslexiaToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedTextSizeMultiplier") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<float>("savedTextSizeMultiplier", 1f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedFullScreenToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedFullScreenToggle", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedCRTToggle") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedCRTToggle", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedMusicVolume") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<float>("savedMusicVolume", 1f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedSFXVolume") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<float>("savedSFXVolume", 1f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedAmbienceVolume") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<float>("savedAmbienceVolume", 1f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedColorTheme") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedColorTheme", 0, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("themeShownOnce") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("themeShownOnce", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				if (saveAfterInit)
				{
					MelonPreferences.Save();
				}
			}
		}

		public static void SaveCustomCampaignOptions()
		{
			if (ReloadJSONParsing.IsInHotReload)
			{
				LoggingHelper.DebugLog("In Hot Reload. Prevented saving of options.");
				return;
			}
			if (!CustomCampaignGlobal.InCustomCampaign)
			{
				LoggingHelper.WarningLog("Called save custom campaign but there is no campaign active.");
				return;
			}
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign != null)
			{
				if (activeCustomCampaign.CampaignSaveCategory == null)
				{
					activeCustomCampaign.CampaignSaveCategory = MelonPreferences.CreateCategory(activeCustomCampaign.CampaignName + activeCustomCampaign.CampaignDesktopName + activeCustomCampaign.CampaignDays);
				}
				initializeCustomCampaignOptionsOnce();
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedImmunityToggle") == null)
				{
					MelonPreferences_Entry<bool> val = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedImmunityToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val.Value = activeCustomCampaign.SavedImmunityToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedImmunityToggle").Value = activeCustomCampaign.SavedImmunityToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedAccuracyToggle") == null)
				{
					MelonPreferences_Entry<bool> val2 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedAccuracyToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val2.Value = activeCustomCampaign.SavedAccuracyToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedAccuracyToggle").Value = activeCustomCampaign.SavedAccuracyToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedCallSkipToggle") == null)
				{
					MelonPreferences_Entry<bool> val3 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedCallSkipToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val3.Value = activeCustomCampaign.SavedCallSkipToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedCallSkipToggle").Value = activeCustomCampaign.SavedCallSkipToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedScreenHeight") == null)
				{
					MelonPreferences_Entry<int> val4 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedScreenHeight", 1080, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val4.Value = activeCustomCampaign.SavedScreenHeight;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedScreenHeight").Value = activeCustomCampaign.SavedScreenHeight;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedScreenWidth") == null)
				{
					MelonPreferences_Entry<int> val5 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedScreenWidth", 1920, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val5.Value = activeCustomCampaign.SavedScreenWidth;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedScreenWidth").Value = activeCustomCampaign.SavedScreenWidth;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedRefreshRate") == null)
				{
					MelonPreferences_Entry<int> val6 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedRefreshRate", 60, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val6.Value = activeCustomCampaign.SavedRefreshRate;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedRefreshRate").Value = activeCustomCampaign.SavedRefreshRate;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedSpiderToggle") == null)
				{
					MelonPreferences_Entry<bool> val7 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedSpiderToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val7.Value = activeCustomCampaign.SavedSpiderToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedSpiderToggle").Value = activeCustomCampaign.SavedSpiderToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedInsectToggle") == null)
				{
					MelonPreferences_Entry<bool> val8 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedInsectToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val8.Value = activeCustomCampaign.SavedInsectToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedInsectToggle").Value = activeCustomCampaign.SavedInsectToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedDarkToggle") == null)
				{
					MelonPreferences_Entry<bool> val9 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedDarkToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val9.Value = activeCustomCampaign.SavedDarkToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedDarkToggle").Value = activeCustomCampaign.SavedDarkToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedHoleToggle") == null)
				{
					MelonPreferences_Entry<bool> val10 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedHoleToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val10.Value = activeCustomCampaign.SavedHoleToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedHoleToggle").Value = activeCustomCampaign.SavedHoleToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedWatchToggle") == null)
				{
					MelonPreferences_Entry<bool> val11 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedWatchToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val11.Value = activeCustomCampaign.SavedWatchToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedWatchToggle").Value = activeCustomCampaign.SavedWatchToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedDogToggle") == null)
				{
					MelonPreferences_Entry<bool> val12 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedDogToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val12.Value = activeCustomCampaign.SavedDogToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedDogToggle").Value = activeCustomCampaign.SavedDogToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedTightToggle") == null)
				{
					MelonPreferences_Entry<bool> val13 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedTightToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val13.Value = activeCustomCampaign.SavedTightToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedTightToggle").Value = activeCustomCampaign.SavedTightToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedDyslexiaToggle") == null)
				{
					MelonPreferences_Entry<bool> val14 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedDyslexiaToggle", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val14.Value = activeCustomCampaign.SavedDyslexiaToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedDyslexiaToggle").Value = activeCustomCampaign.SavedDyslexiaToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedTextSizeMultiplier") == null)
				{
					MelonPreferences_Entry<float> val15 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<float>("savedTextSizeMultiplier", 1f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val15.Value = activeCustomCampaign.SavedTextSizeMultiplier;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedTextSizeMultiplier").Value = activeCustomCampaign.SavedTextSizeMultiplier;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedFullScreenToggle") == null)
				{
					MelonPreferences_Entry<bool> val16 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedFullScreenToggle", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val16.Value = activeCustomCampaign.SavedFullScreenToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedFullScreenToggle").Value = activeCustomCampaign.SavedFullScreenToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedCRTToggle") == null)
				{
					MelonPreferences_Entry<bool> val17 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("savedCRTToggle", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val17.Value = activeCustomCampaign.SavedCRTToggle;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("savedCRTToggle").Value = activeCustomCampaign.SavedCRTToggle;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedMusicVolume") == null)
				{
					MelonPreferences_Entry<float> val18 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<float>("savedMusicVolume", 1f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val18.Value = activeCustomCampaign.SavedMusicVolume;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedMusicVolume").Value = activeCustomCampaign.SavedMusicVolume;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedSFXVolume") == null)
				{
					MelonPreferences_Entry<float> val19 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<float>("savedSFXVolume", 1f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val19.Value = activeCustomCampaign.SavedSFXVolume;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedSFXVolume").Value = activeCustomCampaign.SavedSFXVolume;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedAmbienceVolume") == null)
				{
					MelonPreferences_Entry<float> val20 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<float>("savedAmbienceVolume", 1f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val20.Value = activeCustomCampaign.SavedAmbienceVolume;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<float>("savedAmbienceVolume").Value = activeCustomCampaign.SavedAmbienceVolume;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedColorTheme") == null)
				{
					MelonPreferences_Entry<int> val21 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedColorTheme", 0, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val21.Value = activeCustomCampaign.ActiveTheme;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedColorTheme").Value = activeCustomCampaign.ActiveTheme;
				}
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("themeShownOnce") == null)
				{
					MelonPreferences_Entry<bool> val22 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>("themeShownOnce", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					val22.Value = activeCustomCampaign.DefaultThemeAppliedOnce;
				}
				else
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("themeShownOnce").Value = activeCustomCampaign.DefaultThemeAppliedOnce;
				}
				MelonPreferences.Save();
				LoggingHelper.InfoLog("Finished saving (Options) for the custom campaign " + activeCustomCampaign.CampaignName + ".");
			}
		}

		public static void LoadCustomCampaignOptions()
		{
			LoggingHelper.InfoLog("Starting to load all custom campaign settings/options.");
			if (!CustomCampaignGlobal.InCustomCampaign)
			{
				LoggingHelper.WarningLog("Called load custom campaign but there is no campaign active.");
				return;
			}
			CustomCampaign currentCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (currentCampaign != null)
			{
				if (currentCampaign.CampaignSaveCategory == null)
				{
					currentCampaign.CampaignSaveCategory = MelonPreferences.CreateCategory(currentCampaign.CampaignName + currentCampaign.CampaignDesktopName + currentCampaign.CampaignDays);
				}
				initializeCustomCampaignOptionsOnce(saveAfterInit: false);
				LoggingHelper.DebugLog(() => string.Format("Saved color themes ({0}).", currentCampaign.CampaignSaveCategory.GetEntry<int>("savedColorTheme").Value), LoggingHelper.LoggingCategory.THEME);
				currentCampaign.SavedImmunityToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedImmunityToggle").Value;
				currentCampaign.SavedAccuracyToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedAccuracyToggle").Value;
				currentCampaign.SavedCallSkipToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedCallSkipToggle").Value;
				currentCampaign.SavedScreenHeight = currentCampaign.CampaignSaveCategory.GetEntry<int>("savedScreenHeight").Value;
				currentCampaign.SavedScreenWidth = currentCampaign.CampaignSaveCategory.GetEntry<int>("savedScreenWidth").Value;
				currentCampaign.SavedRefreshRate = currentCampaign.CampaignSaveCategory.GetEntry<int>("savedRefreshRate").Value;
				currentCampaign.SavedSpiderToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedSpiderToggle").Value;
				currentCampaign.SavedInsectToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedInsectToggle").Value;
				currentCampaign.SavedDarkToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedDarkToggle").Value;
				currentCampaign.SavedDogToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedDogToggle").Value;
				currentCampaign.SavedWatchToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedWatchToggle").Value;
				currentCampaign.SavedHoleToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedHoleToggle").Value;
				currentCampaign.SavedTightToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedTightToggle").Value;
				currentCampaign.SavedDyslexiaToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedDyslexiaToggle").Value;
				currentCampaign.SavedTextSizeMultiplier = currentCampaign.CampaignSaveCategory.GetEntry<float>("savedTextSizeMultiplier").Value;
				currentCampaign.SavedFullScreenToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedFullScreenToggle").Value;
				currentCampaign.SavedCRTToggle = currentCampaign.CampaignSaveCategory.GetEntry<bool>("savedCRTToggle").Value;
				currentCampaign.SavedMusicVolume = currentCampaign.CampaignSaveCategory.GetEntry<float>("savedMusicVolume").Value;
				currentCampaign.SavedSFXVolume = currentCampaign.CampaignSaveCategory.GetEntry<float>("savedSFXVolume").Value;
				currentCampaign.SavedAmbienceVolume = currentCampaign.CampaignSaveCategory.GetEntry<float>("savedAmbienceVolume").Value;
				currentCampaign.ActiveTheme = currentCampaign.CampaignSaveCategory.GetEntry<int>("savedColorTheme").Value;
				currentCampaign.DefaultThemeAppliedOnce = currentCampaign.CampaignSaveCategory.GetEntry<bool>("themeShownOnce").Value;
				GlobalVariables.saveManagerScript.savedScreenHeight = currentCampaign.SavedScreenHeight;
				GlobalVariables.screenHeightSetting = currentCampaign.SavedScreenHeight;
				GlobalVariables.saveManagerScript.savedScreenWidth = currentCampaign.SavedScreenWidth;
				GlobalVariables.screenWidthSetting = currentCampaign.SavedScreenWidth;
				GlobalVariables.saveManagerScript.savedRefreshRate = currentCampaign.SavedRefreshRate;
				GlobalVariables.refreshRateSetting = currentCampaign.SavedRefreshRate;
				GlobalVariables.saveManagerScript.savedSpiderToggle = (currentCampaign.SavedSpiderToggle ? 1 : 0);
				GlobalVariables.saveManagerScript.savedInsectToggle = (currentCampaign.SavedInsectToggle ? 1 : 0);
				GlobalVariables.saveManagerScript.savedDarkToggle = (currentCampaign.SavedDarkToggle ? 1 : 0);
				GlobalVariables.saveManagerScript.savedDogToggle = (currentCampaign.SavedDogToggle ? 1 : 0);
				GlobalVariables.saveManagerScript.savedWatchToggle = (currentCampaign.SavedWatchToggle ? 1 : 0);
				GlobalVariables.saveManagerScript.savedHoleToggle = (currentCampaign.SavedHoleToggle ? 1 : 0);
				GlobalVariables.saveManagerScript.savedTightToggle = (currentCampaign.SavedTightToggle ? 1 : 0);
				GlobalVariables.saveManagerScript.savedDyslexiaToggle = (currentCampaign.SavedDyslexiaToggle ? 1 : 0);
				GlobalVariables.dyslexiaMode = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedDyslexiaToggle);
				GlobalVariables.saveManagerScript.savedTextSizeMultiplier = currentCampaign.SavedTextSizeMultiplier;
				GlobalVariables.textSizeMultiplier = GlobalVariables.saveManagerScript.savedTextSizeMultiplier;
				GlobalVariables.saveManagerScript.savedFullScreenToggle = (currentCampaign.SavedFullScreenToggle ? 1 : 0);
				GlobalVariables.isFullScreen = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedFullScreenToggle);
				GlobalVariables.saveManagerScript.savedCRTToggle = (currentCampaign.SavedCRTToggle ? 1 : 0);
				GlobalVariables.saveManagerScript.savedMusicVolume = currentCampaign.SavedMusicVolume;
				GlobalVariables.saveManagerScript.savedSFXVolume = currentCampaign.SavedSFXVolume;
				GlobalVariables.saveManagerScript.savedAmbienceVolume = currentCampaign.SavedAmbienceVolume;
				GlobalVariables.saveManagerScript.savedColorTheme = currentCampaign.ActiveTheme;
				if (Object.op_Implicit((Object)(object)GlobalVariables.colorPaletteController))
				{
					GlobalVariables.colorPaletteController.UpdateColorTheme();
				}
				LoggingHelper.InfoLog("Finished loading all custom campaign settings/options.");
			}
		}
	}
	public static class CustomCampaignSaving
	{
		private static void initializeCustomCampaignOnce()
		{
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return;
			}
			if (activeCustomCampaign.CampaignSaveCategory == null)
			{
				activeCustomCampaign.CampaignSaveCategory = MelonPreferences.CreateCategory(activeCustomCampaign.CampaignName + activeCustomCampaign.CampaignDesktopName + activeCustomCampaign.CampaignDays);
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedDays") == null)
			{
				activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedDays", 1, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCurrentCaller") == null)
			{
				activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedCurrentCaller", 0, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedEntryTier") == null)
			{
				activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedEntryTier", 1, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCallerArrayLength") == null)
			{
				activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedCallerArrayLength", 0, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			}
			for (int i = 0; i < activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCallerArrayLength").Value; i++)
			{
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>($"savedCallerCorrectAnswer{i}") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>($"savedCallerCorrectAnswer{i}", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedGameFinished") == null)
			{
				activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedGameFinished", 0, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedGameFinishedDisplay") == null)
			{
				activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedGameFinishedDisplay", 0, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			}
			for (int j = 0; j < activeCustomCampaign.CampaignDays + 1; j++)
			{
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>($"SavedDayScore{j}") == null)
				{
					activeCustomCampaign.CampaignSaveCategory.CreateEntry<float>($"SavedDayScore{j}", 0f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
			}
			MelonPreferences.Save();
		}

		public static void SaveCustomCampaignInfo()
		{
			if (!CustomCampaignGlobal.InCustomCampaign)
			{
				LoggingHelper.WarningLog("Called save custom campaign but there is no campaign active.");
				return;
			}
			LoggingHelper.DebugLog("Saving Custom Campaign Info.");
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return;
			}
			if (activeCustomCampaign.CampaignSaveCategory == null)
			{
				activeCustomCampaign.CampaignSaveCategory = MelonPreferences.CreateCategory(activeCustomCampaign.CampaignName + activeCustomCampaign.CampaignDesktopName + activeCustomCampaign.CampaignDays);
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedDays") == null)
			{
				MelonPreferences_Entry<int> val = activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedDays", 1, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				val.Value = activeCustomCampaign.CurrentDay;
			}
			else
			{
				activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedDays").Value = activeCustomCampaign.CurrentDay;
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCurrentCaller") == null)
			{
				MelonPreferences_Entry<int> val2 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedCurrentCaller", 0, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				val2.Value = activeCustomCampaign.SavedCurrentCaller;
			}
			else
			{
				activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCurrentCaller").Value = activeCustomCampaign.SavedCurrentCaller;
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedEntryTier") == null)
			{
				MelonPreferences_Entry<int> val3 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedEntryTier", 1, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				val3.Value = activeCustomCampaign.CurrentPermissionTier;
			}
			else
			{
				activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedEntryTier").Value = activeCustomCampaign.CurrentPermissionTier;
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCallerArrayLength") == null)
			{
				MelonPreferences_Entry<int> val4 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedCallerArrayLength", 0, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				val4.Value = activeCustomCampaign.SavedCallerArrayLength;
			}
			else
			{
				activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCallerArrayLength").Value = activeCustomCampaign.SavedCallerArrayLength;
			}
			for (int i = 0; i < activeCustomCampaign.SavedCallerArrayLength; i++)
			{
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>($"savedCallerCorrectAnswer{i}") == null)
				{
					MelonPreferences_Entry<bool> val5 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>($"savedCallerCorrectAnswer{i}", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					if (activeCustomCampaign.SavedCallersCorrectAnswer.Count > i)
					{
						val5.Value = activeCustomCampaign.SavedCallersCorrectAnswer[i];
					}
					else
					{
						LoggingHelper.WarningLog($"Provided index {i} is not available. " + "(savedCallerCorrectAnswer doesn't exist)");
					}
				}
				else if (activeCustomCampaign.SavedCallersCorrectAnswer.Count > i)
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>($"savedCallerCorrectAnswer{i}").Value = activeCustomCampaign.SavedCallersCorrectAnswer[i];
				}
				else
				{
					LoggingHelper.WarningLog($"Provided index {i} is not available." + " (savedCallerCorrectAnswer exists)");
				}
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedGameFinished") == null)
			{
				MelonPreferences_Entry<int> val6 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedGameFinished", 0, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				val6.Value = activeCustomCampaign.SavedGameFinished;
			}
			else
			{
				activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedGameFinished").Value = activeCustomCampaign.SavedGameFinished;
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedGameFinishedDisplay") == null)
			{
				MelonPreferences_Entry<int> val7 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<int>("savedGameFinishedDisplay", 0, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				val7.Value = activeCustomCampaign.SavedGameFinishedDisplay;
			}
			else
			{
				activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedGameFinishedDisplay").Value = activeCustomCampaign.SavedGameFinishedDisplay;
			}
			for (int j = 0; j < activeCustomCampaign.CampaignDays + 1; j++)
			{
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>($"SavedDayScore{j}") == null)
				{
					MelonPreferences_Entry<float> val8 = activeCustomCampaign.CampaignSaveCategory.CreateEntry<float>($"SavedDayScore{j}", 0f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
					if (activeCustomCampaign.SavedDayScores.Count > j)
					{
						val8.Value = activeCustomCampaign.SavedDayScores[j];
					}
					else
					{
						LoggingHelper.WarningLog($"Provided index {j} is not available. " + "(SavedDayScore doesn't exist)");
					}
				}
				else if (activeCustomCampaign.SavedDayScores.Count > j)
				{
					activeCustomCampaign.CampaignSaveCategory.GetEntry<float>($"SavedDayScore{j}").Value = activeCustomCampaign.SavedDayScores[j];
				}
				else
				{
					LoggingHelper.WarningLog($"Provided index {j} is not available." + " (SavedDayScore exists)");
				}
			}
			MelonPreferences.Save();
			LoggingHelper.InfoLog("Finished saving custom campaign " + activeCustomCampaign.CampaignName + ".");
		}

		public static void LoadFromFileCustomCampaignInfo()
		{
			if (!CustomCampaignGlobal.InCustomCampaign)
			{
				LoggingHelper.WarningLog("Called load custom campaign but there is no campaign active.");
				return;
			}
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return;
			}
			if (activeCustomCampaign.CampaignSaveCategory == null)
			{
				activeCustomCampaign.CampaignSaveCategory = MelonPreferences.CreateCategory(activeCustomCampaign.CampaignName + activeCustomCampaign.CampaignDesktopName + activeCustomCampaign.CampaignDays);
			}
			initializeCustomCampaignOnce();
			activeCustomCampaign.CurrentDay = activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedDays").Value;
			activeCustomCampaign.CurrentPermissionTier = activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedEntryTier").Value;
			activeCustomCampaign.SavedCallerArrayLength = activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCallerArrayLength").Value;
			activeCustomCampaign.SavedCurrentCaller = activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCurrentCaller").Value;
			activeCustomCampaign.SavedGameFinished = activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedGameFinished").Value;
			activeCustomCampaign.SavedGameFinishedDisplay = activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedGameFinishedDisplay").Value;
			for (int i = 0; i < activeCustomCampaign.SavedCallerArrayLength; i++)
			{
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>($"savedCallerCorrectAnswer{i}") != null)
				{
					activeCustomCampaign.SavedCallersCorrectAnswer.Add(activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>($"savedCallerCorrectAnswer{i}").Value);
					continue;
				}
				LoggingHelper.WarningLog($"While loading all saved caller answers, 'savedCallerCorrectAnswer{i}' does not exist!" + $" Setting to 0.0 for {i}.");
				activeCustomCampaign.SavedCallersCorrectAnswer.Add(item: false);
			}
			for (int j = 0; j < activeCustomCampaign.CampaignDays + 1; j++)
			{
				if (activeCustomCampaign.CampaignSaveCategory.GetEntry<float>($"SavedDayScore{j}") != null)
				{
					activeCustomCampaign.SavedDayScores.Add(activeCustomCampaign.CampaignSaveCategory.GetEntry<float>($"SavedDayScore{j}").Value);
					continue;
				}
				LoggingHelper.WarningLog("While loading all saved caller answers, " + $"'SavedDayScore{j}' was not found! " + $"Setting score to 0.0f for {j}.");
				activeCustomCampaign.SavedDayScores.Add(0f);
			}
			GlobalVariables.saveManagerScript.savedDay = activeCustomCampaign.CurrentDay;
			GlobalVariables.currentDay = activeCustomCampaign.CurrentDay;
			GlobalVariables.saveManagerScript.savedCurrentCaller = activeCustomCampaign.SavedCurrentCaller;
			GlobalVariables.saveManagerScript.savedEntryTier = activeCustomCampaign.CurrentPermissionTier;
			GlobalVariables.saveManagerScript.savedCallerArrayLength = activeCustomCampaign.SavedCallerArrayLength;
			bool[] array = new bool[activeCustomCampaign.SavedCallerArrayLength];
			for (int k = 0; k < activeCustomCampaign.SavedCallerArrayLength; k++)
			{
				MelonPreferences_Entry<bool> val = activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>($"savedCallerCorrectAnswer{k}");
				if (val == null)
				{
					val = activeCustomCampaign.CampaignSaveCategory.CreateEntry<bool>($"savedCallerCorrectAnswer{k}", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
				}
				array[k] = val.Value;
			}
			GlobalVariables.saveManagerScript.savedCallerCorrectAnswers = array;
			GlobalVariables.saveManagerScript.savedGameFinished = activeCustomCampaign.SavedGameFinished;
			GlobalVariables.saveManagerScript.savedGameFinishedDisplay = activeCustomCampaign.SavedGameFinishedDisplay;
			for (int l = 0; l < Mathf.Min(7, activeCustomCampaign.CampaignDays + 1); l++)
			{
				switch (l)
				{
				case 0:
					GlobalVariables.saveManagerScript.savedDayScore1 = activeCustomCampaign.SavedDayScores[l];
					break;
				case 1:
					GlobalVariables.saveManagerScript.savedDayScore2 = activeCustomCampaign.SavedDayScores[l];
					break;
				case 2:
					GlobalVariables.saveManagerScript.savedDayScore3 = activeCustomCampaign.SavedDayScores[l];
					break;
				case 3:
					GlobalVariables.saveManagerScript.savedDayScore4 = activeCustomCampaign.SavedDayScores[l];
					break;
				case 4:
					GlobalVariables.saveManagerScript.savedDayScore5 = activeCustomCampaign.SavedDayScores[l];
					break;
				case 5:
					GlobalVariables.saveManagerScript.savedDayScore6 = activeCustomCampaign.SavedDayScores[l];
					break;
				case 6:
					GlobalVariables.saveManagerScript.savedDayScore7 = activeCustomCampaign.SavedDayScores[l];
					break;
				}
			}
			LoggingHelper.InfoLog("Finished loading all custom campaign values.");
		}

		public static void ResetCustomCampaignFile()
		{
			LoggingHelper.InfoLog("Resetting custom campaign file.");
			if (!CustomCampaignGlobal.InCustomCampaign)
			{
				LoggingHelper.WarningLog("Called reset custom campaign but there is no campaign active.");
				return;
			}
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return;
			}
			if (activeCustomCampaign.CampaignSaveCategory == null)
			{
				LoggingHelper.DebugLog("Loading values before saving.");
				LoadFromFileCustomCampaignInfo();
			}
			if (activeCustomCampaign.CampaignSaveCategory == null)
			{
				LoggingHelper.ErrorLog("Tried resetting but save is still null!");
				return;
			}
			if (activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedDays") == null)
			{
				LoggingHelper.ErrorLog("Tried resetting when no save is available!");
				return;
			}
			activeCustomCampaign.CurrentDay = 1;
			activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedDays").Value = 1;
			activeCustomCampaign.CurrentPermissionTier = 1;
			activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedEntryTier").Value = 1;
			activeCustomCampaign.SavedCurrentCaller = 0;
			activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCurrentCaller").Value = 0;
			activeCustomCampaign.SavedCallersCorrectAnswer = new List<bool>();
			for (int i = 0; i < activeCustomCampaign.SavedCallerArrayLength; i++)
			{
				activeCustomCampaign.CampaignSaveCategory.DeleteEntry($"savedCallerCorrectAnswer{i}");
			}
			activeCustomCampaign.SavedDayScores = new List<float>();
			for (int j = 0; j < activeCustomCampaign.CampaignDays + 1; j++)
			{
				activeCustomCampaign.CampaignSaveCategory.DeleteEntry($"SavedDayScore{j}");
			}
			activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedCallerArrayLength").Value = 0;
			activeCustomCampaign.SavedCallerArrayLength = 0;
			bool flag = false;
			if (activeCustomCampaign.ShouldResetGameBeatenVariableOnReset.HasChanged)
			{
				flag = activeCustomCampaign.ShouldResetGameBeatenVariableOnReset.Data;
			}
			if (flag)
			{
				activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedGameFinished").Value = 0;
				activeCustomCampaign.SavedGameFinished = 0;
			}
			activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedGameFinishedDisplay").Value = 0;
			activeCustomCampaign.SavedGameFinishedDisplay = 0;
			activeCustomCampaign.CampaignSaveCategory.GetEntry<int>("savedColorTheme").Value = 0;
			activeCustomCampaign.ActiveTheme = 0;
			activeCustomCampaign.CampaignSaveCategory.GetEntry<bool>("themeShownOnce").Value = false;
			activeCustomCampaign.DefaultThemeAppliedOnce = false;
			LoggingHelper.InfoLog("Finished resetting values for the custom campaign " + activeCustomCampaign.CampaignName + ".");
		}
	}
	public static class OptionUpdatePatches
	{
		[HarmonyPatch(typeof(OptionsMenuBehavior), "OnMusicSliderChange")]
		public static class OnMusicSliderChangePatch
		{
			private static bool Prefix(OptionsMenuBehavior __instance)
			{
				GlobalVariables.saveManagerScript.savedMusicVolume = __instance.musicSlider.value;
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedMusicVolume = __instance.musicSlider.value;
				}
				if (Mathf.Approximately(__instance.musicSlider.value, __instance.musicSlider.minValue))
				{
					__instance.masterMixer.SetFloat("musicVol", -80f);
				}
				else
				{
					__instance.masterMixer.SetFloat("musicVol", Mathf.Log10(__instance.musicSlider.value) * 20f);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "OnSFXSliderChange")]
		public static class OnSFXSliderChangePatch
		{
			private static bool Prefix(OptionsMenuBehavior __instance)
			{
				GlobalVariables.saveManagerScript.savedSFXVolume = __instance.sfxSlider.value;
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedSFXVolume = __instance.sfxSlider.value;
				}
				if (Mathf.Approximately(__instance.sfxSlider.value, __instance.sfxSlider.minValue))
				{
					__instance.masterMixer.SetFloat("sfxVol", -80f);
				}
				else
				{
					__instance.masterMixer.SetFloat("sfxVol", Mathf.Log10(__instance.sfxSlider.value) * 20f);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "OnMasterSliderChange")]
		public static class OnMasterSliderChangePatch
		{
			private static bool Prefix(OptionsMenuBehavior __instance)
			{
				GlobalVariables.saveManagerScript.savedAmbienceVolume = __instance.masterSlider.value;
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedAmbienceVolume = __instance.masterSlider.value;
				}
				if (Mathf.Approximately(__instance.masterSlider.value, __instance.masterSlider.minValue))
				{
					__instance.masterMixer.SetFloat("masterVol", -80f);
				}
				else
				{
					__instance.masterMixer.SetFloat("masterVol", Mathf.Log10(__instance.masterSlider.value) * 20f);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "CRTToggle", new Type[] { typeof(bool) })]
		public static class CRTTogglePatch
		{
			private static bool Prefix(ref bool value)
			{
				GlobalVariables.saveManagerScript.savedCRTToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedCRTToggle = value;
				}
				if ((Object)(object)GlobalVariables.crtShader == (Object)null)
				{
					return false;
				}
				GlobalVariables.crtShader.scanlineIntensity = (value ? 8f : 0f);
				return false;
			}
		}

		[HarmonyPatch(typeof(ScreenResolutions), "FullScreenToggle")]
		public static class FullScreenTogglePatch
		{
			private static bool Prefix(ScreenResolutions __instance)
			{
				GlobalVariables.isFullScreen = __instance.fullScreenToggle.isOn;
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedFullScreenToggle = __instance.fullScreenToggle.isOn;
				}
				Screen.fullScreen = GlobalVariables.isFullScreen;
				__instance.SaveResolutionInfo();
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "DyslexiaToggle", new Type[] { typeof(bool) })]
		public static class DyslexiaTogglePatch
		{
			private static bool Prefix(ref bool value)
			{
				GlobalVariables.saveManagerScript.savedDyslexiaToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedDyslexiaToggle = value;
				}
				GlobalVariables.dyslexiaMode = value;
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "OnTextSizeSliderChange")]
		public static class OnTextSizeSliderChangePatch
		{
			private static bool Prefix(OptionsMenuBehavior __instance)
			{
				GlobalVariables.textSizeMultiplier = __instance.textSizeSlider.value;
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedTextSizeMultiplier = __instance.textSizeSlider.value;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "SpiderToggle", new Type[] { typeof(bool) })]
		public static class SpiderTogglePatch
		{
			private static bool Prefix(ref bool value)
			{
				GlobalVariables.saveManagerScript.savedSpiderToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedSpiderToggle = value;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "InsectToggle", new Type[] { typeof(bool) })]
		public static class InsectTogglePatch
		{
			private static bool Prefix(ref bool value)
			{
				GlobalVariables.saveManagerScript.savedInsectToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedInsectToggle = value;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "DarkToggle", new Type[] { typeof(bool) })]
		public static class DarkTogglePatch
		{
			private static bool Prefix(ref bool value)
			{
				GlobalVariables.saveManagerScript.savedDarkToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedDarkToggle = value;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "HoleToggle", new Type[] { typeof(bool) })]
		public static class HoleTogglePatch
		{
			private static bool Prefix(ref bool value)
			{
				GlobalVariables.saveManagerScript.savedHoleToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedHoleToggle = value;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "WatchToggle", new Type[] { typeof(bool) })]
		public static class WatchTogglePatch
		{
			private static bool Prefix(ref bool value)
			{
				GlobalVariables.saveManagerScript.savedWatchToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedWatchToggle = value;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "TightToggle", new Type[] { typeof(bool) })]
		public static class TightTogglePatch
		{
			private static bool Prefix(ref bool value)
			{
				GlobalVariables.saveManagerScript.savedTightToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedTightToggle = value;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "DogToggle", new Type[] { typeof(bool) })]
		public static class DogTogglePatch
		{
			private static bool Prefix(ref bool value)
			{
				GlobalVariables.saveManagerScript.savedDogToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedDogToggle = value;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "CallSkipToggle", new Type[] { typeof(bool) })]
		public static class CallSkipTogglePatch
		{
			private static bool Prefix(OptionsMenuBehavior __instance, ref bool value)
			{
				GlobalVariables.saveManagerScript.savedCallSkipToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedCallSkipToggle = value;
				}
				if ((Object)(object)__instance.callSkipButton == (Object)null)
				{
					return false;
				}
				__instance.callSkipButton.SetActive(value);
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "ImmunityToggle", new Type[] { typeof(bool) })]
		public static class ImmunityTogglePatch
		{
			private static bool Prefix(ref bool value)
			{
				GlobalVariables.saveManagerScript.savedImmunityToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedImmunityToggle = value;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "AccuracyToggle", new Type[] { typeof(bool) })]
		public static class AccuracyTogglePatch
		{
			private static bool Prefix(OptionsMenuBehavior __instance, ref bool value)
			{
				GlobalVariables.saveManagerScript.savedAccuracyToggle = GlobalVariables.saveManagerScript.BoolToInt(value);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					activeCustomCampaign.SavedAccuracyToggle = value;
				}
				if ((Object)(object)__instance.accuracyText != (Object)null)
				{
					return false;
				}
				__instance.accuracyText.gameObject.SetActive(value);
				return false;
			}
		}
	}
	public static class SavingSettingPatches
	{
		[HarmonyPatch(typeof(SaveManagerBehavior), "SaveOptions")]
		public static class SaveOptionsPatch
		{
			private static bool Prefix(SaveManagerBehavior __instance)
			{
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					PlayerPrefs.SetInt("SavedSpiderToggle", __instance.savedSpiderToggle);
					PlayerPrefs.SetInt("SavedInsectToggle", __instance.savedInsectToggle);
					PlayerPrefs.SetInt("SavedDarkToggle", __instance.savedDarkToggle);
					PlayerPrefs.SetInt("SavedHoleToggle", __instance.savedHoleToggle);
					PlayerPrefs.SetInt("SavedWatchToggle", __instance.savedWatchToggle);
					PlayerPrefs.SetInt("SavedDogToggle", __instance.savedDogToggle);
					PlayerPrefs.SetInt("SavedTightToggle", __instance.savedTightToggle);
					PlayerPrefs.SetInt("SavedDyslexiaToggle", __instance.savedDyslexiaToggle);
				}
				if (GlobalVariables.isXmasDLC)
				{
					if (SaveXmasOptions == null)
					{
						LoggingHelper.ReflectionError("SaveXmasOptions");
						return true;
					}
					SaveXmasOptions.Invoke(__instance, null);
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					PlayerPrefs.SetInt("SavedImmunityToggle", __instance.savedImmunityToggle);
					PlayerPrefs.SetInt("SavedAccuracyToggle", __instance.savedAccuracyToggle);
					PlayerPrefs.SetInt("SavedCallSkipToggle", __instance.savedCallSkipToggle);
					__instance.savedScreenHeight = GlobalVariables.screenHeightSetting;
					__instance.savedScreenWidth = GlobalVariables.screenWidthSetting;
					PlayerPrefs.SetInt("SavedScreenHeight", __instance.savedScreenHeight);
					PlayerPrefs.SetInt("SavedScreenWidth", __instance.savedScreenWidth);
					__instance.savedRefreshRate = GlobalVariables.refreshRateSetting;
					PlayerPrefs.SetInt("SavedRefreshRate", __instance.savedRefreshRate);
					__instance.savedTextSizeMultiplier = GlobalVariables.textSizeMultiplier;
					PlayerPrefs.SetFloat("SavedTextSizeMultiplier", __instance.savedTextSizeMultiplier);
					__instance.savedFullScreenToggle = __instance.BoolToInt(GlobalVariables.isFullScreen);
					PlayerPrefs.SetInt("SavedFullScreenToggle", __instance.savedFullScreenToggle);
					PlayerPrefs.SetInt("SavedCRTToggle", __instance.savedCRTToggle);
					PlayerPrefs.SetFloat("SavedMusicVolume", __instance.savedMusicVolume);
					PlayerPrefs.SetFloat("SavedSFXVolume", __instance.savedSFXVolume);
					PlayerPrefs.SetFloat("SavedAmbienceVolume", __instance.savedAmbienceVolume);
					PlayerPrefs.SetInt("SavedColorTheme", __instance.savedColorTheme);
				}
				else
				{
					CustomCampaignOptionSaving.SaveCustomCampaignOptions();
				}
				PlayerPrefs.Save();
				return false;
			}
		}

		[HarmonyPatch(typeof(OptionsMenuBehavior), "LoadSavedValues")]
		public static class LoadSavedValuesPatch
		{
			private static bool Prefix(OptionsMenuBehavior __instance)
			{
				if (!GlobalVariables.saveManagerScript.hasLoaded)
				{
					return false;
				}
				__instance.xmasImmunityToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedImmunityToggle);
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					__instance.immunityToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedImmunityToggle);
					__instance.accuracyToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedAccuracyToggle);
					__instance.callSkipToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedCallSkipToggle);
					__instance.spiderToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedSpiderToggle);
					__instance.insectToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedInsectToggle);
					__instance.darkToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedDarkToggle);
					__instance.holeToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedHoleToggle);
					__instance.watchToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedWatchToggle);
					__instance.tightToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedTightToggle);
					__instance.dogToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedDogToggle);
					__instance.dyslexiaToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedDyslexiaToggle);
					__instance.textSizeSlider.value = GlobalVariables.saveManagerScript.savedTextSizeMultiplier;
					__instance.crtToggle.isOn = GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedCRTToggle);
					__instance.musicSlider.value = GlobalVariables.saveManagerScript.savedMusicVolume;
					__instance.sfxSlider.value = GlobalVariables.saveManagerScript.savedSFXVolume;
					__instance.masterSlider.value = GlobalVariables.saveManagerScript.savedAmbienceVolume;
					__instance.colorDropdown.value = GlobalVariables.saveManagerScript.savedColorTheme;
					__instance.ColorThemeChanged();
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return false;
					}
					__instance.immunityToggle.isOn = activeCustomCampaign.SavedImmunityToggle;
					__instance.accuracyToggle.isOn = activeCustomCampaign.SavedAccuracyToggle;
					__instance.callSkipToggle.isOn = activeCustomCampaign.SavedCallSkipToggle;
					__instance.spiderToggle.isOn = activeCustomCampaign.SavedSpiderToggle;
					__instance.insectToggle.isOn = activeCustomCampaign.SavedInsectToggle;
					__instance.darkToggle.isOn = activeCustomCampaign.SavedDarkToggle;
					__instance.holeToggle.isOn = activeCustomCampaign.SavedHoleToggle;
					__instance.watchToggle.isOn = activeCustomCampaign.SavedWatchToggle;
					__instance.tightToggle.isOn = activeCustomCampaign.SavedTightToggle;
					__instance.dogToggle.isOn = activeCustomCampaign.SavedDogToggle;
					__instance.dyslexiaToggle.isOn = activeCustomCampaign.SavedDyslexiaToggle;
					__instance.textSizeSlider.value = activeCustomCampaign.SavedTextSizeMultiplier;
					__instance.crtToggle.isOn = activeCustomCampaign.SavedCRTToggle;
					__instance.musicSlider.value = activeCustomCampaign.SavedMusicVolume;
					__instance.sfxSlider.value = activeCustomCampaign.SavedSFXVolume;
					__instance.masterSlider.value = activeCustomCampaign.SavedAmbienceVolume;
					__instance.colorDropdown.value = activeCustomCampaign.ActiveTheme;
					__instance.ColorThemeChanged();
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(LogoManager), "LoadVideoSettings")]
		public static class LoadVideoSettingsPatch
		{
			private static bool Prefix()
			{
				if (GlobalVariables.saveManagerScript.savedScreenHeight == 0)
				{
					return false;
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					Screen.SetResolution(GlobalVariables.saveManagerScript.savedScreenWidth, GlobalVariables.saveManagerScript.savedScreenHeight, GlobalVariables.saveManagerScript.IntToBool(GlobalVariables.saveManagerScript.savedFullScreenToggle));
					Application.targetFrameRate = GlobalVariables.refreshRateSetting;
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					Screen.SetResolution(activeCustomCampaign.SavedScreenWidth, activeCustomCampaign.SavedScreenHeight, activeCustomCampaign.SavedFullScreenToggle, activeCustomCampaign.SavedRefreshRate);
					if (GlobalPreferences.Vsync.Value)
					{
						QualitySettings.vSyncCount = 1;
					}
					else
					{
						QualitySettings.vSyncCount = 0;
					}
					Application.targetFrameRate = activeCustomCampaign.SavedRefreshRate;
					LoggingHelper.DebugLog($"Load video settings: {activeCustomCampaign.SavedScreenHeight} and {activeCustomCampaign.SavedScreenWidth} and {activeCustomCampaign.SavedFullScreenToggle}.");
					LoggingHelper.DebugLog($"Target Frame Rate: {Application.targetFrameRate}");
				}
				return false;
			}
		}

		private static readonly MethodInfo SaveXmasOptions = typeof(SaveManagerBehavior).GetMethod("SaveXmasOptions", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
	}
	public static class SpecialOptionUpdatePatches
	{
		[HarmonyPatch(typeof(ScreenResolutions), "OnEnable")]
		public static class OnEnablePatch
		{
			private static bool Prefix(ScreenResolutions __instance)
			{
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					if (GlobalVariables.screenWidthSetting == 0)
					{
						return false;
					}
					__instance.SetMenuValue(GlobalVariables.screenWidthSetting, GlobalVariables.screenHeightSetting, GlobalVariables.refreshRateSetting);
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					if (activeCustomCampaign.SavedScreenWidth == 0)
					{
						return false;
					}
					__instance.SetMenuValue(activeCustomCampaign.SavedScreenWidth, activeCustomCampaign.SavedScreenHeight, activeCustomCampaign.SavedRefreshRate);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(ScreenResolutions), "Start")]
		public static class ScreenResolutionsStartPatch
		{
			private static readonly FieldInfo ResolutionsField = typeof(ScreenResolutions).GetField("resolutions", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo ResToString = typeof(ScreenResolutions).GetMethod("ResToString", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo SetSteamDeckResolution = typeof(ScreenResolutions).GetMethod("SetSteamDeckResolution", BindingFlags.Instance | BindingFlags.NonPublic);

			private static readonly FieldInfo JustStarted = typeof(ScreenResolutions).GetField("justStarted", BindingFlags.Static | BindingFlags.NonPublic);

			private static bool Prefix(ScreenResolutions __instance)
			{
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Expected O, but got Unknown
				//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_021d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0227: Expected O, but got Unknown
				if (ResolutionsField == null || ResToString == null || JustStarted == null || SetSteamDeckResolution == null)
				{
					LoggingHelper.ReflectionError("ResolutionsField", "ResToString", "SetSteamDeckResolution", "JustStarted");
					return true;
				}
				Resolution[] resolutions = (Resolution[])ResolutionsField.GetValue(__instance);
				__instance.dropdownMenu.options.Clear();
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					for (int i = 0; i < resolutions.Length; i++)
					{
						string text = (string)ResToString.Invoke(__instance, new object[1] { resolutions[i] });
						__instance.dropdownMenu.options.Add(new OptionData(text));
						if (((Resolution)(ref resolutions[i])).width == GlobalVariables.screenWidthSetting && ((Resolution)(ref resolutions[i])).height == GlobalVariables.screenHeightSetting && ((Resolution)(ref resolutions[i])).refreshRate == GlobalVariables.refreshRateSetting)
						{
							__instance.dropdownMenu.value = i;
						}
					}
					__instance.fullScreenToggle.isOn = GlobalVariables.isFullScreen;
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					for (int j = 0; j < resolutions.Length; j++)
					{
						string text2 = (string)ResToString.Invoke(__instance, new object[1] { resolutions[j] });
						__instance.dropdownMenu.options.Add(new OptionData(text2));
						if (((Resolution)(ref resolutions[j])).width == activeCustomCampaign.SavedScreenWidth && ((Resolution)(ref resolutions[j])).height == activeCustomCampaign.SavedScreenHeight && ((Resolution)(ref resolutions[j])).refreshRate == activeCustomCampaign.SavedRefreshRate)
						{
							__instance.dropdownMenu.value = j;
						}
					}
					__instance.fullScreenToggle.isOn = activeCustomCampaign.SavedFullScreenToggle;
				}
				((UnityEvent<int>)(object)__instance.dropdownMenu.onValueChanged).AddListener((UnityAction<int>)delegate
				{
					__instance.SetDropdownResolution(((Resolution)(ref resolutions[__instance.dropdownMenu.value])).width, ((Resolution)(ref resolutions[__instance.dropdownMenu.value])).height, ((Resolution)(ref resolutions[__instance.dropdownMenu.value])).refreshRate);
				});
				JustStarted.SetValue(__instance, false);
				SetSteamDeckResolution.Invoke(__instance, null);
				return false;
			}
		}

		[HarmonyPatch(typeof(ScreenResolutions), "SaveResolutionInfo")]
		public static class SaveResolutionInfoPatch
		{
			private static bool Prefix()
			{
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					if (GlobalVariables.screenWidthSetting >= 480 && GlobalVariables.screenHeightSetting >= 480)
					{
						Screen.SetResolution(GlobalVariables.screenWidthSetting, GlobalVariables.screenHeightSetting, GlobalVariables.isFullScreen, GlobalVariables.refreshRateSetting);
						if (GlobalPreferences.Vsync.Value)
						{
							QualitySettings.vSyncCount = 1;
						}
						else
						{
							QualitySettings.vSyncCount = 0;
						}
						Application.targetFrameRate = GlobalVariables.refreshRateSetting;
						LoggingHelper.DebugLog("Saved Resolution: " + GlobalVariables.screenWidthSetting + "x" + GlobalVariables.screenHeightSetting + " @" + GlobalVariables.refreshRateSetting);
						LoggingHelper.DebugLog($"Target Frame Rate: {Application.targetFrameRate}");
					}
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					if (activeCustomCampaign.SavedScreenWidth >= 480 && activeCustomCampaign.SavedScreenHeight >= 480)
					{
						Screen.SetResolution(activeCustomCampaign.SavedScreenWidth, activeCustomCampaign.SavedScreenHeight, activeCustomCampaign.SavedFullScreenToggle, activeCustomCampaign.SavedRefreshRate);
						if (GlobalPreferences.Vsync.Value)
						{
							QualitySettings.vSyncCount = 1;
						}
						else
						{
							QualitySettings.vSyncCount = 0;
						}
						Application.targetFrameRate = activeCustomCampaign.SavedRefreshRate;
						LoggingHelper.DebugLog("Saved Resolution: " + GlobalVariables.screenWidthSetting + "x" + GlobalVariables.screenHeightSetting + " @" + GlobalVariables.refreshRateSetting);
						LoggingHelper.DebugLog($"Target Frame Rate: {Application.targetFrameRate}");
					}
				}
				GlobalVariables.saveManagerScript.SaveOptions();
				return false;
			}
		}

		[HarmonyPatch(typeof(ScreenResolutions), "SetDropdownResolution", new Type[]
		{
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		public static class SetDropdownResolutionPatch
		{
			private static readonly FieldInfo ResolutionsField = typeof(ScreenResolutions).GetField("resolutions", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly FieldInfo JustStartedField = typeof(ScreenResolutions).GetField("justStarted", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(ScreenResolutions __instance, ref int width, ref int height, ref int refresh)
			{
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				if (ResolutionsField == null || JustStartedField == null)
				{
					LoggingHelper.ReflectionError("ResolutionsField", "JustStartedField");
					return true;
				}
				Resolution[] array = (Resolution[])ResolutionsField.GetValue(__instance);
				if ((bool)JustStartedField.GetValue(__instance))
				{
					return false;
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					for (int i = 0; i < array.Length; i++)
					{
						Resolution val = array[i];
						if (((Resolution)(ref val)).width == width && ((Resolution)(ref val)).height == height && ((Resolution)(ref val)).refreshRate == refresh)
						{
							__instance.dropdownMenu.value = i;
							GlobalVariables.refreshRateSetting = refresh;
							GlobalVariables.screenHeightSetting = height;
							GlobalVariables.screenWidthSetting = width;
							break;
						}
					}
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					for (int j = 0; j < array.Length; j++)
					{
						Resolution val2 = array[j];
						if (((Resolution)(ref val2)).width == width && ((Resolution)(ref val2)).height == height && ((Resolution)(ref val2)).refreshRate == refresh)
						{
							__instance.dropdownMenu.value = j;
							activeCustomCampaign.SavedRefreshRate = refresh;
							activeCustomCampaign.SavedScreenHeight = height;
							activeCustomCampaign.SavedScreenWidth = width;
							break;
						}
					}
				}
				__instance.SaveResolutionInfo();
				return false;
			}
		}
	}
	public static class SavingManagerPatchesCC
	{
		[HarmonyPatch(typeof(SaveManagerBehavior), "SaveGameProgress")]
		public static class SaveGameProgressPatch
		{
			private static readonly MethodInfo SaveXmasGameProgress = typeof(SaveManagerBehavior).GetMethod("SaveXmasGameProgress", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(SaveManagerBehavior __instance)
			{
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaignSaving.SaveCustomCampaignInfo();
				}
				else if (GlobalVariables.isXmasDLC)
				{
					if (SaveXmasGameProgress == null)
					{
						LoggingHelper.ReflectionError("SaveXmasGameProgress");
						return true;
					}
					SaveXmasGameProgress.Invoke(__instance, null);
				}
				else
				{
					PlayerPrefs.SetInt("SavedDay", __instance.savedDay);
					PlayerPrefs.SetInt("SavedCurrentCaller", __instance.savedCurrentCaller);
					PlayerPrefs.SetInt("SavedEntryTier", __instance.savedEntryTier);
					PlayerPrefs.SetInt("SavedCallerArrayLength", __instance.savedCallerArrayLength);
					__instance.SaveBoolArray("SavedCallerCorrectAnswer", __instance.savedCallerCorrectAnswers);
					PlayerPrefs.Save();
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(SaveManagerBehavior), "SaveGameFinished")]
		public static class SaveGameFinishedPatch
		{
			private static readonly MethodInfo SaveXmasGameFinished = typeof(SaveManagerBehavior).GetMethod("SaveXmasGameFinished", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(SaveManagerBehavior __instance)
			{
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaignSaving.SaveCustomCampaignInfo();
				}
				else if (GlobalVariables.isXmasDLC)
				{
					if (SaveXmasGameFinished == null)
					{
						LoggingHelper.ReflectionError("SaveXmasGameFinished");
						return true;
					}
					SaveXmasGameFinished.Invoke(__instance, null);
				}
				else
				{
					PlayerPrefs.SetInt("SavedGameFinished", __instance.savedGameFinished);
					PlayerPrefs.SetInt("SavedGameFinishedDisplay", __instance.savedGameFinishedDisplay);
					PlayerPrefs.Save();
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(SaveManagerBehavior), "Load")]
		public static class LoadPatch
		{
			private static readonly MethodInfo LoadXmas = typeof(SaveManagerBehavior).GetMethod("LoadXmas", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(SaveManagerBehavior __instance)
			{
				__instance.hasLoaded = false;
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					LoggingHelper.DebugLog("Loading values due to game loading values.");
					CustomCampaignSaving.LoadFromFileCustomCampaignInfo();
				}
				else if (GlobalVariables.isXmasDLC)
				{
					if (LoadXmas == null)
					{
						LoggingHelper.ReflectionError("LoadXmas");
						return true;
					}
					LoadXmas.Invoke(__instance, null);
				}
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaignOptionSaving.LoadCustomCampaignOptions();
				}
				else if (!GlobalVariables.isXmasDLC)
				{
					if (PlayerPrefs.HasKey("SavedImmunityToggle"))
					{
						__instance.savedImmunityToggle = PlayerPrefs.GetInt("SavedImmunityToggle", 0);
					}
					if (PlayerPrefs.HasKey("SavedAccuracyToggle"))
					{
						__instance.savedAccuracyToggle = PlayerPrefs.GetInt("SavedAccuracyToggle", 0);
					}
					if (PlayerPrefs.HasKey("SavedCallSkipToggle"))
					{
						__instance.savedCallSkipToggle = PlayerPrefs.GetInt("SavedCallSkipToggle", 0);
					}
					if (PlayerPrefs.HasKey("SavedScreenHeight"))
					{
						__instance.savedScreenHeight = PlayerPrefs.GetInt("SavedScreenHeight");
					}
					GlobalVariables.screenHeightSetting = __instance.savedScreenHeight;
					if (PlayerPrefs.HasKey("SavedScreenWidth"))
					{
						__instance.savedScreenWidth = PlayerPrefs.GetInt("SavedScreenWidth");
					}
					GlobalVariables.screenWidthSetting = __instance.savedScreenWidth;
					if (PlayerPrefs.HasKey("SavedRefreshRate"))
					{
						__instance.savedRefreshRate = PlayerPrefs.GetInt("SavedRefreshRate");
					}
					GlobalVariables.refreshRateSetting = __instance.savedRefreshRate;
					if (PlayerPrefs.HasKey("SavedSpiderToggle"))
					{
						__instance.savedSpiderToggle = PlayerPrefs.GetInt("SavedSpiderToggle");
					}
					if (PlayerPrefs.HasKey("SavedInsectToggle"))
					{
						__instance.savedInsectToggle = PlayerPrefs.GetInt("SavedInsectToggle");
					}
					if (PlayerPrefs.HasKey("SavedDarkToggle"))
					{
						__instance.savedDarkToggle = PlayerPrefs.GetInt("SavedDarkToggle");
					}
					if (PlayerPrefs.HasKey("SavedHoleToggle"))
					{
						__instance.savedHoleToggle = PlayerPrefs.GetInt("SavedHoleToggle");
					}
					if (PlayerPrefs.HasKey("SavedWatchToggle"))
					{
						__instance.savedWatchToggle = PlayerPrefs.GetInt("SavedWatchToggle");
					}
					if (PlayerPrefs.HasKey("SavedDogToggle"))
					{
						__instance.savedDogToggle = PlayerPrefs.GetInt("SavedDogToggle");
					}
					if (PlayerPrefs.HasKey("SavedTightToggle"))
					{
						__instance.savedTightToggle = PlayerPrefs.GetInt("SavedTightToggle");
					}
					if (PlayerPrefs.HasKey("SavedDay"))
					{
						__instance.savedDay = PlayerPrefs.GetInt("SavedDay");
					}
					GlobalVariables.currentDay = __instance.savedDay;
					if (PlayerPrefs.HasKey("SavedCurrentCaller"))
					{
						__instance.savedCurrentCaller = PlayerPrefs.GetInt("SavedCurrentCaller");
					}
					if (PlayerPrefs.HasKey("SavedEntryTier"))
					{
						__instance.savedEntryTier = PlayerPrefs.GetInt("SavedEntryTier");
					}
					if (PlayerPrefs.HasKey("SavedCallerArrayLength"))
					{
						__instance.savedCallerArrayLength = PlayerPrefs.GetInt("SavedCallerArrayLength");
					}
					__instance.savedCallerCorrectAnswers = __instance.LoadBoolArray("SavedCallerCorrectAnswer", __instance.savedCallerArrayLength);
					if (PlayerPrefs.HasKey("SavedDyslexiaToggle"))
					{
						__instance.savedDyslexiaToggle = PlayerPrefs.GetInt("SavedDyslexiaToggle");
					}
					GlobalVariables.dyslexiaMode = __instance.IntToBool(__instance.savedDyslexiaToggle);
					if (PlayerPrefs.HasKey("SavedTextSizeMultiplier"))
					{
						__instance.savedTextSizeMultiplier = PlayerPrefs.GetFloat("SavedTextSizeMultiplier");
					}
					GlobalVariables.textSizeMultiplier = __instance.savedTextSizeMultiplier;
					if (PlayerPrefs.HasKey("SavedFullScreenToggle"))
					{
						__instance.savedFullScreenToggle = PlayerPrefs.GetInt("SavedFullScreenToggle");
					}
					GlobalVariables.isFullScreen = __instance.IntToBool(__instance.savedFullScreenToggle);
					if (PlayerPrefs.HasKey("SavedCRTToggle"))
					{
						__instance.savedCRTToggle = PlayerPrefs.GetInt("SavedCRTToggle", 1);
					}
					if (PlayerPrefs.HasKey("SavedMusicVolume"))
					{
						__instance.savedMusicVolume = PlayerPrefs.GetFloat("SavedMusicVolume");
					}
					if (PlayerPrefs.HasKey("SavedSFXVolume"))
					{
						__instance.savedSFXVolume = PlayerPrefs.GetFloat("SavedSFXVolume");
					}
					if (PlayerPrefs.HasKey("SavedAmbienceVolume"))
					{
						__instance.savedAmbienceVolume = PlayerPrefs.GetFloat("SavedAmbienceVolume");
					}
					if (PlayerPrefs.HasKey("SavedColorTheme"))
					{
						__instance.savedColorTheme = PlayerPrefs.GetInt("SavedColorTheme");
					}
					if (Object.op_Implicit((Object)(object)GlobalVariables.colorPaletteController))
					{
						GlobalVariables.colorPaletteController.UpdateColorTheme();
					}
					if (PlayerPrefs.HasKey("SavedGameFinished"))
					{
						__instance.savedGameFinished = PlayerPrefs.GetInt("SavedGameFinished");
					}
					if (PlayerPrefs.HasKey("SavedGameFinishedDisplay"))
					{
						__instance.savedGameFinishedDisplay = PlayerPrefs.GetInt("SavedGameFinishedDisplay");
					}
					if (PlayerPrefs.HasKey("SavedDayScore1"))
					{
						__instance.savedDayScore1 = PlayerPrefs.GetFloat("SavedDayScore1");
					}
					if (PlayerPrefs.HasKey("SavedDayScore2"))
					{
						__instance.savedDayScore2 = PlayerPrefs.GetFloat("SavedDayScore2");
					}
					if (PlayerPrefs.HasKey("SavedDayScore3"))
					{
						__instance.savedDayScore3 = PlayerPrefs.GetFloat("SavedDayScore3");
					}
					if (PlayerPrefs.HasKey("SavedDayScore4"))
					{
						__instance.savedDayScore4 = PlayerPrefs.GetFloat("SavedDayScore4");
					}
					if (PlayerPrefs.HasKey("SavedDayScore5"))
					{
						__instance.savedDayScore5 = PlayerPrefs.GetFloat("SavedDayScore5");
					}
					if (PlayerPrefs.HasKey("SavedDayScore6"))
					{
						__instance.savedDayScore6 = PlayerPrefs.GetFloat("SavedDayScore6");
					}
					if (PlayerPrefs.HasKey("SavedDayScore7"))
					{
						__instance.savedDayScore7 = PlayerPrefs.GetFloat("SavedDayScore7");
					}
					if (PlayerPrefs.HasKey("SavedArcadeScore"))
					{
						__instance.savedArcadeScore = PlayerPrefs.GetFloat("SavedArcadeScore");
					}
				}
				__instance.hasLoaded = true;
				if (__instance.PostLoadEvent == null)
				{
					return false;
				}
				__instance.PostLoadEvent.Invoke();
				return false;
			}
		}

		[HarmonyPatch(typeof(SaveManagerBehavior), "DeleteGameProgress")]
		public static class DeleteGameProgressPatch
		{
			private static readonly MethodInfo DeleteXmasGameProgress = typeof(SaveManagerBehavior).GetMethod("DeleteXmasGameProgress", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(SaveManagerBehavior __instance)
			{
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaignSaving.ResetCustomCampaignFile();
					SceneManager.LoadScene("MainMenuScene");
				}
				else if (GlobalVariables.isXmasDLC)
				{
					if (DeleteXmasGameProgress == null)
					{
						LoggingHelper.ReflectionError("DeleteXmasGameProgress");
						return true;
					}
					DeleteXmasGameProgress.Invoke(__instance, null);
				}
				else
				{
					PlayerPrefs.DeleteKey("SavedDay");
					__instance.savedDay = 1;
					PlayerPrefs.DeleteKey("SavedCurrentCaller");
					__instance.savedCurrentCaller = 0;
					PlayerPrefs.DeleteKey("SavedEntryTier");
					__instance.savedEntryTier = 1;
					PlayerPrefs.DeleteKey("SavedDayScore1");
					PlayerPrefs.DeleteKey("SavedDayScore2");
					PlayerPrefs.DeleteKey("SavedDayScore3");
					PlayerPrefs.DeleteKey("SavedDayScore4");
					PlayerPrefs.DeleteKey("SavedDayScore5");
					PlayerPrefs.DeleteKey("SavedDayScore6");
					PlayerPrefs.DeleteKey("SavedDayScore7");
					__instance.DeleteBoolArray("SavedCallerCorrectAnswer", __instance.savedCallerArrayLength);
					__instance.savedCallerCorrectAnswers = null;
					PlayerPrefs.DeleteKey("SavedCallerArrayLength");
					__instance.savedCallerArrayLength = 0;
					PlayerPrefs.DeleteKey("SavedGameFinishedDisplay");
					__instance.savedGameFinishedDisplay = 0;
					LoggingHelper.DebugLog("[UNITY] Game Progress Save Data Deleted.");
					SceneManager.LoadScene("MainMenuScene");
				}
				return false;
			}
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.Modifier.Data
{
	public class DesktopModifierSnapshot
	{
		public (bool found, VariableChanged<string> value) UsernameText;

		public (bool found, VariableChanged<string> value) RenameMainGameDesktopIcon;

		public (bool found, VariableChanged<Sprite> value) MainGameDesktopIcon;

		public (bool found, VariableChanged<bool> value) DisableDesktopLogo;

		public (bool found, VariableChanged<Sprite> value) CustomBackgroundLogo;

		public (bool found, VariableChanged<float> value) BackgroundLogoTransparency;

		public (bool found, VariableChanged<bool> value) VideoPlayerDesktopIsWideMode;

		public (bool found, VariableChanged<Sprite> value) MailboxIcon;

		public (bool found, VariableChanged<string> value) MailboxRename;

		public (bool found, VariableChanged<string> value) ApplicationMailboxTitle;

		public (bool found, VariableChanged<Sprite> value) ApplicationMailboxIcon;

		public (bool found, VariableChanged<bool> value) DisplayMailboxOnDesktop;

		public (bool found, VariableChanged<Sprite> value) EntryBrowserIcon;

		public (bool found, VariableChanged<string> value) EntryBrowserRename;

		public (bool found, VariableChanged<string> value) ApplicationEntryBrowserTitle;

		public (bool found, VariableChanged<Sprite> value) ApplicationEntryBrowserIcon;

		public (bool found, VariableChanged<Sprite> value) OptionsIcon;

		public (bool found, VariableChanged<string> value) OptionsRename;

		public (bool found, VariableChanged<string> value) ApplicationOptionsTitle;

		public (bool found, VariableChanged<Sprite> value) ApplicationOptionsIcon;

		public (bool found, VariableChanged<Sprite> value) ArtbookIcon;

		public (bool found, VariableChanged<string> value) ArtbookRename;

		public (bool found, List<ArtbookPage> value) ArtbookPages;

		public (bool found, VariableChanged<string> value) ApplicationArtbookTitle;

		public (bool found, VariableChanged<Sprite> value) ApplicationArtbookIcon;

		public (bool found, VariableChanged<Sprite> value) ArcadeIcon;

		public (bool found, VariableChanged<string> value) ArcadeRename;

		public (bool found, VariableChanged<Sprite> value) ScorecardIcon;

		public (bool found, VariableChanged<string> value) ScorecardRename;

		public (bool found, VariableChanged<string> value) ApplicationScorecardTitle;

		public (bool found, VariableChanged<Sprite> value) ApplicationScorecardIcon;

		public (bool found, VariableChanged<string> value) DesktopCredits;

		public (bool found, VariableChanged<string> value) CreditsRename;

		public (bool found, VariableChanged<Sprite> value) CreditsIcon;

		public (bool found, VariableChanged<bool> value) HideDesktopCredits;

		public (bool found, VariableChanged<bool> value) HideDiscordProgram;
	}
	public class ModifierSource
	{
		public List<CustomModifier> Modifiers = new List<CustomModifier>();

		public string ModifierName = "NO_MODIFIER_NAME_GIVEN";

		public Func<CustomCampaign, bool> SourceCondition = (CustomCampaign _) => true;

		public Func<CustomModifier, bool> RequirementForAddingToModifierList = (CustomModifier _) => true;

		public Func<CustomModifier, bool> ModifierExtraSelectionCondition = (CustomModifier _) => true;
	}
	public class VariableChanged<T>
	{
		public bool HasChanged = false;

		public T Data = default(T);
	}
	public class CustomModifier : CustomCampaignElementBase
	{
		[CanBeNull]
		public List<int> UnlockDays = null;

		public bool OnlyIfGameFinished = false;

		public VariableChanged<string> UsernameText = new VariableChanged<string>
		{
			Data = string.Empty
		};

		public VariableChanged<string> DateLabelOverwritten = new VariableChanged<string>
		{
			Data = "NO_DATE_SET"
		};

		public List<Sprite> DesktopBackgrounds = new List<Sprite>();

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

		public bool BlackBackgroundOnAnimatedBackground = false;

		public VariableChanged<bool> AnimatedDesktopBackgroundShouldLoop = new VariableChanged<bool>
		{
			Data = true
		};

		public bool DisableColorBackground = false;

		public Color? DesktopBackgroundColor = null;

		public VariableChanged<Sprite> GameFinishedBackground = new VariableChanged<Sprite>();

		public VariableChanged<bool> DisableDesktopLogo = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Sprite> CustomBackgroundLogo = new VariableChanged<Sprite>();

		public VariableChanged<float> BackgroundLogoTransparency = new VariableChanged<float>
		{
			Data = 0.2627f
		};

		public VariableChanged<bool> VideoPlayerDesktopIsWideMode = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<string> RenameMainGameDesktopIcon = new VariableChanged<string>
		{
			Data = string.Empty
		};

		public VariableChanged<Sprite> MainGameDesktopIcon = new VariableChanged<Sprite>();

		public VariableChanged<Sprite> MailboxIcon = new VariableChanged<Sprite>();

		public VariableChanged<Sprite> ApplicationMailboxIcon = new VariableChanged<Sprite>();

		public VariableChanged<string> MailboxRename = new VariableChanged<string>();

		public VariableChanged<string> ApplicationMailboxTitle = new VariableChanged<string>();

		public VariableChanged<bool> DisplayMailboxOnDesktop = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Sprite> EntryBrowserIcon = new VariableChanged<Sprite>();

		public VariableChanged<Sprite> ApplicationEntryBrowserIcon = new VariableChanged<Sprite>();

		public VariableChanged<string> EntryBrowserRename = new VariableChanged<string>();

		public VariableChanged<string> ApplicationEntryBrowserTitle = new VariableChanged<string>();

		public VariableChanged<bool> DisplayEntryBrowserOnDesktop = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Sprite> OptionsIcon = new VariableChanged<Sprite>();

		public VariableChanged<Sprite> ApplicationOptionsIcon = new VariableChanged<Sprite>();

		public VariableChanged<string> OptionsRename = new VariableChanged<string>();

		public VariableChanged<string> ApplicationOptionsTitle = new VariableChanged<string>();

		public VariableChanged<Sprite> ArtbookIcon = new VariableChanged<Sprite>();

		public VariableChanged<Sprite> ApplicationArtbookIcon = new VariableChanged<Sprite>();

		public VariableChanged<string> ArtbookRename = new VariableChanged<string>();

		public VariableChanged<string> ApplicationArtbookTitle = new VariableChanged<string>();

		public List<ArtbookPage> ArtbookPages = new List<ArtbookPage>();

		public VariableChanged<bool> DisplayArtbookOnDesktop = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Sprite> ArcadeIcon = new VariableChanged<Sprite>();

		public VariableChanged<string> ArcadeRename = new VariableChanged<string>();

		public VariableChanged<bool> DisplayArcadeOnDesktop = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Sprite> ScorecardIcon = new VariableChanged<Sprite>();

		public VariableChanged<Sprite> ApplicationScorecardIcon = new VariableChanged<Sprite>();

		public VariableChanged<string> ScorecardRename = new VariableChanged<string>();

		public VariableChanged<string> ApplicationScorecardTitle = new VariableChanged<string>();

		public VariableChanged<bool> DisplayScorecardOnDesktop = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<string> DesktopCredits = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<Sprite> CreditsIcon = new VariableChanged<Sprite>();

		public VariableChanged<string> CreditsRename = new VariableChanged<string>();

		public VariableChanged<bool> HideDesktopCredits = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> HideDiscordProgram = new VariableChanged<bool>();

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

		public VariableChanged<bool> FinalCutsceneFadeToBlack = new VariableChanged<bool>
		{
			Data = true
		};

		public VariableChanged<bool> FinalCutsceneShake = new VariableChanged<bool>
		{
			Data = true
		};

		public VariableChanged<bool> FinalCutsceneGlitchSounds = new VariableChanged<bool>
		{
			Data = true
		};

		public VariableChanged<bool> FinalCutscenePreventClicks = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<float> FinalCutsceneFadeDuration = new VariableChanged<float>
		{
			Data = 3f
		};

		public VariableChanged<float> FinalCutsceneFadePaddingDuration = new VariableChanged<float>
		{
			Data = 1f
		};

		public VariableChanged<bool> FinalCutsceneStopAudioAfterFade = new VariableChanged<bool>
		{
			Data = true
		};

		public VariableChanged<RichAudioClip> FinalCutsceneAudio = new VariableChanged<RichAudioClip>
		{
			Data = null
		};

		public VariableChanged<bool> FinalCutsceneReturnTo3DScreen = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> FinalCutsceneStayInCustomCampaign = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> FinalCutsceneDisableSkippingKeys = new VariableChanged<bool>
		{
			Data = false
		};

		public string FinalCutsceneAudioPath = null;

		public VariableChanged<bool> DisablePhoneStatic = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> UseClockInsteadOfTimer = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<float> DigitalClockTickRate = new VariableChanged<float>
		{
			Data = 1f
		};

		public VariableChanged<float> AnalogClockTickRate = new VariableChanged<float>
		{
			Data = 0.05f
		};

		public VariableChanged<string> TimedCallerDisconnectedMessage = new VariableChanged<string>
		{
			Data = "TIMES UP!\nCALL DISCONNECTED"
		};

		public VariableChanged<RichAudioClip> TimedCallerStartSound = new VariableChanged<RichAudioClip>
		{
			Data = null
		};

		public VariableChanged<string> TimedCallerStartSoundPath = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<RichAudioClip> TimedCallerHalfSound = new VariableChanged<RichAudioClip>
		{
			Data = null
		};

		public VariableChanged<string> TimedCallerHalfSoundPath = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<RichAudioClip> TimedCallerCriticalSound = new VariableChanged<RichAudioClip>
		{
			Data = null
		};

		public VariableChanged<string> TimedCallerCriticalSoundPath = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<Sprite> TimedCallerBaseClock = new VariableChanged<Sprite>
		{
			Data = null
		};

		public VariableChanged<Sprite> TimedCallerClockHand = new VariableChanged<Sprite>
		{
			Data = null
		};

		public VariableChanged<float> TimedCallerProfileClockSize = new VariableChanged<float>
		{
			Data = 57.5f
		};

		public VariableChanged<float> TimedCallerProfileClockSizeMultiplier = new VariableChanged<float>
		{
			Data = 1f
		};

		public VariableChanged<float> TimedCallerProfileClockPadX = new VariableChanged<float>
		{
			Data = 5f
		};

		public VariableChanged<float> TimedCallerProfileClockPadY = new VariableChanged<float>
		{
			Data = 5f
		};

		public VariableChanged<Sprite> InGameProgramIcon = new VariableChanged<Sprite>
		{
			Data = null
		};

		public VariableChanged<bool> InGameProgramIconCenter = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Sprite> InGamePhoneIcon = new VariableChanged<Sprite>
		{
			Data = null
		};

		public VariableChanged<bool> InGamePhoneIconCenter = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<string> IncomingCallTitle = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<string> IncomingCallLabel = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<string> IncomingCallAnswerButtonText = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<Sprite> IncomingCallAnswerButtonImage = new VariableChanged<Sprite>
		{
			Data = null
		};

		public VariableChanged<RichAudioClip> ClockDayStartedAudio = new VariableChanged<RichAudioClip>
		{
			Data = null
		};

		public VariableChanged<string> ClockDayStartedAudioPath = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<RichAudioClip> DayStartedAudio = new VariableChanged<RichAudioClip>
		{
			Data = null
		};

		public VariableChanged<string> DayStartedAudioPath = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<RichAudioClip> InGameLogoFadeInAudio = new VariableChanged<RichAudioClip>
		{
			Data = null
		};

		public VariableChanged<string> InGameLogoFadeInAudioPath = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<List<Sprite>> ClockInLogoAnimation = new VariableChanged<List<Sprite>>
		{
			Data = new List<Sprite>()
		};

		public VariableChanged<float> ClockInLogoAnimationScale = new VariableChanged<float>
		{
			Data = 1f
		};

		public VariableChanged<float> ClockInLogoAnimationFadeDuration = new VariableChanged<float>
		{
			Data = 1.82f
		};

		public VariableChanged<float> ClockInLogoAnimationHoldDuration = new VariableChanged<float>
		{
			Data = 1.42f
		};

		public VariableChanged<string> SubmitWindowTitle = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<string> SubmitWindowText = new VariableChanged<string>
		{
			Data = null
		};

		public VariableChanged<Sprite> SubmitWindowIcon = new VariableChanged<Sprite>
		{
			Data = null
		};

		public VariableChanged<List<Sprite>> ClockInAnimation = new VariableChanged<List<Sprite>>
		{
			Data = new List<Sprite>()
		};

		public VariableChanged<float> ClockInAnimationDuration = new VariableChanged<float>
		{
			Data = 2.25f
		};

		public VariableChanged<float> ClockInAnimationScale = new VariableChanged<float>
		{
			Data = 1f
		};

		public VariableChanged<bool> ShowDefaultUIAccuracyText = new VariableChanged<bool>
		{
			Data = false
		};

		public bool DisableDesktopLoading = false;

		public VariableChanged<bool> SelectPreviouslySelectedEntryInSubmitWindow = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> SelectCurrentlyMainViewSelectedEntryInSubmitWindow = new VariableChanged<bool>
		{
			Data = false
		};
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.LinkApps
{
	public class LinkApp : CustomCampaignElementBase
	{
		public int UnlockDay = 0;

		public int LinkAppPriority = 0;

		public VariableChanged<int> GameObjectOrder = new VariableChanged<int>
		{
			Data = 0
		};

		[CanBeNull]
		public Uri LinkAppClickURL;

		public VariableChanged<string> DesktopName = new VariableChanged<string>
		{
			Data = "No Name Provided"
		};

		public VariableChanged<Sprite> DesktopIcon = new VariableChanged<Sprite>
		{
			Data = null
		};

		[CanBeNull]
		public List<GeneralAccuracyType> UnlockAccuracy = null;

		[CanBeNull]
		public List<CallerRequirement> UnlockRequiredCallers = null;

		public bool UnlockWhenGameFinished = false;

		public GameObject GameObjectReference = null;
	}
	public static class LinkAppHelper
	{
		public class LinkAppOpener : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
		{
			public void PlayExecutableFunction()
			{
				((MonoBehaviour)this).StartCoroutine(ExecutableRoutine());
			}

			private IEnumerator ExecutableRoutine()
			{
				yield return (object)new WaitForSeconds(0.5f);
				OpenLinkApp();
			}

			public void OnPointerClick(PointerEventData eventData)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Invalid comparison between Unknown and I4
				if (eventData.clickCount == 2 || (int)SystemInfo.deviceType == 1)
				{
					PlayExecutableFunction();
				}
			}

			public void OpenLinkApp()
			{
				LinkApp linkAppFromActiveCampaign = CustomCampaignGlobal.GetLinkAppFromActiveCampaign(((Component)this).gameObject);
				if (linkAppFromActiveCampaign != null)
				{
					URLVerification.OpenURIInBrowser(linkAppFromActiveCampaign.LinkAppClickURL);
				}
				else
				{
					LoggingHelper.ErrorLog("Was unable of opening link app. Could not find relevant link app GameObject.");
				}
			}
		}

		public static GameObject CreateCustomLinkApp(LinkApp customLinkApp)
		{
			GameObject gameObject = ((Component)CustomDesktopHelper.GetLeftPrograms().transform.Find("Readme")).gameObject;
			GameObject val = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent);
			if (!customLinkApp.DesktopName.HasChanged)
			{
				LoggingHelper.WarningLog("No desktop name provided for the custom link app, using default name.");
			}
			((Object)val).name = customLinkApp.DesktopName.Data + customLinkApp.UnlockDay;
			if (customLinkApp.DesktopIcon.HasChanged)
			{
				val.GetComponent<Image>().sprite = customLinkApp.DesktopIcon.Data;
			}
			else
			{
				val.GetComponent<Image>().sprite = CustomTextFileHelper.TextFileIcon;
			}
			if (customLinkApp.GameObjectOrder.HasChanged)
			{
				val.transform.SetSiblingIndex(customLinkApp.GameObjectOrder.Data);
			}
			TextMeshProUGUI component = ((Component)((Component)val.transform.Find("TextBackground")).transform.Find("ExecutableName")).gameObject.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = customLinkApp.DesktopName.Data;
			TextFileExecutable component2 = val.GetComponent<TextFileExecutable>();
			((Behaviour)component2).enabled = false;
			val.SetActive(true);
			if (GlobalVariables.currentDay < customLinkApp.UnlockDay)
			{
				val.SetActive(false);
			}
			if (!AccuracyLinkAppHelper.CheckIfLinkAppPassAccuracyChecks(customLinkApp))
			{
				val.SetActive(false);
			}
			val.AddComponent<LinkAppOpener>();
			customLinkApp.GameObjectReference = val;
			return val;
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.InGamePatches
{
	public static class SelectPreviousEntryPatch
	{
		[HarmonyPatch(typeof(SubmitWindowBehavior), "PopulateDropdownList")]
		public static class SubmitWindowPopulateDropdownList
		{
			public static MonsterProfile LastSelectedEntry;

			private static bool Prefix(SubmitWindowBehavior __instance)
			{
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Expected O, but got Unknown
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected O, but got Unknown
				__instance.myDropdown.ClearOptions();
				MonsterProfile[] monsterProfiles = GlobalVariables.entryUnlockScript.allEntries.monsterProfiles;
				foreach (MonsterProfile val in monsterProfiles)
				{
					if (GlobalVariables.entryUnlockScript.CheckMonsterIsUnlocked(val))
					{
						__instance.myDropdown.options.Add(new OptionData
						{
							text = val.monsterName
						});
					}
					else
					{
						__instance.myDropdown.options.Add(new OptionData
						{
							text = "ENTRY INACCESSIBLE"
						});
					}
				}
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					(bool, VariableChanged<bool>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.SelectPreviouslySelectedEntryInSubmitWindow, (VariableChanged<bool> vCs) => vCs.HasChanged);
					(bool, VariableChanged<bool>) activeModifierValue2 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.SelectCurrentlyMainViewSelectedEntryInSubmitWindow, (VariableChanged<bool> vCs) => vCs.HasChanged);
					if (activeModifierValue.Item1 && activeModifierValue.Item2.Data)
					{
						if ((Object)(object)LastSelectedEntry != (Object)null)
						{
							int num = __instance.myDropdown.options.FindIndex((OptionData option) => option.text == LastSelectedEntry.monsterName);
							if (num < 0)
							{
								LoggingHelper.DebugLog("Entry to be selected not found.");
								__instance.myDropdown.value = 0;
								__instance.myDropdown.RefreshShownValue();
								__instance.OnDropdownItemSelected();
							}
							else
							{
								LoggingHelper.DebugLog($"Selected entry with ID: '{num}'.");
								__instance.myDropdown.value = num;
								__instance.myDropdown.RefreshShownValue();
								__instance.OnDropdownItemSelected();
							}
						}
						else
						{
							LoggingHelper.DebugLog("Entry to be selected not found (No last selected entry).");
							__instance.myDropdown.value = 0;
							__instance.myDropdown.RefreshShownValue();
							__instance.OnDropdownItemSelected();
						}
					}
					else if (activeModifierValue2.Item1 && activeModifierValue2.Item2.Data)
					{
						if ((Object)(object)GlobalVariables.mainCanvasScript.selectedMonsterProfile == (Object)null)
						{
							LoggingHelper.DebugLog("No entry selected. Defaulting to first entry.");
							__instance.myDropdown.value = 0;
							__instance.myDropdown.RefreshShownValue();
							__instance.OnDropdownItemSelected();
						}
						else
						{
							int num2 = __instance.myDropdown.options.FindIndex((OptionData option) => option.text == GlobalVariables.mainCanvasScript.selectedMonsterProfile.monsterName);
							if (num2 < 0)
							{
								LoggingHelper.DebugLog("Entry to be selected not found.");
								__instance.myDropdown.value = 0;
								__instance.myDropdown.RefreshShownValue();
								__instance.OnDropdownItemSelected();
							}
							else
							{
								LoggingHelper.DebugLog($"Selected entry '{GlobalVariables.mainCanvasScript.selectedMonsterProfile.monsterName}' (Index: {num2}) in dropdown.");
								__instance.myDropdown.value = num2;
								__instance.myDropdown.RefreshShownValue();
								__instance.OnDropdownItemSelected();
							}
						}
					}
					else
					{
						__instance.OnDropdownItemSelected();
					}
				}
				else
				{
					__instance.OnDropdownItemSelected();
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(SubmitWindowBehavior), "OnDropdownItemSelected")]
		public static class SubmitWindowLastSelectedItem
		{
			private static void Prefix(SubmitWindowBehavior __instance)
			{
				SubmitWindowPopulateDropdownList.LastSelectedEntry = __instance.GetMonsterProfileFromName();
			}
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.Helper
{
	public static class AccuracyTextPatches
	{
		[HarmonyPatch(typeof(AccuracyTextUpdate), "Start")]
		public static class AccuracyTextUpdateStartPatch
		{
			private static bool Prefix(AccuracyTextUpdate __instance)
			{
				if (MyText == null)
				{
					LoggingHelper.ReflectionError("MyText");
					return true;
				}
				MyText.SetValue(__instance, ((Component)__instance).GetComponent<TextMeshProUGUI>());
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					if (MyText != null)
					{
						object? value = MyText.GetValue(__instance);
						TextMeshProUGUI val = (TextMeshProUGUI)((value is TextMeshProUGUI) ? value : null);
						if ((Object)(object)val != (Object)null && ((TMP_Text)val).text.Equals("ACCURACY RATE: 50%") && GlobalVariables.callerControllerScript.callersToday <= 0)
						{
							((TMP_Text)val).text = "ACCURACY RATE: 100%";
						}
					}
					(bool, VariableChanged<bool>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.ShowDefaultUIAccuracyText, (VariableChanged<bool> vCb) => vCb.HasChanged);
					if (activeModifierValue.Item1)
					{
						if (!activeModifierValue.Item2.Data)
						{
							((Component)__instance).gameObject.SetActive(false);
						}
						return false;
					}
				}
				if (!__instance.onlyDisplayWhenAccuracyOptionIsOn || GlobalVariables.saveManagerScript.savedAccuracyToggle != 0)
				{
					return false;
				}
				((Component)__instance).gameObject.SetActive(false);
				return false;
			}
		}

		[HarmonyPatch(typeof(CallerController), "GetScore")]
		public static class CallerControllerGetScorePatch
		{
			private static bool Prefix(ref float __result)
			{
				if (GlobalVariables.callerControllerScript.callersToday <= 0 && GlobalVariables.callerControllerScript.correctCallsToday <= 0)
				{
					__result = 100f;
					return false;
				}
				__result = (float)((double)GlobalVariables.callerControllerScript.correctCallsToday / (double)GlobalVariables.callerControllerScript.callersToday * 100.0);
				return false;
			}
		}

		private static readonly FieldInfo MyText = typeof(AccuracyTextUpdate).GetField("myText", BindingFlags.Instance | BindingFlags.NonPublic);
	}
	public static class RandomFromList
	{
		public static float? GetRandomFromList(List<float> providedList)
		{
			if (providedList == null || providedList.Count == 0)
			{
				return null;
			}
			if (providedList.Count == 1)
			{
				return providedList[0];
			}
			if (providedList.Count == 2)
			{
				return Random.Range(providedList[0], providedList[1]);
			}
			int index = Random.Range(0, providedList.Count);
			return providedList[index];
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.Helper.CallerRequirementHelper
{
	public class CallerRequirement
	{
		public int? CallerID = null;

		public bool ShouldCallerBeCorrect = false;
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.Helper.AccuracyModel
{
	public class CallerAccuracyType
	{
		public float RequiredAccuracy = -1f;

		public bool UseTotalAccuracy = false;

		public AccuracyHelper.CheckOptions AccuracyCheck = AccuracyHelper.CheckOptions.NoneSet;
	}
	public class GeneralAccuracyType
	{
		public int? CheckDay = null;

		public float RequiredAccuracy = -1f;

		public AccuracyHelper.CheckOptions AccuracyCheck = AccuracyHelper.CheckOptions.GreaterThanOrEqualTo;
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.Helper.AccuracyHelpers
{
	public static class AccuracyCallerHelper
	{
		public static int StartOfDayCallerID;

		private static float ComputeDayAccuracy()
		{
			if (GlobalVariables.callerControllerScript.callersToday <= 0)
			{
				return 1f;
			}
			return (float)GlobalVariables.callerControllerScript.correctCallsToday / (float)GlobalVariables.callerControllerScript.callersToday;
		}

		private static float ComputeTotalDayAccuracy()
		{
			int num = 0;
			int num2 = 0;
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				LoggingHelper.CampaignNullError();
				return 0f;
			}
			for (int i = StartOfDayCallerID; i < activeCustomCampaign.CustomCallersInCampaign.Count; i++)
			{
				CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(i);
				if (customCallerFromActiveCampaign == null)
				{
					LoggingHelper.WarningLog($"Missing caller found for caller order {i}. Not counting this caller.");
					continue;
				}
				num++;
				if (GlobalVariables.callerControllerScript.callers[i].answeredCorrectly)
				{
					num2++;
				}
				if (customCallerFromActiveCampaign.LastDayCaller)
				{
					break;
				}
			}
			if (num <= 0)
			{
				return 1f;
			}
			return (float)num2 / (float)num;
		}

		public static bool CheckIfCallerIsToBeShown(CustomCCaller currentCaller)
		{
			LoggingHelper.InfoLog(() => "Checking if accuracy caller is to be shown " + $"({currentCaller.CallerName} with '{currentCaller.AccuracyChecks.Count}' checks). " + $"Current day accuracy is '{GetCorrectAccuracy(useTotalAccuracy: false)}'. " + $"Total current day accuracy is '{GetCorrectAccuracy(useTotalAccuracy: false, useTotalDayAccuracy: true)}'. " + $"Total accuracy is '{GetCorrectAccuracy(useTotalAccuracy: true)}'.", LoggingHelper.LoggingCategory.SKIPPED_CALLER);
			foreach (CallerAccuracyType accuracyType in currentCaller.AccuracyChecks)
			{
				float currentAccuracy = GetCorrectAccuracy(accuracyType.UseTotalAccuracy, currentCaller.CountEveryCallerForLocalAccuracy);
				LoggingHelper.DebugLog(() => "FoundAccuracy caller with current check '" + accuracyType.AccuracyCheck.ToString() + "' " + $"and required accuracy '{accuracyType.RequiredAccuracy}'. " + $"The current accuracy is: '{currentAccuracy}'.", LoggingHelper.LoggingCategory.SKIPPED_CALLER);
				switch (accuracyType.AccuracyCheck)
				{
				case AccuracyHelper.CheckOptions.EqualTo:
					if (!Mathf.Approximately(accuracyType.RequiredAccuracy, currentAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.GreaterThanOrEqualTo:
					if (!(currentAccuracy >= accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.LessThanOrEqualTo:
					if (!(currentAccuracy <= accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.NotEqualTo:
					if (Mathf.Approximately(currentAccuracy, accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				}
			}
			return true;
		}

		public static float GetCorrectAccuracy(bool useTotalAccuracy, bool useTotalDayAccuracy = false)
		{
			if (useTotalAccuracy)
			{
				return AccuracyHelper.ComputeTotalCampaignAccuracy();
			}
			if (useTotalDayAccuracy)
			{
				return ComputeTotalDayAccuracy();
			}
			return ComputeDayAccuracy();
		}
	}
	public static class AccuracyCutsceneHelper
	{
		private static bool CheckAllAccuracyRequirements(CustomCutscene customCutscene)
		{
			if (customCutscene.UnlockAccuracy == null)
			{
				return true;
			}
			LoggingHelper.DebugLog(() => "Checking specific accuracy requirement for a cutscene.", LoggingHelper.LoggingCategory.CUTSCENE);
			foreach (GeneralAccuracyType accuracyType in customCutscene.UnlockAccuracy)
			{
				if (!AccuracyHelper.CheckIfDayValid(accuracyType))
				{
					LoggingHelper.DebugLog(() => "Accuracy day not reached.", LoggingHelper.LoggingCategory.CUTSCENE);
					return false;
				}
				float? accuracyOfDay = AccuracyHelper.GetAccuracyOfDay(accuracyType.CheckDay);
				if (!accuracyOfDay.HasValue)
				{
					LoggingHelper.WarningLog("Unable of getting accuracy of a day. Possible logic error?");
					return false;
				}
				float currentAccuracy = accuracyOfDay.Value;
				if (accuracyType.CheckDay.HasValue)
				{
					int? checkDay = accuracyType.CheckDay;
					LoggingHelper.DebugLog(() => $"The current accuracy is '{currentAccuracy}' of day '{checkDay}' " + "with check type: '" + accuracyType.AccuracyCheck.ToString() + "'. " + $"With required accuracy of '{accuracyType.RequiredAccuracy}'.", LoggingHelper.LoggingCategory.CUTSCENE);
					switch (accuracyType.AccuracyCheck)
					{
					case AccuracyHelper.CheckOptions.EqualTo:
						if (!Mathf.Approximately(accuracyType.RequiredAccuracy, currentAccuracy))
						{
							return false;
						}
						break;
					case AccuracyHelper.CheckOptions.GreaterThanOrEqualTo:
						if (!(currentAccuracy >= accuracyType.RequiredAccuracy))
						{
							return false;
						}
						break;
					case AccuracyHelper.CheckOptions.LessThanOrEqualTo:
						if (!(currentAccuracy <= accuracyType.RequiredAccuracy))
						{
							return false;
						}
						break;
					case AccuracyHelper.CheckOptions.NotEqualTo:
						if (Mathf.Approximately(currentAccuracy, accuracyType.RequiredAccuracy))
						{
							return false;
						}
						break;
					}
					continue;
				}
				LoggingHelper.ErrorLog("Provided custom cutscene check day is invalid! Unable of checking requirement.");
				return false;
			}
			return true;
		}

		public static bool CheckCutsceneAccuracy(CustomCutscene customCutscene)
		{
			LoggingHelper.DebugLog("Checking custom cutscene accuracy.", LoggingHelper.LoggingCategory.CUTSCENE);
			if (customCutscene.UnlockRequiredCallers != null && customCutscene.UnlockRequiredCallers.Count > 0 && !AccuracyHelper.CheckIfCallerRequirementsAreMet(customCutscene.UnlockRequiredCallers, LoggingHelper.LoggingCategory.CUTSCENE))
			{
				LoggingHelper.DebugLog("Cutscene will not be shown. The caller requirement was not met.", LoggingHelper.LoggingCategory.CUTSCENE);
				return false;
			}
			if (!CheckAllAccuracyRequirements(customCutscene))
			{
				return false;
			}
			return true;
		}
	}
	public static class AccuracyEmailHelper
	{
		private static bool CheckIfDayValid(GeneralAccuracyType accuracyType, CustomEmail email)
		{
			int? num = accuracyType.CheckDay;
			if (!accuracyType.CheckDay.HasValue)
			{
				num = email.UnlockDay - 1;
			}
			if (num <= 0 || num <= GlobalVariables.currentDay)
			{
				return true;
			}
			LoggingHelper.DebugLog($"Checking accuracy day of '{num}' " + $"on day '{GlobalVariables.currentDay}'. " + $"(Accuracy type check day: '{accuracyType.CheckDay}')", LoggingHelper.LoggingCategory.EMAIL);
			return false;
		}

		private static float? GetAccuracyOfDay(int? unlockDay, CustomEmail email)
		{
			if (!unlockDay.HasValue)
			{
				unlockDay = email.UnlockDay - 1;
			}
			if (unlockDay <= 0)
			{
				LoggingHelper.WarningLog("Unable of getting accuracy for any day that isn't the first. " + $"Unlock day '{unlockDay}' with unlock day of " + $"'{email.UnlockDay}' is thus invalid.");
				return null;
			}
			if (CustomCampaignGlobal.InCustomCampaign)
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return null;
				}
				if (activeCustomCampaign.SavedDayScores.Count > unlockDay)
				{
					return activeCustomCampaign.SavedDayScores[unlockDay.Value] / 100f;
				}
			}
			else
			{
				int? num = unlockDay;
				if (PlayerPrefs.HasKey("SavedDayScore" + num))
				{
					num = unlockDay;
					return PlayerPrefs.GetFloat("SavedDayScore" + num) / 100f;
				}
			}
			return null;
		}

		private static bool CheckAllAccuracyRequirements(CustomEmail customEmail)
		{
			if (customEmail.UnlockAccuracy == null)
			{
				return true;
			}
			foreach (GeneralAccuracyType accuracyType in customEmail.UnlockAccuracy)
			{
				if (!CheckIfDayValid(accuracyType, customEmail))
				{
					LoggingHelper.DebugLog(() => "Accuracy day not reached.", LoggingHelper.LoggingCategory.EMAIL);
					return false;
				}
				float? accuracyOfDay = GetAccuracyOfDay(accuracyType.CheckDay, customEmail);
				if (!accuracyOfDay.HasValue)
				{
					LoggingHelper.WarningLog("Unable of getting accuracy of a day. Possible logic error? Not showing email.");
					return false;
				}
				float currentAccuracy = accuracyOfDay.Value;
				int? checkDay;
				if (!accuracyType.CheckDay.HasValue)
				{
					checkDay = customEmail.UnlockDay - 1;
				}
				else
				{
					checkDay = accuracyType.CheckDay;
				}
				LoggingHelper.DebugLog(() => $"The current accuracy is '{currentAccuracy}' of day '{checkDay}' " + $"(Email Unlock Day: '{customEmail.UnlockDay}') " + "with check type: '" + accuracyType.AccuracyCheck.ToString() + "'. " + $"With required accuracy of '{accuracyType.RequiredAccuracy}'.", LoggingHelper.LoggingCategory.EMAIL);
				switch (accuracyType.AccuracyCheck)
				{
				case AccuracyHelper.CheckOptions.EqualTo:
					if (!Mathf.Approximately(accuracyType.RequiredAccuracy, currentAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.GreaterThanOrEqualTo:
					if (!(currentAccuracy >= accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.LessThanOrEqualTo:
					if (!(currentAccuracy <= accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.NotEqualTo:
					if (Mathf.Approximately(currentAccuracy, accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				}
			}
			return true;
		}

		public static bool CheckIfEmailAccuracyType(CustomEmail customEmail)
		{
			LoggingHelper.DebugLog("Checking customEmail accuracy type.", LoggingHelper.LoggingCategory.EMAIL);
			if (customEmail.UnlockDay > GlobalVariables.currentDay)
			{
				return false;
			}
			if (customEmail.UseOldAccuracyChecks && CustomCampaignGlobal.InCustomCampaign)
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return false;
				}
				int num = customEmail.UnlockDay - 1;
				if (num < 0)
				{
					num = 0;
				}
				if (customEmail.UnlockThreshold > 0f)
				{
					LoggingHelper.DebugLog("This email is using the old accuracy system (for accuracy). " + $"Unlock Threshold: '{customEmail.UnlockThreshold}' " + $"with that day '{num}' score " + $"'{activeCustomCampaign.SavedDayScores[num]}'.");
					if (activeCustomCampaign.SavedDayScores[num] < customEmail.UnlockThreshold)
					{
						return false;
					}
				}
			}
			if (customEmail.UnlockWhenGameFinished && CustomCampaignGlobal.InCustomCampaign)
			{
				CustomCampaign activeCustomCampaign2 = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign2 == null)
				{
					return false;
				}
				if (activeCustomCampaign2.SavedGameFinished != 1 && activeCustomCampaign2.SavedGameFinishedDisplay != 1)
				{
					LoggingHelper.DebugLog("Email will not be shown. Game has not been finished.", LoggingHelper.LoggingCategory.EMAIL);
					return false;
				}
			}
			if (customEmail.UnlockRequiredCallers != null && customEmail.UnlockRequiredCallers.Count > 0 && !AccuracyHelper.CheckIfCallerRequirementsAreMet(customEmail.UnlockRequiredCallers))
			{
				LoggingHelper.DebugLog("Email will not be shown. A caller requirement was not met.", LoggingHelper.LoggingCategory.EMAIL);
				return false;
			}
			if (!CheckAllAccuracyRequirements(customEmail))
			{
				return false;
			}
			return true;
		}
	}
	public static class AccuracyHelper
	{
		public enum CheckOptions
		{
			GreaterThanOrEqualTo,
			LessThanOrEqualTo,
			EqualTo,
			NotEqualTo,
			NoneSet
		}

		public static float ComputeTotalCampaignAccuracy()
		{
			float num = 0f;
			Caller[] callers = GlobalVariables.callerControllerScript.callers;
			foreach (Caller val in callers)
			{
				if (val.answeredCorrectly)
				{
					num += 1f;
				}
			}
			return num / (float)GlobalVariables.callerControllerScript.callers.Length;
		}

		public static float? GetAccuracyOfDay(int? unlockDay)
		{
			if (unlockDay <= 0)
			{
				LoggingHelper.WarningLog("Provided accuracy of cutscene" + $"Unlock day '{unlockDay}' is invalid.");
				return null;
			}
			if (CustomCampaignGlobal.InCustomCampaign)
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return null;
				}
				if (activeCustomCampaign.SavedDayScores.Count > unlockDay)
				{
					return activeCustomCampaign.SavedDayScores[unlockDay.Value] / 100f;
				}
			}
			else
			{
				int? num = unlockDay;
				if (PlayerPrefs.HasKey("SavedDayScore" + num))
				{
					num = unlockDay;
					return PlayerPrefs.GetFloat("SavedDayScore" + num) / 100f;
				}
			}
			return null;
		}

		public static bool CheckIfDayValid(GeneralAccuracyType accuracyType, LoggingHelper.LoggingCategory loggingCategory = LoggingHelper.LoggingCategory.CUTSCENE)
		{
			int? checkDay = accuracyType.CheckDay;
			if (checkDay <= 0 || checkDay <= GlobalVariables.currentDay)
			{
				return true;
			}
			LoggingHelper.DebugLog($"Checking cutscene accuracy day of '{checkDay}' " + $"on day '{GlobalVariables.currentDay}'. " + $"(Accuracy type check day: '{accuracyType.CheckDay}')", loggingCategory);
			return false;
		}

		public static bool CheckIfCallerRequirementsAreMet(List<CallerRequirement> callerRequirements, LoggingHelper.LoggingCategory loggingCategory = LoggingHelper.LoggingCategory.EMAIL)
		{
			LoggingHelper.DebugLog("Checking caller requirements...", loggingCategory);
			if (CustomCampaignGlobal.InCustomCampaign)
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return false;
				}
				foreach (CallerRequirement callerRequirement in callerRequirements)
				{
					if (!callerRequirement.CallerID.HasValue)
					{
						LoggingHelper.WarningLog("Provided caller requirement is invalid. Unable to check. Hiding GameObject.");
						return false;
					}
					int callerID = callerRequirement.CallerID.Value;
					CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(callerID);
					if (customCallerFromActiveCampaign == null)
					{
						LoggingHelper.WarningLog("Provided object has a caller requirement that could not be checked. Caller does not exist. Unable to check. Hiding GameObject.");
						return false;
					}
					if (callerID >= activeCustomCampaign.SavedCallersCorrectAnswer.Count)
					{
						LoggingHelper.DebugLog("Caller requirement skipped, we have not reached the caller yet.", loggingCategory);
						return false;
					}
					bool isMarkedCorrect = activeCustomCampaign.SavedCallersCorrectAnswer[callerID];
					LoggingHelper.DebugLog(() => "Caller Requirement for caller " + $"ID: '{callerID}' with requirement " + $"'{callerRequirement.ShouldCallerBeCorrect}'." + $" Is that caller marked as correct? '{isMarkedCorrect}'. ", loggingCategory);
					if (callerRequirement.ShouldCallerBeCorrect != isMarkedCorrect)
					{
						return false;
					}
				}
			}
			return true;
		}
	}
	public static class AccuracyLinkAppHelper
	{
		private static bool CheckIfDayValid(GeneralAccuracyType accuracyType, LinkApp linkApp)
		{
			int? num = accuracyType.CheckDay;
			if (!accuracyType.CheckDay.HasValue)
			{
				num = linkApp.UnlockDay - 1;
			}
			if (num <= 0 || num <= GlobalVariables.currentDay)
			{
				return true;
			}
			LoggingHelper.DebugLog($"Checking accuracy day of '{num}' " + $"on day '{GlobalVariables.currentDay}'. " + $"(Accuracy type check day: '{accuracyType.CheckDay}')", LoggingHelper.LoggingCategory.LINK_APP);
			return false;
		}

		private static float? GetAccuracyOfDay(int? unlockDay, LinkApp linkApp)
		{
			if (!unlockDay.HasValue)
			{
				unlockDay = linkApp.UnlockDay - 1;
			}
			if (unlockDay <= 0)
			{
				LoggingHelper.WarningLog("Unable of getting accuracy for any day that isn't the first. " + $"Unlock day '{unlockDay}' with unlock day of " + $"'{linkApp.UnlockDay}' is thus invalid.", LoggingHelper.LoggingCategory.LINK_APP);
				return null;
			}
			if (CustomCampaignGlobal.InCustomCampaign)
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return null;
				}
				if (activeCustomCampaign.SavedDayScores.Count > unlockDay)
				{
					return activeCustomCampaign.SavedDayScores[unlockDay.Value] / 100f;
				}
			}
			else
			{
				int? num = unlockDay;
				if (PlayerPrefs.HasKey("SavedDayScore" + num))
				{
					num = unlockDay;
					return PlayerPrefs.GetFloat("SavedDayScore" + num) / 100f;
				}
			}
			return null;
		}

		private static bool CheckAllAccuracyRequirements(LinkApp linkApp)
		{
			if (linkApp.UnlockAccuracy == null)
			{
				return true;
			}
			foreach (GeneralAccuracyType accuracyType in linkApp.UnlockAccuracy)
			{
				if (!CheckIfDayValid(accuracyType, linkApp))
				{
					LoggingHelper.DebugLog(() => "Link App accuracy day not reached.", LoggingHelper.LoggingCategory.LINK_APP);
					return false;
				}
				float? accuracyOfDay = GetAccuracyOfDay(accuracyType.CheckDay, linkApp);
				if (!accuracyOfDay.HasValue)
				{
					LoggingHelper.WarningLog("Unable of getting accuracy of a day. Possible logic error? Not showing link app.");
					return false;
				}
				float currentAccuracy = accuracyOfDay.Value;
				int? checkDay;
				if (!accuracyType.CheckDay.HasValue)
				{
					checkDay = linkApp.UnlockDay - 1;
				}
				else
				{
					checkDay = accuracyType.CheckDay;
				}
				LoggingHelper.DebugLog(() => $"The current accuracy is '{currentAccuracy}' of day '{checkDay}' " + $"(Link App Unlock Day: '{linkApp.UnlockDay}') " + "with check type: '" + accuracyType.AccuracyCheck.ToString() + "'. " + $"With required accuracy of '{accuracyType.RequiredAccuracy}'.", LoggingHelper.LoggingCategory.LINK_APP);
				switch (accuracyType.AccuracyCheck)
				{
				case AccuracyHelper.CheckOptions.EqualTo:
					if (!Mathf.Approximately(accuracyType.RequiredAccuracy, currentAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.GreaterThanOrEqualTo:
					if (!(currentAccuracy >= accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.LessThanOrEqualTo:
					if (!(currentAccuracy <= accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.NotEqualTo:
					if (Mathf.Approximately(currentAccuracy, accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				}
			}
			return true;
		}

		public static bool CheckIfLinkAppPassAccuracyChecks(LinkApp linkApp)
		{
			LoggingHelper.DebugLog("Checking custom link app ('" + linkApp.DesktopName.Data + "') accuracy type.");
			if (!CustomCampaignGlobal.InCustomCampaign)
			{
				return true;
			}
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return false;
			}
			if (linkApp.UnlockDay > GlobalVariables.currentDay)
			{
				return false;
			}
			if (linkApp.UnlockWhenGameFinished && activeCustomCampaign.SavedGameFinished != 1 && activeCustomCampaign.SavedGameFinishedDisplay != 1)
			{
				LoggingHelper.DebugLog("Link app will not be shown. Game has not been finished.", LoggingHelper.LoggingCategory.LINK_APP);
				return false;
			}
			if (linkApp.UnlockRequiredCallers != null && linkApp.UnlockRequiredCallers.Count > 0 && !AccuracyHelper.CheckIfCallerRequirementsAreMet(linkApp.UnlockRequiredCallers, LoggingHelper.LoggingCategory.LINK_APP))
			{
				LoggingHelper.DebugLog("Link app will not be shown. A caller requirement was not met.", LoggingHelper.LoggingCategory.LINK_APP);
				return false;
			}
			if (!CheckAllAccuracyRequirements(linkApp))
			{
				return false;
			}
			return true;
		}
	}
	public static class AccuracyTextFileHelper
	{
		private static bool CheckIfDayValid(GeneralAccuracyType accuracyType, CustomTextFile textFile)
		{
			int? num = accuracyType.CheckDay;
			if (!accuracyType.CheckDay.HasValue)
			{
				num = textFile.UnlockDay - 1;
			}
			if (num <= 0 || num <= GlobalVariables.currentDay)
			{
				return true;
			}
			LoggingHelper.DebugLog($"Checking accuracy day of '{num}' " + $"on day '{GlobalVariables.currentDay}'. " + $"(Accuracy type check day: '{accuracyType.CheckDay}')", LoggingHelper.LoggingCategory.TEXT_FILE);
			return false;
		}

		private static float? GetAccuracyOfDay(int? unlockDay, CustomTextFile textFile)
		{
			if (!unlockDay.HasValue)
			{
				unlockDay = textFile.UnlockDay - 1;
			}
			if (unlockDay <= 0)
			{
				LoggingHelper.WarningLog("Unable of getting accuracy for any day that isn't the first. " + $"Unlock day '{unlockDay}' with unlock day of " + $"'{textFile.UnlockDay}' is thus invalid.", LoggingHelper.LoggingCategory.TEXT_FILE);
				return null;
			}
			if (CustomCampaignGlobal.InCustomCampaign)
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return null;
				}
				if (activeCustomCampaign.SavedDayScores.Count > unlockDay)
				{
					return activeCustomCampaign.SavedDayScores[unlockDay.Value] / 100f;
				}
			}
			else
			{
				int? num = unlockDay;
				if (PlayerPrefs.HasKey("SavedDayScore" + num))
				{
					num = unlockDay;
					return PlayerPrefs.GetFloat("SavedDayScore" + num) / 100f;
				}
			}
			return null;
		}

		private static bool CheckAllAccuracyRequirements(CustomTextFile customTextFile)
		{
			if (customTextFile.UnlockAccuracy == null)
			{
				return true;
			}
			foreach (GeneralAccuracyType accuracyType in customTextFile.UnlockAccuracy)
			{
				if (!CheckIfDayValid(accuracyType, customTextFile))
				{
					LoggingHelper.DebugLog(() => "Text file accuracy day not reached.", LoggingHelper.LoggingCategory.TEXT_FILE);
					return false;
				}
				float? accuracyOfDay = GetAccuracyOfDay(accuracyType.CheckDay, customTextFile);
				if (!accuracyOfDay.HasValue)
				{
					LoggingHelper.WarningLog("Unable of getting accuracy of a day. Possible logic error? Not showing text file.");
					return false;
				}
				float currentAccuracy = accuracyOfDay.Value;
				int? checkDay;
				if (!accuracyType.CheckDay.HasValue)
				{
					checkDay = customTextFile.UnlockDay - 1;
				}
				else
				{
					checkDay = accuracyType.CheckDay;
				}
				LoggingHelper.DebugLog(() => $"The current accuracy is '{currentAccuracy}' of day '{checkDay}' " + $"(Text File Unlock Day: '{customTextFile.UnlockDay}') " + "with check type: '" + accuracyType.AccuracyCheck.ToString() + "'. " + $"With required accuracy of '{accuracyType.RequiredAccuracy}'.", LoggingHelper.LoggingCategory.TEXT_FILE);
				switch (accuracyType.AccuracyCheck)
				{
				case AccuracyHelper.CheckOptions.EqualTo:
					if (!Mathf.Approximately(accuracyType.RequiredAccuracy, currentAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.GreaterThanOrEqualTo:
					if (!(currentAccuracy >= accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.LessThanOrEqualTo:
					if (!(currentAccuracy <= accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.NotEqualTo:
					if (Mathf.Approximately(currentAccuracy, accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				}
			}
			return true;
		}

		public static bool CheckIfTextFilePassAccuracyChecks(CustomTextFile customTextFile)
		{
			LoggingHelper.DebugLog("Checking custom text file ('" + customTextFile.FileNameOnDesktop + "') accuracy type.");
			if (!CustomCampaignGlobal.InCustomCampaign)
			{
				return true;
			}
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				return false;
			}
			if (customTextFile.UnlockDay > GlobalVariables.currentDay)
			{
				return false;
			}
			if (customTextFile.UnlockWhenGameFinished && activeCustomCampaign.SavedGameFinished != 1 && activeCustomCampaign.SavedGameFinishedDisplay != 1)
			{
				LoggingHelper.DebugLog("Text file will not be shown. Game has not been finished.", LoggingHelper.LoggingCategory.TEXT_FILE);
				return false;
			}
			if (customTextFile.UnlockRequiredCallers != null && customTextFile.UnlockRequiredCallers.Count > 0 && !AccuracyHelper.CheckIfCallerRequirementsAreMet(customTextFile.UnlockRequiredCallers, LoggingHelper.LoggingCategory.TEXT_FILE))
			{
				LoggingHelper.DebugLog("Text file will not be shown. A caller requirement was not met.", LoggingHelper.LoggingCategory.TEXT_FILE);
				return false;
			}
			if (!CheckAllAccuracyRequirements(customTextFile))
			{
				return false;
			}
			return true;
		}
	}
	public static class AccuracyVideoHelper
	{
		private static bool CheckIfDayValid(GeneralAccuracyType accuracyType, CustomVideo video)
		{
			int? num = accuracyType.CheckDay;
			if (!accuracyType.CheckDay.HasValue)
			{
				num = video.UnlockDay - 1;
			}
			if (num <= 0 || num <= GlobalVariables.currentDay)
			{
				return true;
			}
			LoggingHelper.DebugLog($"Checking video accuracy day of '{num}' " + $"on day '{GlobalVariables.currentDay}'. " + $"(Accuracy type check day: '{accuracyType.CheckDay}')", LoggingHelper.LoggingCategory.VIDEO);
			return false;
		}

		private static float? GetAccuracyOfDay(int? unlockDay, CustomVideo video)
		{
			if (!unlockDay.HasValue)
			{
				unlockDay = video.UnlockDay - 1;
			}
			if (unlockDay <= 0)
			{
				LoggingHelper.WarningLog("Unable of getting video accuracy for any day that isn't the first. " + $"Unlock day '{unlockDay}' with unlock day of " + $"'{video.UnlockDay}' is thus invalid.");
				return null;
			}
			if (CustomCampaignGlobal.InCustomCampaign)
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return null;
				}
				if (activeCustomCampaign.SavedDayScores.Count > unlockDay)
				{
					return activeCustomCampaign.SavedDayScores[unlockDay.Value] / 100f;
				}
			}
			else
			{
				int? num = unlockDay;
				if (PlayerPrefs.HasKey("SavedDayScore" + num))
				{
					num = unlockDay;
					return PlayerPrefs.GetFloat("SavedDayScore" + num) / 100f;
				}
			}
			return null;
		}

		private static bool CheckAllAccuracyRequirements(CustomVideo customVideo)
		{
			if (customVideo.UnlockAccuracy == null)
			{
				return true;
			}
			foreach (GeneralAccuracyType accuracyType in customVideo.UnlockAccuracy)
			{
				if (!CheckIfDayValid(accuracyType, customVideo))
				{
					LoggingHelper.DebugLog(() => "Accuracy day not reached.", LoggingHelper.LoggingCategory.VIDEO);
					return false;
				}
				float? accuracyOfDay = GetAccuracyOfDay(accuracyType.CheckDay, customVideo);
				if (!accuracyOfDay.HasValue)
				{
					LoggingHelper.WarningLog("Unable of getting accuracy of a day. Possible logic error? Not showing video.");
					return false;
				}
				float currentAccuracy = accuracyOfDay.Value;
				int? checkDay;
				if (!accuracyType.CheckDay.HasValue)
				{
					checkDay = customVideo.UnlockDay - 1;
				}
				else
				{
					checkDay = accuracyType.CheckDay;
				}
				LoggingHelper.DebugLog(() => $"The current accuracy is '{currentAccuracy}' of day '{checkDay}' " + $"(Video Unlock Day: '{customVideo.UnlockDay}') " + "with check type: '" + accuracyType.AccuracyCheck.ToString() + "'. " + $"With required accuracy of '{accuracyType.RequiredAccuracy}'.", LoggingHelper.LoggingCategory.VIDEO);
				switch (accuracyType.AccuracyCheck)
				{
				case AccuracyHelper.CheckOptions.EqualTo:
					if (!Mathf.Approximately(accuracyType.RequiredAccuracy, currentAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.GreaterThanOrEqualTo:
					if (!(currentAccuracy >= accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.LessThanOrEqualTo:
					if (!(currentAccuracy <= accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				case AccuracyHelper.CheckOptions.NotEqualTo:
					if (Mathf.Approximately(currentAccuracy, accuracyType.RequiredAccuracy))
					{
						return false;
					}
					break;
				}
			}
			return true;
		}

		public static bool CheckIfVideoAccuracyType(CustomVideo customVideo)
		{
			LoggingHelper.DebugLog("Checking customVideo accuracy type.", LoggingHelper.LoggingCategory.VIDEO);
			if (customVideo.UnlockDay > GlobalVariables.currentDay)
			{
				return false;
			}
			if (customVideo.UnlockWhenGameFinished && CustomCampaignGlobal.InCustomCampaign)
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return false;
				}
				if (activeCustomCampaign.SavedGameFinished != 1 && activeCustomCampaign.SavedGameFinishedDisplay != 1)
				{
					LoggingHelper.DebugLog("Video will not be shown. Game has not been finished.", LoggingHelper.LoggingCategory.VIDEO);
					return false;
				}
			}
			if (customVideo.UnlockRequiredCallers != null && customVideo.UnlockRequiredCallers.Count > 0 && !AccuracyHelper.CheckIfCallerRequirementsAreMet(customVideo.UnlockRequiredCallers, LoggingHelper.LoggingCategory.VIDEO))
			{
				LoggingHelper.DebugLog("Video will not be shown. A caller requirement was not met.", LoggingHelper.LoggingCategory.VIDEO);
				return false;
			}
			if (!CheckAllAccuracyRequirements(customVideo))
			{
				return false;
			}
			return true;
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.Fade
{
	public static class FadeScreenPatches
	{
		[HarmonyPatch(typeof(FadeBehavior), "Update")]
		public static class FadeBehaviorUpdatePatch
		{
			private static readonly FieldInfo IsFadingToBlack = typeof(FadeBehavior).GetField("isFadingToBlack", BindingFlags.Instance | BindingFlags.NonPublic);

			private static readonly FieldInfo TimeSinceFadeToBlack = typeof(FadeBehavior).GetField("timeSinceFadeToBlack", BindingFlags.Instance | BindingFlags.NonPublic);

			private static bool Prefix(FadeBehavior __instance)
			{
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					if (!(bool)IsFadingToBlack.GetValue(__instance))
					{
						TimeSinceFadeToBlack.SetValue(__instance, 0f);
					}
					else
					{
						float num = (float)TimeSinceFadeToBlack.GetValue(__instance) + Time.deltaTime;
						TimeSinceFadeToBlack.SetValue(__instance, num);
						if ((double)(float)TimeSinceFadeToBlack.GetValue(__instance) < 15.0)
						{
							return false;
						}
						__instance.FadeOut(0.5f);
					}
				}
				return false;
			}
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.Abstract
{
	public abstract class CustomCampaignElementBase
	{
		public string CustomCampaignName = null;
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.Desktop
{
	public static class DesktopBackgroundPatches
	{
		[HarmonyPatch(typeof(DayNumSpriteSwapper), "Start")]
		public static class StartPatch
		{
			private static GameObject animatedVideoBackground;

			private static bool Prefix(DayNumSpriteSwapper __instance)
			{
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_059f: Unknown result type (might be due to invalid IL or missing references)
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					animatedVideoBackground = AnimatedImageHelper.CreateAnimatedPortrait(((Component)__instance).gameObject, deleteChildren: true, deleteDaySpriteSwapper: true, setAsFirstChild: true);
					bool flag = false;
					Color? val = null;
					if (activeCustomCampaign.DisableGreenColorBackground)
					{
						flag = true;
					}
					(bool, bool) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DisableColorBackground);
					(bool, Color?) activeModifierValue2 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DesktopBackgroundColor, (Color? v) => v.HasValue);
					if (activeModifierValue.Item1 && activeModifierValue.Item2)
					{
						flag = true;
					}
					if (activeModifierValue2.Item1)
					{
						val = activeModifierValue2.Item2;
					}
					if (flag)
					{
						((Graphic)__instance.myImage).color = Color.white;
					}
					else if (val.HasValue)
					{
						((Graphic)__instance.myImage).color = val.Value;
					}
					Sprite val2 = ((GlobalVariables.saveManagerScript.savedGameFinishedDisplay == 1 || activeCustomCampaign.SavedGameFinishedDisplay == 1) ? ((!((Object)(object)activeCustomCampaign.GameFinishedBackground != (Object)null)) ? __instance.gameFinishedSprite : activeCustomCampaign.GameFinishedBackground) : ((activeCustomCampaign.BackgroundSprites.Count > 0 && GlobalVariables.currentDay <= activeCustomCampaign.BackgroundSprites.Count) ? activeCustomCampaign.BackgroundSprites[GlobalVariables.currentDay - 1] : ((GlobalVariables.currentDay <= __instance.spritesPerDay.Length) ? __instance.spritesPerDay[GlobalVariables.currentDay - 1] : __instance.spritesPerDay[0])));
					(bool, List<Sprite>) activeModifierValue3 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DesktopBackgrounds, (List<Sprite> v) => v != null && v.Count > 0);
					(bool, VariableChanged<Sprite>) activeModifierValue4 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.GameFinishedBackground, (VariableChanged<Sprite> vCs) => vCs.HasChanged);
					(bool, List<int>) activeModifierValue5 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.UnlockDays, (List<int> v) => v != null && v.Count > 0);
					if (activeModifierValue3.Item1)
					{
						if (GlobalVariables.saveManagerScript.savedGameFinishedDisplay == 1 || activeCustomCampaign.SavedGameFinishedDisplay == 1)
						{
							if (activeModifierValue4.Item1)
							{
								if (!activeModifierValue5.Item1 || activeModifierValue5.Item2 == null || activeModifierValue5.Item2.Count <= 0)
								{
									val2 = activeModifierValue4.Item2.Data;
								}
								else if (activeModifierValue5.Item2.Contains(GlobalVariables.currentDay))
								{
									val2 = activeModifierValue4.Item2.Data;
								}
							}
						}
						else if (!activeModifierValue5.Item1 || activeModifierValue5.Item2 == null)
						{
							if (activeModifierValue3.Item2.Count > 0 && GlobalVariables.currentDay <= activeModifierValue3.Item2.Count)
							{
								val2 = activeModifierValue3.Item2[(GlobalVariables.currentDay - 1) % activeModifierValue3.Item2.Count];
							}
						}
						else if (activeModifierValue5.Item2.Count > 0)
						{
							for (int num = 0; num < activeModifierValue5.Item2.Count; num++)
							{
								if (GlobalVariables.currentDay == activeModifierValue5.Item2[num])
								{
									val2 = activeModifierValue3.Item2[num % activeModifierValue3.Item2.Count];
								}
							}
						}
					}
					if ((Object)(object)val2 != (Object)null)
					{
						__instance.myImage.sprite = val2;
					}
					else
					{
						__instance.myImage.sprite = __instance.spritesPerDay[0];
					}
					(bool, VariableChanged<bool>) activeModifierValue6 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.AnimatedDesktopBackgroundShouldLoop, (VariableChanged<bool> vSv) => vSv.HasChanged);
					(bool, List<string>) activeModifierValue7 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.AnimatedDesktopBackgrounds, (List<string> v) => v != null && v.Count > 0);
					(bool, bool) activeModifierValue8 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.BlackBackgroundOnAnimatedBackground);
					if (activeModifierValue7.Item1)
					{
						if (activeModifierValue8.Item1 && activeModifierValue8.Item2)
						{
							__instance.myImage.sprite = null;
							if (!activeModifierValue2.Item1)
							{
								((Graphic)__instance.myImage).color = Color.black;
							}
						}
						if (!activeModifierValue5.Item1 || activeModifierValue5.Item2 == null)
						{
							if (activeModifierValue7.Item2.Count > 0 && GlobalVariables.currentDay <= activeModifierValue7.Item2.Count)
							{
								AnimatedImageHelper.SetVideoUrl(activeModifierValue7.Item2[(GlobalVariables.currentDay - 1) % activeModifierValue7.Item2.Count], animatedVideoBackground);
							}
						}
						else if (activeModifierValue5.Item2.Count > 0)
						{
							for (int num2 = 0; num2 < activeModifierValue5.Item2.Count; num2++)
							{
								if (GlobalVariables.currentDay == activeModifierValue5.Item2[num2])
								{
									AnimatedImageHelper.SetVideoUrl(activeModifierValue7.Item2[num2 % activeModifierValue7.Item2.Count], animatedVideoBackground);
								}
							}
						}
						if (activeModifierValue6.Item1)
						{
							if (activeModifierValue6.Item2.Data)
							{
								AnimatedImageHelper.EnableVideoLoop(animatedVideoBackground);
							}
							else
							{
								AnimatedImageHelper.DisableVideoLoop(animatedVideoBackground);
							}
						}
					}
				}
				else
				{
					__instance.myImage.sprite = __instance.spritesPerDay[GlobalVariables.currentDay - 1];
					if (GlobalVariables.saveManagerScript.savedGameFinishedDisplay != 1)
					{
						return false;
					}
					__instance.myImage.sprite = __instance.gameFinishedSprite;
				}
				return false;
			}
		}
	}
	public static class OnDayUnlockPatches
	{
		[HarmonyPatch(typeof(OnDayUnlock), "OnEnable")]
		public static class OnEnablePatch
		{
			private static bool Prefix(OnDayUnlock __instance)
			{
				if (GlobalVariables.arcadeMode)
				{
					return false;
				}
				if (!__instance.enableForArcadeMode)
				{
					if (CustomCampaignGlobal.InCustomCampaign)
					{
						string name = ((Object)((Component)__instance).gameObject).name;
						bool modifierApplied = false;
						bool flag = false;
						switch (name)
						{
						case "EntryBrowser-Executable":
							flag = HandleEntryBrowserUnlocker(ref __instance, ref modifierApplied);
							break;
						case "Scorecard":
							flag = HandleScorecardUnlocker(ref __instance, ref modifierApplied);
							break;
						case "Artbook-Executable":
							flag = HandleArtbookUnlocker(ref __instance, ref modifierApplied);
							break;
						case "Arcade-Executable":
							flag = HandleArcadeUnlocker(ref __instance, ref modifierApplied);
							break;
						case "DLC-Executable(Clone)":
							flag = HandleCustomCampaignIconsTooEarly(ref __instance);
							break;
						}
						if (flag)
						{
							return false;
						}
						if (modifierApplied)
						{
							((Component)__instance).gameObject.SetActive(false);
							return false;
						}
					}
					else if (HandleCustomCampaignIconsTooEarly(ref __instance))
					{
						return false;
					}
					if (GlobalVariables.currentDay < __instance.unlockDay)
					{
						((Component)__instance).gameObject.SetActive(false);
						LoggingHelper.DebugLog(() => $"Day to unlock ({__instance.unlockDay}) has not been reached. " + "Disabling this GameObject ('" + ((Object)((Component)__instance).gameObject).name + "'). (Main and Custom Campaign). " + $"Current day: {GlobalVariables.currentDay}.\n");
					}
					else
					{
						if (!CustomCampaignGlobal.InCustomCampaign)
						{
							if (PlayerPrefs.HasKey("SavedDayScore" + (__instance.unlockDay - 1)))
							{
								if ((double)PlayerPrefs.GetFloat("SavedDayScore" + (__instance.unlockDay - 1)) < (double)__instance.scoreThresholdToUnlock)
								{
									((Component)__instance).gameObject.SetActive(false);
								}
								else
								{
									LoggingHelper.DebugLog(() => "[UNITY]: Email unlocked: " + ((Object)((Component)__instance).gameObject).name + "| Day Checked: " + (__instance.unlockDay - 1) + "| Day Score: " + PlayerPrefs.GetFloat("SavedDayScore" + (__instance.unlockDay - 1)).ToString(CultureInfo.InvariantCulture));
								}
							}
						}
						else
						{
							CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
							if (customCampaign == null)
							{
								return true;
							}
							int unlockDay = __instance.unlockDay - 1;
							if (unlockDay < 0)
							{
								unlockDay = 0;
							}
							LoggingHelper.DebugLog(() => "This GameObject (For GameObject: '" + ((Object)((Component)__instance).gameObject).name + "') " + $"unlocks on day: {__instance.unlockDay} (Current Day is {GlobalVariables.currentDay}). " + $"The threshold is: {__instance.scoreThresholdToUnlock}. " + $"The current score for the day {__instance.unlockDay - 1} is {customCampaign.SavedDayScores[unlockDay]}. " + $"Is threshold over 0? '{__instance.scoreThresholdToUnlock > 0f}'.");
							EmailListingBehavior component = ((Component)__instance).gameObject.GetComponent<EmailListingBehavior>();
							LoggingHelper.DebugLog("Checking if GameObject is email. " + $"Is email null? '{(Object)(object)component == (Object)null}'", LoggingHelper.LoggingCategory.EMAIL);
							if ((Object)(object)component != (Object)null)
							{
								LoggingHelper.DebugLog("Found Email to be unlocked.", LoggingHelper.LoggingCategory.EMAIL);
								CustomEmail customEmailFromActiveCampaign = CustomCampaignGlobal.GetCustomEmailFromActiveCampaign(component.myEmail);
								if (customEmailFromActiveCampaign != null)
								{
									if (AccuracyEmailHelper.CheckIfEmailAccuracyType(customEmailFromActiveCampaign))
									{
										LoggingHelper.DebugLog("Email allowed to be shown.", LoggingHelper.LoggingCategory.EMAIL);
										return false;
									}
									LoggingHelper.DebugLog("One of the checks failed, deactivating email.", LoggingHelper.LoggingCategory.EMAIL);
									((Component)__instance).gameObject.SetActive(false);
									return false;
								}
							}
							if (__instance.scoreThresholdToUnlock > 0f)
							{
								if ((double)customCampaign.SavedDayScores[unlockDay] < (double)__instance.scoreThresholdToUnlock)
								{
									LoggingHelper.DebugLog(() => $"The score {customCampaign.SavedDayScores[unlockDay]} for day {unlockDay} is not enough to unlock. " + $"Required for Score: '{__instance.scoreThresholdToUnlock}' for this GameObject. " + "Disabling this GameObject '" + ((Object)((Component)__instance).gameObject).name + "'.\n");
									((Component)__instance).gameObject.SetActive(false);
								}
								else
								{
									LoggingHelper.DebugLog(() => "[UNITY] GameObject unlocked: " + ((Object)((Component)__instance).gameObject).name + "| Day Checked: " + unlockDay + "| Day Score: " + $"{customCampaign.SavedDayScores[unlockDay]}.\n", LoggingHelper.LoggingCategory.EMAIL);
								}
							}
							VideoExecutableFile val = default(VideoExecutableFile);
							if (((Component)__instance).gameObject.TryGetComponent<VideoExecutableFile>(ref val))
							{
								CustomVideo customVideoFromActiveCampaign = CustomCampaignGlobal.GetCustomVideoFromActiveCampaign(((Component)__instance).gameObject);
								if (customVideoFromActiveCampaign != null)
								{
									LoggingHelper.DebugLog("Found video on desktop '" + customVideoFromActiveCampaign.DesktopName + "'.", LoggingHelper.LoggingCategory.VIDEO);
									if (!customVideoFromActiveCampaign.IgnoreAccuracyChecks)
									{
										if (AccuracyVideoHelper.CheckIfVideoAccuracyType(customVideoFromActiveCampaign))
										{
											LoggingHelper.DebugLog("Video allowed to be shown.", LoggingHelper.LoggingCategory.VIDEO);
											return false;
										}
										LoggingHelper.DebugLog("One of the checks failed, deactivating video.", LoggingHelper.LoggingCategory.VIDEO);
										((Component)__instance).gameObject.SetActive(false);
										return false;
									}
								}
							}
						}
						if (!__instance.beatGameUnlock || !Object.op_Implicit((Object)(object)GlobalVariables.saveManagerScript) || GlobalVariables.saveManagerScript.savedGameFinished >= 1 || (__instance.xmasUnlock && GlobalVariables.isXmasDLC))
						{
							LoggingHelper.DebugLog(() => "GameObject '" + ((Object)((Component)__instance).gameObject).name + "' is unlocked! This may be due to it always being unlocked or by beating the game or being in winter DLC. " + $"BeatGameUnlock: '{__instance.beatGameUnlock}'. " + $"SaveManagerScript: '{Object.op_Implicit((Object)(object)GlobalVariables.saveManagerScript)}'. " + $"SaveManagerScript Game Finished: '{GlobalVariables.saveManagerScript.savedGameFinished >= 1}'. " + $"XmasUnlock: '{__instance.xmasUnlock && GlobalVariables.isXmasDLC}'.\n");
							return false;
						}
						LoggingHelper.DebugLog(() => "Didn't beat the game to unlock this or not in winter DLC. Disabling the GameObject '" + ((Object)((Component)__instance).gameObject).name + "'." + $" BeatGameUnlock: '{__instance.beatGameUnlock}'." + $" SaveManagerScript: '{Object.op_Implicit((Object)(object)GlobalVariables.saveManagerScript)}'." + $" SaveManagerScript Game Finished: '{GlobalVariables.saveManagerScript.savedGameFinished >= 1}'." + $" XmasUnlock: '{__instance.xmasUnlock && GlobalVariables.isXmasDLC}'.\n");
						((Component)__instance).gameObject.SetActive(false);
					}
				}
				else
				{
					LoggingHelper.DebugLog("Disabling UI Icon. GameObject made for Arcade.");
					((Component)__instance).gameObject.SetActive(false);
				}
				return false;
			}
		}

		public static bool HandleEntryBrowserUnlocker(ref OnDayUnlock __instance, ref bool modifierApplied)
		{
			if (((Object)((Component)__instance).gameObject).name == "EntryBrowser-Executable")
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return false;
				}
				bool result = false;
				(bool, VariableChanged<bool>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DisplayEntryBrowserOnDesktop, (VariableChanged<bool> vCb) => vCb.HasChanged);
				if (activeCustomCampaign.EntryBrowserAlwaysActive)
				{
					result = true;
				}
				if (activeModifierValue.Item1)
				{
					modifierApplied = true;
					result = activeModifierValue.Item2.Data;
				}
				return result;
			}
			return false;
		}

		public static bool HandleScorecardUnlocker(ref OnDayUnlock __instance, ref bool modifierApplied)
		{
			if (((Object)((Component)__instance).gameObject).name == "Scorecard")
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return false;
				}
				bool result = false;
				(bool, VariableChanged<bool>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DisplayScorecardOnDesktop, (VariableChanged<bool> vCb) => vCb.HasChanged);
				if (activeCustomCampaign.ScorecardAlwaysActive)
				{
					result = true;
				}
				if (activeModifierValue.Item1)
				{
					modifierApplied = true;
					result = activeModifierValue.Item2.Data;
				}
				return result;
			}
			return false;
		}

		public static bool HandleArtbookUnlocker(ref OnDayUnlock __instance, ref bool modifierApplied)
		{
			if (((Object)((Component)__instance).gameObject).name == "Artbook-Executable")
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					return false;
				}
				bool result = false;
				(bool, VariableChanged<bool>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DisplayArtbookOnDesktop, (VariableChanged<bool> vCb) => vCb.HasChanged);
				if (activeCustomCampaign.ArtbookAlwaysActive)
				{
					result = true;
				}
				if (activeModifierValue.Item1)
				{
					modifierApplied = true;
					result = activeModifierValue.Item2.Data;
				}
				return result;
			}
			return false;
		}

		public static bool HandleArcadeUnlocker(ref OnDayUnlock __instance, ref bool modifierApplied)
		{
			if (((Object)((Component)__instance).gameObject).name == "Arcade-Executable")
			{
				CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
				if (activeCustomCampaign == null)
				{
					LoggingHelper.CampaignNullError();
					return false;
				}
				bool result = false;
				(bool, VariableChanged<bool>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DisplayArcadeOnDesktop, (VariableChanged<bool> vCb) => vCb.HasChanged);
				if (activeCustomCampaign.ArcadeAlwaysActive)
				{
					result = true;
				}
				if (activeModifierValue.Item1)
				{
					modifierApplied = true;
					result = activeModifierValue.Item2.Data;
				}
				return result;
			}
			return false;
		}

		public static bool HandleCustomCampaignIconsTooEarly(ref OnDayUnlock __instance)
		{
			if (((Object)((Component)__instance).gameObject).name == "DLC-Executable(Clone)")
			{
				return true;
			}
			return false;
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.CutsceneLogic
{
	public class CustomCutscene : CustomCampaignElementBase
	{
		[CanBeNull]
		public string CutsceneVideoPath = null;

		[CanBeNull]
		public List<GeneralAccuracyType> UnlockAccuracy = null;

		[CanBeNull]
		public List<CallerRequirement> UnlockRequiredCallers = null;

		public int ApplyPriority = 0;
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.CustomTextFiles
{
	public class CustomTextFile : CustomCampaignElementBase
	{
		public string FileNameOnDesktop = "file.txt";

		public string TextFileContents = "Empty";

		public int UnlockDay = 0;

		public int OrderPriority = 0;

		public VariableChanged<int> GameObjectOrder = new VariableChanged<int>
		{
			Data = 0
		};

		[CanBeNull]
		public List<GeneralAccuracyType> UnlockAccuracy = null;

		[CanBeNull]
		public List<CallerRequirement> UnlockRequiredCallers = null;

		public bool UnlockWhenGameFinished = false;

		public GameObject CustomTextFileReference = null;
	}
	public static class CustomTextFileHelper
	{
		public static Sprite TextFileIcon;

		public static GameObject CreateCustomTextFile(CustomTextFile customTextFile)
		{
			GameObject gameObject = ((Component)CustomDesktopHelper.GetLeftPrograms().transform.Find("Readme")).gameObject;
			GameObject val = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent);
			if (string.IsNullOrEmpty(customTextFile.FileNameOnDesktop))
			{
				LoggingHelper.ErrorLog("No desktop name provided for the custom text file to be created!");
			}
			((Object)val).name = customTextFile.FileNameOnDesktop + customTextFile.UnlockDay;
			if ((Object)(object)TextFileIcon != (Object)null)
			{
				val.GetComponent<Image>().sprite = TextFileIcon;
			}
			TextMeshProUGUI component = ((Component)((Component)val.transform.Find("TextBackground")).transform.Find("ExecutableName")).gameObject.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = customTextFile.FileNameOnDesktop;
			TextFileExecutable component2 = val.GetComponent<TextFileExecutable>();
			component2.myContent = customTextFile.TextFileContents;
			if (customTextFile.GameObjectOrder.HasChanged)
			{
				((Component)component2).transform.SetSiblingIndex(customTextFile.GameObjectOrder.Data);
			}
			val.SetActive(true);
			if (GlobalVariables.currentDay < customTextFile.UnlockDay)
			{
				val.SetActive(false);
			}
			if (!AccuracyTextFileHelper.CheckIfTextFilePassAccuracyChecks(customTextFile))
			{
				val.SetActive(false);
			}
			customTextFile.CustomTextFileReference = val;
			return val;
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.CustomRingtone
{
	public class CustomRingtone : CustomCampaignElementBase
	{
		public string RingtoneClipPath = "";

		public RichAudioClip RingtoneClip = null;

		public bool AppendRingtone = false;

		public float PlayChance = 1f;

		public int UnlockDay = 0;

		public bool OnlyOnUnlockDay = true;

		public bool IsGlitchedVersion = false;
	}
	public static class RingtoneHelper
	{
		public static RichAudioClip ReplacePhoneRingtoneIfValid(ref List<CustomRingtone> validRingtones, bool doNotAccountDefaultRingtone, ref RichAudioClip gameDefaultRingtone)
		{
			LoggingHelper.DebugLog($"Finding valid ringtone with '{validRingtones.Count > 0}' ringtones available. " + $"Do we include the default ringtone? '{doNotAccountDefaultRingtone}'.", LoggingHelper.LoggingCategory.RINGTONE);
			if (validRingtones.Count <= 0)
			{
				return gameDefaultRingtone;
			}
			List<CustomRingtone> collection = validRingtones.Where((CustomRingtone r) => r.AppendRingtone).ToList();
			List<CustomRingtone> workingList = new List<CustomRingtone>(collection);
			if (workingList.Count <= 0)
			{
				return validRingtones[0].RingtoneClip;
			}
			if (!doNotAccountDefaultRingtone)
			{
				workingList.Add(new CustomRingtone
				{
					AppendRingtone = true,
					RingtoneClip = gameDefaultRingtone,
					PlayChance = 1f
				});
			}
			float percentageSum = 0f;
			foreach (CustomRingtone item in workingList)
			{
				percentageSum += item.PlayChance;
			}
			if (percentageSum <= 0f)
			{
				return gameDefaultRingtone;
			}
			float chosenPhoneCallPercentage = Random.Range(0f, percentageSum);
			LoggingHelper.DebugLog(() => $"(Random Number that was chosen) ChosenPhoneCall Percentage: '{chosenPhoneCallPercentage}'.\n" + $"percentageSum: '{percentageSum}'.\n" + $"doNotAccountDefaultRingtone: '{doNotAccountDefaultRingtone}'.\n" + $"Do we have any append ringtones?: '{workingList.Count > 0}'.\n" + $"How many append ringtones?: '{workingList.Count}'.\n", LoggingHelper.LoggingCategory.RINGTONE);
			float num = 0f;
			foreach (CustomRingtone item2 in workingList)
			{
				num += item2.PlayChance;
				if (chosenPhoneCallPercentage < num)
				{
					return item2.RingtoneClip;
				}
			}
			return gameDefaultRingtone;
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.CustomCampaignModel
{
	public class CustomCampaign
	{
		public string CampaignName = "NO_CAMPAIGN_NAME_PROVIDED";

		public int CampaignDays = 7;

		public Sprite CampaignIcon = null;

		public string CampaignDesktopName = "NO_CAMPAIGN_DESKTOP_NAME";

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

		public List<CustomCCaller> CustomCallersInCampaign = new List<CustomCCaller>();

		public List<CustomCCaller> CustomWarningCallersInCampaign = new List<CustomCCaller>();

		public List<CustomCCaller> CustomGameOverCallersInCampaign = new List<CustomCCaller>();

		public int GameOverThreshold = 60;

		public int WarningThreshold = 60;

		public List<int> WarningCallThresholdCallerAmounts = new List<int>();

		public List<EntryMetadata> EntriesOnlyInCampaign = new List<EntryMetadata>();

		public List<EntryMetadata> EntryReplaceOnlyInCampaign = new List<EntryMetadata>();

		public bool RemoveExistingEntries = false;

		public bool UseDLCEntries = false;

		public bool ResetDefaultEntriesPermission = false;

		public bool DoShowNewTagForMainGameEntries = false;

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

		public bool SkipCallersCorrectly = false;

		public bool GameOverImmunity = false;

		public string DesktopUsernameText = "";

		public int DesktopDateStartYear = -1;

		public int DesktopDateStartMonth = -1;

		public int DesktopDateStartDay = -1;

		public bool UseEuropeDateFormat = false;

		public MelonPreferences_Category CampaignSaveCategory = null;

		public int CurrentDay = 1;

		public int SavedCurrentCaller = 0;

		public int CurrentPermissionTier = 1;

		public int SavedCallerArrayLength = 0;

		public List<bool> SavedCallersCorrectAnswer = new List<bool>();

		public int SavedGameFinished = 0;

		public int SavedGameFinishedDisplay = 0;

		public float SavedMusicVolume = 1f;

		public float SavedSFXVolume = 1f;

		public float SavedAmbienceVolume = 1f;

		public bool SavedCRTToggle = true;

		public bool SavedFullScreenToggle = true;

		public int SavedScreenHeight = 1080;

		public int SavedScreenWidth = 1920;

		public int SavedRefreshRate = 180;

		public bool SavedDyslexiaToggle = false;

		public float SavedTextSizeMultiplier = 1f;

		public bool SavedSpiderToggle = false;

		public bool SavedInsectToggle = false;

		public bool SavedDarkToggle = false;

		public bool SavedHoleToggle = false;

		public bool SavedWatchToggle = false;

		public bool SavedDogToggle = false;

		public bool SavedTightToggle = false;

		public bool SavedImmunityToggle = false;

		public bool SavedAccuracyToggle = false;

		public bool SavedCallSkipToggle = false;

		public List<float> SavedDayScores = new List<float>();

		public VariableChanged<bool> ShouldResetGameBeatenVariableOnReset = new VariableChanged<bool>
		{
			Data = false
		};

		public string EndCutsceneVideoName = "";

		public string GameOverCutsceneVideoName = "";

		public List<CustomCutscene> CustomCutscenes = new List<CustomCutscene>();

		public bool AlwaysRandomMusic = true;

		public bool RemoveDefaultMusic = false;

		public List<CustomMusic> CustomMusic = new List<CustomMusic>();

		public List<CustomMusic> CustomIntermissionMusic = new List<CustomMusic>();

		public List<float> WaitBetweenCallers = new List<float>();

		public bool EnableCustomWaitBetweenCallers = false;

		public bool EntryBrowserAlwaysActive = false;

		public bool ScorecardAlwaysActive = false;

		public bool ArtbookAlwaysActive = false;

		public bool ArcadeAlwaysActive = false;

		public string RenameMainGameDesktopIcon = null;

		public Sprite ChangeMainGameDesktopIcon = null;

		public bool AlwaysSkipCallButton = false;

		public bool RemoveDefaultEmails = true;

		public List<CustomEmail> Emails = new List<CustomEmail>();

		public List<Sprite> BackgroundSprites = new List<Sprite>();

		public Sprite GameFinishedBackground = null;

		public bool DisableDesktopLogo = false;

		public Sprite CustomDesktopLogo = null;

		public float CustomDesktopLogoTransparency = 0.2627f;

		public bool DisableGreenColorBackground = false;

		public bool DisableAllDefaultVideos = true;

		public List<CustomVideo> CustomVideos = new List<CustomVideo>();

		public List<CustomTextFile> CustomTextProgramFiles = new List<CustomTextFile>();

		public bool DisablePickingThemeOption = false;

		public bool DefaultThemeAppliedOnce = false;

		public string DefaultTheme = null;

		public int ActiveTheme = 0;

		public List<CustomTheme> CustomThemesGeneral = new List<CustomTheme>();

		public List<CustomTheme> CustomThemesDays = new List<CustomTheme>();

		public VariableChanged<bool> RemoveDefaultThemes = new VariableChanged<bool>
		{
			Data = false
		};

		public List<ModifierSource> ModifierSources = new List<ModifierSource>();

		public bool DoNotAccountDefaultRingtone = true;

		public List<NewSafetyHelp.CustomCampaignSystem.CustomRingtone.CustomRingtone> CustomRingtones = new List<NewSafetyHelp.CustomCampaignSystem.CustomRingtone.CustomRingtone>();

		public List<Computer3DScreen> CustomComputer3DScreens = new List<Computer3DScreen>();

		public VariableChanged<bool> Skip3DComputerScreenForCustomCampaign = new VariableChanged<bool>
		{
			Data = true
		};

		public VariableChanged<bool> FadeInCustomCampaign = new VariableChanged<bool>
		{
			Data = false
		};

		public List<LinkApp> LinkApps = new List<LinkApp>();

		public void SortCustomCallersInCustomCampaign()
		{
			CustomCallersInCampaign = CustomCallersInCampaign.OrderBy((CustomCCaller customCCaller) => customCCaller.OrderInCampaign).ToList();
		}

		public void SortEmailsInCustomCampaign()
		{
			Emails = (from email in Emails
				orderby email.UnlockDay, email.EmailPriority descending
				select email).ToList();
		}

		public void SortCutsceneInCustomCampaign()
		{
			CustomCutscenes = CustomCutscenes.OrderByDescending((CustomCutscene cutscene) => cutscene.ApplyPriority).ToList();
		}

		public void SortCustomVideoFiles()
		{
			CustomVideos = (from customVideo in CustomVideos
				orderby customVideo.UnlockDay descending, customVideo.OrderPriority descending, customVideo.DesktopName
				select customVideo).ToList();
		}

		public void SortTextFiles()
		{
			CustomTextProgramFiles = (from customTextFile in CustomTextProgramFiles
				orderby customTextFile.UnlockDay descending, customTextFile.OrderPriority descending, customTextFile.FileNameOnDesktop
				select customTextFile).ToList();
		}

		public void SortComputer3DScreens()
		{
			CustomComputer3DScreens = CustomComputer3DScreens.OrderByDescending((Computer3DScreen computer3DScreen) => computer3DScreen.ApplyPriority).ToList();
		}

		public void SortLinkApps()
		{
			LinkApps = LinkApps.OrderByDescending((LinkApp linkApp) => linkApp.LinkAppPriority).ToList();
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.CustomComputer3DScreen
{
	public class Computer3DScreen : CustomCampaignElementBase
	{
		public bool InMainCampaign = false;

		public int ApplyPriority = 0;

		public VariableChanged<bool> SkipClickTime = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Color> MainLightColor = new VariableChanged<Color>
		{
			Data = default(Color)
		};

		public VariableChanged<bool> DisableMainLight = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Color> SecondMainLightColor = new VariableChanged<Color>
		{
			Data = default(Color)
		};

		public VariableChanged<bool> DisableSecondMainLight = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Color> DeskLightColor = new VariableChanged<Color>
		{
			Data = default(Color)
		};

		public VariableChanged<bool> DisableDeskLight = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Color> KeyboardLightColor = new VariableChanged<Color>
		{
			Data = default(Color)
		};

		public VariableChanged<bool> DisableKeyboardLight = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Color> RightLightColor = new VariableChanged<Color>
		{
			Data = default(Color)
		};

		public VariableChanged<bool> DisableRightLight = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> DisableComputerScreen = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> DisableKeyboard = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> DisableTable = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Color> BackgroundColor = new VariableChanged<Color>
		{
			Data = default(Color)
		};

		public VariableChanged<bool> DisablePostProcessing = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> DisableParticles = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<int> ParticleEmissionRate = new VariableChanged<int>
		{
			Data = 10
		};

		public VariableChanged<float> ParticleStartSize = new VariableChanged<float>
		{
			Data = 0.01f
		};

		public VariableChanged<Color> ParticleColor = new VariableChanged<Color>
		{
			Data = default(Color)
		};

		public VariableChanged<Sprite> ParticleTexture = new VariableChanged<Sprite>
		{
			Data = null
		};

		public VariableChanged<List<string>> TitleText = new VariableChanged<List<string>>
		{
			Data = null
		};

		public VariableChanged<Sprite> TitleLogo = new VariableChanged<Sprite>
		{
			Data = null
		};

		public string MusicPath = null;

		public RichAudioClip Music = null;

		public VariableChanged<bool> BringMusicCloser = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> CenterMusic = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<float> MusicVolume = new VariableChanged<float>
		{
			Data = 0.07f
		};

		public VariableChanged<bool> DisableMusic = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<bool> EnableBackgroundImage = new VariableChanged<bool>
		{
			Data = false
		};

		public VariableChanged<Sprite> BackgroundImage = new VariableChanged<Sprite>
		{
			Data = null
		};

		public VariableChanged<bool> AddSun = new VariableChanged<bool>
		{
			Data = false
		};
	}
	public static class Computer3DScreenHelper
	{
		[CanBeNull]
		public static Computer3DScreen Pick3DComputerScreen()
		{
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				LoggingHelper.CampaignNullError();
				return null;
			}
			Computer3DScreen result = null;
			foreach (Computer3DScreen customComputer3DScreen in activeCustomCampaign.CustomComputer3DScreens)
			{
				result = customComputer3DScreen;
			}
			return result;
		}
	}
	public static class Custom3DScreenPatches
	{
		[HarmonyPatch(typeof(StartMenuBehavior), "Start")]
		public static class StartMenuPatches
		{
			private static readonly FieldInfo CanStartField = typeof(StartMenuBehavior).GetField("canStart", BindingFlags.Instance | BindingFlags.NonPublic);

			private static void Prefix(StartMenuBehavior __instance)
			{
				//IL_0289: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_0351: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0428: Unknown result type (might be due to invalid IL or missing references)
				//IL_055b: Unknown result type (might be due to invalid IL or missing references)
				//IL_060d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0612: Unknown result type (might be due to invalid IL or missing references)
				//IL_0622: Unknown result type (might be due to invalid IL or missing references)
				//IL_065e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0663: Unknown result type (might be due to invalid IL or missing references)
				//IL_0672: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_06bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_08d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0908: Unknown result type (might be due to invalid IL or missing references)
				//IL_090f: Expected O, but got Unknown
				//IL_0925: Unknown result type (might be due to invalid IL or missing references)
				//IL_093b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0940: Unknown result type (might be due to invalid IL or missing references)
				//IL_094e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0960: Unknown result type (might be due to invalid IL or missing references)
				//IL_0977: Unknown result type (might be due to invalid IL or missing references)
				//IL_098e: Unknown result type (might be due to invalid IL or missing references)
				//IL_09af: Unknown result type (might be due to invalid IL or missing references)
				//IL_09b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_09c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_09c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_09d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_09e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_09ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a00: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a05: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a21: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a35: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a3a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a67: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a71: Expected O, but got Unknown
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					return;
				}
				Computer3DScreen computer3DScreen = Computer3DScreenHelper.Pick3DComputerScreen();
				if (computer3DScreen == null)
				{
					return;
				}
				if (computer3DScreen.SkipClickTime.HasChanged && computer3DScreen.SkipClickTime.Data)
				{
					CanStartField.SetValue(__instance, true);
				}
				if ((Object)(object)computer3DScreen.Music != (Object)null && (Object)(object)computer3DScreen.Music.clip != (Object)null)
				{
					AudioSource[] components = GameObject.Find("MusicController").GetComponents<AudioSource>();
					AudioSource[] array = components;
					foreach (AudioSource val in array)
					{
						val.clip = computer3DScreen.Music.clip;
						if (val.playOnAwake && !val.isPlaying)
						{
							val.Play();
						}
					}
				}
				if (computer3DScreen.BringMusicCloser.HasChanged && computer3DScreen.BringMusicCloser.Data)
				{
					AudioSource[] components2 = GameObject.Find("MusicController").GetComponents<AudioSource>();
					AudioSource[] array2 = components2;
					foreach (AudioSource val2 in array2)
					{
						val2.minDistance = 5f;
					}
				}
				if (computer3DScreen.CenterMusic.HasChanged && computer3DScreen.CenterMusic.Data)
				{
					AudioSource[] components3 = GameObject.Find("MusicController").GetComponents<AudioSource>();
					AudioSource[] array3 = components3;
					foreach (AudioSource val3 in array3)
					{
						val3.spatialBlend = 0.5f;
					}
				}
				if (computer3DScreen.MusicVolume.HasChanged)
				{
					AudioSource[] components4 = GameObject.Find("MusicController").GetComponents<AudioSource>();
					AudioSource[] array4 = components4;
					foreach (AudioSource val4 in array4)
					{
						val4.volume = computer3DScreen.MusicVolume.Data;
					}
				}
				if (computer3DScreen.DisableMusic.HasChanged && computer3DScreen.DisableMusic.Data)
				{
					AudioSource[] components5 = GameObject.Find("MusicController").GetComponents<AudioSource>();
					AudioSource[] array5 = components5;
					foreach (AudioSource val5 in array5)
					{
						((Behaviour)val5).enabled = false;
					}
				}
				if (computer3DScreen.MainLightColor.HasChanged)
				{
					GameObject.Find("Point Light (1)").GetComponent<Light>().color = computer3DScreen.MainLightColor.Data;
				}
				if (computer3DScreen.DisableMainLight.HasChanged)
				{
					GameObject.Find("Point Light (1)").SetActive(!computer3DScreen.DisableMainLight.Data);
				}
				if (computer3DScreen.SecondMainLightColor.HasChanged)
				{
					GameObject.Find("Directional Light").GetComponent<Light>().color = computer3DScreen.SecondMainLightColor.Data;
				}
				if (computer3DScreen.DisableSecondMainLight.HasChanged)
				{
					GameObject.Find("Directional Light").SetActive(!computer3DScreen.DisableSecondMainLight.Data);
				}
				if (computer3DScreen.DeskLightColor.HasChanged)
				{
					GameObject.Find("Point Light (3)").GetComponent<Light>().color = computer3DScreen.DeskLightColor.Data;
				}
				if (computer3DScreen.DisableDeskLight.HasChanged)
				{
					GameObject.Find("Point Light (3)").SetActive(!computer3DScreen.DisableDeskLight.Data);
				}
				if (computer3DScreen.KeyboardLightColor.HasChanged)
				{
					GameObject.Find("Point Light").GetComponent<Light>().color = computer3DScreen.KeyboardLightColor.Data;
				}
				if (computer3DScreen.DisableKeyboardLight.HasChanged)
				{
					GameObject.Find("Point Light").SetActive(!computer3DScreen.DisableKeyboardLight.Data);
				}
				if (computer3DScreen.RightLightColor.HasChanged)
				{
					((Component)GameObject.Find("model").transform.Find("Point Light (2)")).GetComponent<Light>().color = computer3DScreen.RightLightColor.Data;
				}
				if (computer3DScreen.DisableRightLight.HasChanged)
				{
					((Component)GameObject.Find("model").transform.Find("Point Light (2)")).gameObject.SetActive(!computer3DScreen.DisableRightLight.Data);
				}
				if (computer3DScreen.DisableComputerScreen.HasChanged)
				{
					((Component)GameObject.Find("model").transform.Find("diannao")).gameObject.SetActive(!computer3DScreen.DisableComputerScreen.Data);
				}
				if (computer3DScreen.DisableKeyboard.HasChanged)
				{
					((Component)GameObject.Find("model").transform.Find("jianpan")).gameObject.SetActive(!computer3DScreen.DisableKeyboard.Data);
				}
				if (computer3DScreen.DisableTable.HasChanged)
				{
					GameObject.Find("Cube").SetActive(!computer3DScreen.DisableTable.Data);
				}
				if (computer3DScreen.BackgroundColor.HasChanged)
				{
					GameObject.Find("Main Camera").GetComponent<Camera>().backgroundColor = computer3DScreen.BackgroundColor.Data;
				}
				if (computer3DScreen.DisablePostProcessing.HasChanged)
				{
					GameObject.Find("Main Camera/Post-process Volume").SetActive(!computer3DScreen.DisablePostProcessing.Data);
				}
				if (computer3DScreen.DisableParticles.HasChanged)
				{
					((Component)GameObject.Find("model").transform.Find("Particle System")).gameObject.SetActive(!computer3DScreen.DisableParticles.Data);
				}
				if (computer3DScreen.ParticleEmissionRate.HasChanged)
				{
					EmissionModule emission = ((Component)GameObject.Find("model").transform.Find("Particle System")).GetComponent<ParticleSystem>().emission;
					((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit((float)computer3DScreen.ParticleEmissionRate.Data);
				}
				if (computer3DScreen.ParticleStartSize.HasChanged)
				{
					MainModule main = ((Component)GameObject.Find("model").transform.Find("Particle System")).GetComponent<ParticleSystem>().main;
					((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(computer3DScreen.ParticleStartSize.Data);
				}
				if (computer3DScreen.ParticleColor.HasChanged)
				{
					MainModule main2 = ((Component)GameObject.Find("model").transform.Find("Particle System")).GetComponent<ParticleSystem>().main;
					((MainModule)(ref main2)).startColor = MinMaxGradient.op_Implicit(computer3DScreen.ParticleColor.Data);
				}
				if (computer3DScreen.ParticleTexture.HasChanged)
				{
					ParticleSystemRenderer component = ((Component)GameObject.Find("model").transform.Find("Particle System")).GetComponent<ParticleSystemRenderer>();
					((Renderer)component).material.mainTexture = (Texture)(object)computer3DScreen.ParticleTexture.Data.texture;
				}
				if (computer3DScreen.TitleText.HasChanged)
				{
					AnimatedText component2 = GameObject.Find("TitleCanvas/Text (TMP)").GetComponent<AnimatedText>();
					component2.textFrames = new string[computer3DScreen.TitleText.Data.Count];
					for (int n = 0; n < computer3DScreen.TitleText.Data.Count; n++)
					{
						component2.textFrames[n] = computer3DScreen.TitleText.Data[n];
					}
					if (computer3DScreen.TitleText.Data.Count >= 1)
					{
						((TMP_Text)GameObject.Find("TitleCanvas/Text (TMP)").GetComponent<TextMeshProUGUI>()).text = computer3DScreen.TitleText.Data[0];
					}
				}
				if (computer3DScreen.TitleLogo.HasChanged)
				{
					GameObject.Find("TitleCanvas/Image").GetComponent<Image>().sprite = computer3DScreen.TitleLogo.Data;
				}
				if (computer3DScreen.EnableBackgroundImage.HasChanged && computer3DScreen.EnableBackgroundImage.Data)
				{
					GameObject val6 = GameObject.Find("TitleCanvas/Image");
					GameObject val7 = Object.Instantiate<GameObject>(val6, val6.transform.parent);
					((Object)val7).name = "BackgroundImageObject";
					val7.transform.SetAsFirstSibling();
					if (computer3DScreen.BackgroundImage.HasChanged)
					{
						val7.GetComponent<Image>().sprite = computer3DScreen.BackgroundImage.Data;
					}
					else
					{
						val7.GetComponent<Image>().sprite = EmbeddedTimerData.ClockBase;
					}
					((Transform)val7.GetComponent<RectTransform>()).localPosition = new Vector3(-350f, 180f, 50f);
				}
				if (computer3DScreen.AddSun.HasChanged && computer3DScreen.AddSun.Data)
				{
					GameObject val8 = new GameObject("SunObject");
					val8.transform.position = new Vector3(20.64f, 8.31f, -30.11f);
					ParticleSystem val9 = val8.AddComponent<ParticleSystem>();
					MainModule main3 = val9.main;
					((MainModule)(ref main3)).startLifetime = new MinMaxCurve(5f, 25f);
					((MainModule)(ref main3)).startSpeed = MinMaxCurve.op_Implicit(0f);
					((MainModule)(ref main3)).startSize = new MinMaxCurve(10f, 25f);
					((MainModule)(ref main3)).startRotation = new MinMaxCurve(-180f, 180f);
					((MainModule)(ref main3)).startColor = MinMaxGradient.op_Implicit(new Color(255f, 220f, 194f, 255f));
					EmissionModule emission2 = val9.emission;
					((EmissionModule)(ref emission2)).enabled = true;
					((EmissionModule)(ref emission2)).rateOverTime = MinMaxCurve.op_Implicit(100f);
					ShapeModule shape = val9.shape;
					((ShapeModule)(ref shape)).enabled = true;
					((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)0;
					ColorOverLifetimeModule colorOverLifetime = val9.colorOverLifetime;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).color = new MinMaxGradient(new Color(255f, 172f, 45f), new Color(255f, 157f, 45f));
					ParticleSystemRenderer component3 = val8.GetComponent<ParticleSystemRenderer>();
					component3.maxParticleSize = 3f;
					((Renderer)component3).material = new Material(Shader.Find("Particles/Standard Unlit"));
				}
			}
		}
	}
}
namespace NewSafetyHelp.CustomCampaignSystem.ArtbookPatches
{
	public static class ArtbookRefreshPatches
	{
		[HarmonyPatch(typeof(ArtbookPopupBehavior), "RefreshPageContent")]
		public static class ArtbookRefreshPageContentPatch
		{
			private static readonly FieldInfo CurrentPage = typeof(ArtbookPopupBehavior).GetField("currentPage", BindingFlags.Instance | BindingFlags.NonPublic);

			public static bool Prefix(ArtbookPopupBehavior __instance)
			{
				int num = (int)CurrentPage.GetValue(__instance);
				((Component)__instance.image1).gameObject.SetActive(false);
				((Component)__instance.image2).gameObject.SetActive(false);
				if ((Object)(object)__instance.artbookPages[num].image != (Object)null)
				{
					((Component)__instance.image1).gameObject.SetActive(true);
					__instance.image1.sprite = __instance.artbookPages[num].image;
				}
				((TMP_Text)__instance.descriptionText).text = __instance.artbookPages[num].description;
				((TMP_Text)__instance.titleText).text = __instance.artbookPages[num].title;
				if ((Object)(object)__instance.artbookPages[num].image2 != (Object)null)
				{
					((Component)__instance.image2).gameObject.SetActive(true);
					__instance.image2.sprite = __instance.artbookPages[num].image2;
				}
				if (num == __instance.artbookPages.Length - 1 && !CustomCampaignGlobal.InCustomCampaign)
				{
					SteamUserStats.SetAchievement("Artbook");
					SteamUserStats.StoreStats();
				}
				((TMP_Text)__instance.pageNumText).text = num + 1 + "/" + __instance.artbookPages.Length;
				return false;
			}
		}
	}
}
namespace NewSafetyHelp.Callers
{
	public static class CallerPatches
	{
		[HarmonyPatch(typeof(CallerController), "Start")]
		public static class AddCustomCampaign
		{
			private static bool Prefix(CallerController __instance)
			{
				//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c9: Expected O, but got Unknown
				//IL_0639: Unknown result type (might be due to invalid IL or missing references)
				//IL_0643: Expected O, but got Unknown
				//IL_0465: Unknown result type (might be due to invalid IL or missing references)
				//IL_046a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0471: Unknown result type (might be due to invalid IL or missing references)
				//IL_047b: Expected O, but got Unknown
				//IL_08bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_08c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_08ca: Expected O, but got Unknown
				LoggingHelper.DebugLog("Called Start from the class CallerController.");
				GlobalVariables.callerControllerScript = __instance;
				__instance.arcadeMode = GlobalVariables.arcadeMode;
				if (LastDayNum == null || CallerAudioSource == null || GetRandomPicMethod == null || GetRandomClip == null)
				{
					LoggingHelper.ReflectionError("LastDayNum", "CallerAudioSource", "GetRandomPicMethod", "GetRandomClip");
					return true;
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					LastDayNum.SetValue(__instance, __instance.mainGameLastDay);
				}
				else
				{
					LastDayNum.SetValue(__instance, CustomCampaignGlobal.GetActiveCustomCampaign().CampaignDays);
				}
				CallerAudioSource.SetValue(__instance, ((Component)__instance).GetComponent<AudioSource>());
				if (__instance.arcadeMode)
				{
					__instance.CreateCustomCaller();
				}
				if (GlobalVariables.isXmasDLC)
				{
					__instance.callers = null;
					__instance.callers = __instance.xmasCallers;
					__instance.warningCall = __instance.xmasWarningCall;
					__instance.gameOverCall = __instance.xmasGameOverCall;
					LastDayNum.SetValue(__instance, __instance.xmasLastDay);
					__instance.downedNetworkCalls = __instance.xmasDownedNetworkCalls;
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					foreach (KeyValuePair<int, CustomCCaller> item in GlobalParsingVariables.CustomCallersMainGame)
					{
						if (item.Key < 0 || item.Value == null)
						{
							LoggingHelper.ErrorLog($"Custom caller {item.Key} is invalid!");
							continue;
						}
						if (item.Value.InCustomCampaign)
						{
							LoggingHelper.WarningLog("Custom Caller is marked as custom campaign but is also main campaign! Skipping.");
							continue;
						}
						CallerProfile val = ScriptableObject.CreateInstance<CallerProfile>();
						if (!item.Value.IsCallerClipLoaded)
						{
							LoggingHelper.InfoLog("Audio is still loading for this custom caller. It will be updated once the audio has been updated.");
						}
						val.callerName = item.Value.CallerName;
						val.callTranscription = item.Value.CallTranscript;
						val.callerPortrait = item.Value.CallerImage;
						val.callerClip = item.Value.CallerClip;
						val.increaseTier = item.Value.CallerIncreasesTier;
						if (item.Value.EntryNameAttached != "NO_MONSTER_NAME")
						{
							MonsterProfile val2 = NewSafetyHelp.EntryManager.EntryManager.FindEntry(ref GameObject.Find("EntryUnlockController").GetComponent<EntryUnlockController>().allEntries.monsterProfiles, item.Value.EntryNameAttached);
							if ((Object)(object)val2 == (Object)null)
							{
								LoggingHelper.WarningLog("Provided entry (monster) name '" + item.Value.EntryNameAttached + "' " + $"for custom caller {item.Key} was not found! " + "Thus will not have any entry (monster).");
								val.callerMonster = null;
							}
							else
							{
								val.callerMonster = val2;
							}
						}
						else if (item.Value.EntryIDAttached >= 0)
						{
							MonsterProfile val3 = NewSafetyHelp.EntryManager.EntryManager.FindEntry(ref GameObject.Find("EntryUnlockController").GetComponent<EntryUnlockController>().allEntries.monsterProfiles, "SKIP_MONSTER_NAME_TO_SEARCH", item.Value.EntryIDAttached);
							if ((Object)(object)val3 == (Object)null)
							{
								LoggingHelper.WarningLog($"Provided entry (monster) ID for custom caller {item.Key} was not found! " + "Thus will not have any entry (monster).");
								val.callerMonster = null;
							}
							else
							{
								val.callerMonster = val3;
							}
						}
						else
						{
							val.callerMonster = null;
						}
						if (item.Value.ConsequenceCallerID >= 0)
						{
							if ((Object)(object)__instance.callers[item.Value.ConsequenceCallerID].callerProfile == (Object)null)
							{
								LoggingHelper.WarningLog("Provided consequence caller but profile was not found (Profile == null)? Setting to null.");
							}
							val.consequenceCallerProfile = __instance.callers[item.Value.ConsequenceCallerID].callerProfile;
						}
						else
						{
							val.consequenceCallerProfile = null;
						}
						Caller val4 = new Caller
						{
							answeredCorrectly = false,
							callerProfile = val
						};
						__instance.callers[item.Key] = val4;
					}
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					__instance.callers = (Caller[])(object)new Caller[activeCustomCampaign.CustomCallersInCampaign.Count];
					if (activeCustomCampaign.CustomCallersInCampaign.Count <= 0)
					{
						LoggingHelper.WarningLog("Custom Campaign has no custom caller assigned! Unexpected behavior will occur when in campaign.");
					}
					Dictionary<int, int> dictionary = new Dictionary<int, int>();
					foreach (CustomCCaller item2 in activeCustomCampaign.CustomCallersInCampaign)
					{
						CallerProfile val5 = ScriptableObject.CreateInstance<CallerProfile>();
						val5.callerName = item2.CallerName;
						val5.callTranscription = item2.CallTranscript;
						if ((Object)(object)item2.CallerClip == (Object)null)
						{
							if (AudioImport.CurrentLoadingAudios.Count > 0)
							{
								LoggingHelper.InfoLog("Custom Caller '" + item2.CallerName + "' is still loading its audio. Using fallback for now.");
							}
							else
							{
								LoggingHelper.WarningLog("Custom Caller '" + item2.CallerName + "' does not have any valid audio clip! Using fallback instead of real audio.");
							}
							val5.callerClip = (RichAudioClip)GetRandomClip.Invoke(__instance, new object[0]);
						}
						else
						{
							val5.callerClip = item2.CallerClip;
						}
						if ((Object)(object)item2.CallerImage == (Object)null)
						{
							LoggingHelper.WarningLog("Custom Caller '" + ((item2.CallerName != null) ? (item2.CallerName ?? "") : "") + "' does not have any valid image / sprite. Using fallback for now.");
							val5.callerPortrait = (Sprite)GetRandomPicMethod.Invoke(__instance, new object[0]);
						}
						else
						{
							val5.callerPortrait = item2.CallerImage;
						}
						if (item2.EntryNameAttached != "NO_MONSTER_NAME")
						{
							MonsterProfile val6 = NewSafetyHelp.EntryManager.EntryManager.FindEntry(ref GameObject.Find("EntryUnlockController").GetComponent<EntryUnlockController>().allEntries.monsterProfiles, item2.EntryNameAttached);
							if ((Object)(object)val6 == (Object)null)
							{
								LoggingHelper.WarningLog("Provided entry (monster) name '" + item2.EntryNameAttached + "' for custom caller " + item2.CallerName + " was not found! Thus will not have any entry (monster).");
								val5.callerMonster = null;
							}
							else
							{
								val5.callerMonster = val6;
							}
						}
						else if (item2.EntryIDAttached >= 0)
						{
							MonsterProfile val7 = NewSafetyHelp.EntryManager.EntryManager.FindEntry(ref GameObject.Find("EntryUnlockController").GetComponent<EntryUnlockController>().allEntries.monsterProfiles, "SKIP_MONSTER_NAME_TO_SEARCH", item2.EntryIDAttached);
							if ((Object)(object)val7 == (Object)null)
							{
								LoggingHelper.WarningLog("Provided entry (monster) ID for custom caller " + item2.CallerName + " was not found! Thus will not have any entry (monster).");
								val5.callerMonster = null;
							}
							else
							{
								val5.callerMonster = val7;
							}
						}
						if (item2.ConsequenceCallerID >= 0)
						{
							dictionary.Add(item2.OrderInCampaign, item2.ConsequenceCallerID);
						}
						val5.increaseTier = item2.CallerIncreasesTier;
						if (item2.OrderInCampaign < 0 || item2.OrderInCampaign >= activeCustomCampaign.CustomCallersInCampaign.Count)
						{
							LoggingHelper.ErrorLog("Provided order is not valid! (Might be missing a caller(s) in between callers!)" + $" (Info: Provided Order: {item2.OrderInCampaign}; " + $"CampaignSize: {activeCustomCampaign.CustomCallersInCampaign.Count})");
							continue;
						}
						if (__instance.callers[item2.OrderInCampaign] != null)
						{
							LoggingHelper.ErrorLog("Provided caller " + val5.callerName + " has replaced a previous caller at " + $"position {item2.OrderInCampaign}! " + "Reducing array size by 1 to compensate. Things might break!");
							Array.Resize(ref __instance.callers, __instance.callers.Length - 1);
						}
						__instance.callers[item2.OrderInCampaign] = new Caller
						{
							callerProfile = val5
						};
					}
					if (dictionary.Count > 0)
					{
						foreach (KeyValuePair<int, int> item3 in dictionary)
						{
							if (item3.Value < activeCustomCampaign.CustomCallersInCampaign.Count)
							{
								if (__instance.callers[item3.Key] != null && __instance.callers[item3.Value] != null)
								{
									__instance.callers[item3.Key].callerProfile.consequenceCallerProfile = __instance.callers[item3.Value].callerProfile;
								}
								else
								{
									LoggingHelper.ErrorLog("Provided consequence caller cannot be created! Check if was created correctly! (Either original caller or the current consequence caller failed)");
								}
							}
							else
							{
								LoggingHelper.ErrorLog("Provided original caller for consequence caller does not exist! Check that you have the correct amount of callers!");
							}
						}
					}
				}
				if (__instance.callers.Length < 2)
				{
					LoggingHelper.ErrorLog("Amount of callers is less than 2. It is highly recommended to have at least 2 to avoid any soft locks by the game.");
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(CallerController), "IsLastCallOfDay")]
		public static class LastCallOfDayPatch
		{
			private static readonly FieldInfo LastDayNumField = typeof(CallerController).GetField("lastDayNum", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(CallerController __instance, ref bool __result)
			{
				if (LastDayNumField == null)
				{
					LoggingHelper.ReflectionError("LastDayNumField");
					return true;
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					bool flag = ((GlobalVariables.currentDay >= (int)LastDayNumField.GetValue(__instance)) ? (__instance.callers[__instance.currentCallerID + 1] == __instance.callers[__instance.callers.Length - 1]) : __instance.callers[__instance.currentCallerID + 1].callerProfile.increaseTier);
					__result = flag;
				}
				else
				{
					CustomCCaller customCCallerFound = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(__instance.currentCallerID);
					if (customCCallerFound == null)
					{
						LoggingHelper.ErrorLog("Was unable of finding the current caller." + $" Calling original. For ID: {__instance.currentCallerID}");
						foreach (CustomCCaller item in CustomCampaignGlobal.GetActiveCustomCampaign().CustomCallersInCampaign)
						{
							LoggingHelper.InfoLog($"{item.CallerName} : {item.OrderInCampaign}");
						}
						return true;
					}
					__result = customCCallerFound.LastDayCaller;
					LoggingHelper.DebugLog(() => $"Last caller of day: '{customCCallerFound.LastDayCaller}'. " + "Caller name: '" + customCCallerFound.CallerName + "'.");
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(EntryUnlockController), "IncreaseTier")]
		public static class IncreaseTierPatch
		{
			private static readonly FieldInfo OnIncreasedTierEvent = typeof(EntryUnlockController).GetField("OnIncreasedTierEvent", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(EntryUnlockController __instance)
			{
				LoggingHelper.DebugLog("Running increase tier!");
				__instance.currentTier++;
				if (OnIncreasedTierEvent == null)
				{
					LoggingHelper.ReflectionError("OnIncreasedTierEvent");
				}
				else
				{
					Delegate obj = (Delegate)OnIncreasedTierEvent.GetValue(__instance);
					if ((object)obj != null)
					{
						obj.DynamicInvoke();
					}
					else
					{
						LoggingHelper.DebugLog("No subscribers for OnIncreasedTierEvent.");
					}
				}
				if (GlobalVariables.currentDay >= 7 && !CustomCampaignGlobal.InCustomCampaign)
				{
					return false;
				}
				GlobalVariables.mainCanvasScript.CreateError("PERMISSIONS HAVE BEEN UPDATED. NEW ENTRIES NOW AVAILABLE.");
				return false;
			}
		}

		[HarmonyPatch(typeof(CallerController), "AnswerCaller")]
		public static class AnswerCallerPatch
		{
			private static readonly FieldInfo GivenWarning = typeof(CallerController).GetField("givenWarning", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly FieldInfo FirstCaller = typeof(CallerController).GetField("firstCaller", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo AnswerDynamicCall = typeof(CallerController).GetMethod("AnswerDynamicCall", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly FieldInfo DelayedLargeWindowDisplayRoutine = typeof(CallerController).GetField("delayedLargeWindowDisplayRoutine", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo WaitTillCallEndRoutine = typeof(CallerController).GetMethod("WaitTillCallEndRoutine", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(CallerController __instance)
			{
				//IL_072d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0737: Expected O, but got Unknown
				//IL_079d: Unknown result type (might be due to invalid IL or missing references)
				//IL_07a7: Expected O, but got Unknown
				LoggingHelper.DebugLog("Called 'AnswerCaller' method.");
				if (GivenWarning == null || AnswerDynamicCall == null || FirstCaller == null)
				{
					LoggingHelper.ReflectionError("GivenWarning", "AnswerDynamicCall", "FirstCaller");
					return true;
				}
				bool flag = false;
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					if (GlobalVariables.isXmasDLC && (double)GlobalVariables.cheerMeterScript.scoreDisplay * 100.0 <= (double)__instance.xmasGameOverThreshold && GlobalVariables.saveManagerScript.savedImmunityToggle == 0)
					{
						__instance.TriggerGameOver();
					}
					else if (!GlobalVariables.arcadeMode && __instance.IsLastCallOfDay() && !GlobalVariables.isXmasDLC && !__instance.ScoreIsPassing(__instance.gameOverThreshold) && GlobalVariables.currentDay > 1 && GlobalVariables.saveManagerScript.savedImmunityToggle == 0)
					{
						__instance.TriggerGameOver();
					}
					else if (GlobalVariables.currentDay == 1 && __instance.callersToday == 3 && !__instance.ScoreIsPassing(__instance.warningThreshold) && !(bool)GivenWarning.GetValue(__instance))
					{
						AnswerDynamicCall.Invoke(__instance, new object[1] { __instance.warningCall });
						GivenWarning.SetValue(__instance, true);
					}
					else if (GlobalVariables.currentDay == 2 && __instance.callersToday == 2 && !__instance.ScoreIsPassing(__instance.warningThreshold) && !(bool)GivenWarning.GetValue(__instance))
					{
						AnswerDynamicCall.Invoke(__instance, new object[1] { __instance.warningCall });
						GivenWarning.SetValue(__instance, true);
					}
					else if (GlobalVariables.currentDay == 3 && __instance.callersToday == 3 && !__instance.ScoreIsPassing(__instance.warningThreshold) && !(bool)GivenWarning.GetValue(__instance))
					{
						AnswerDynamicCall.Invoke(__instance, new object[1] { __instance.warningCall });
						GivenWarning.SetValue(__instance, true);
					}
					else if (GlobalVariables.currentDay == 4 && __instance.callersToday == 4 && !__instance.ScoreIsPassing(__instance.warningThreshold) && !(bool)GivenWarning.GetValue(__instance))
					{
						AnswerDynamicCall.Invoke(__instance, new object[1] { __instance.warningCall });
						GivenWarning.SetValue(__instance, true);
					}
					else if (GlobalVariables.currentDay == 5 && __instance.callersToday == 5 && !__instance.ScoreIsPassing(__instance.warningThreshold) && !(bool)GivenWarning.GetValue(__instance))
					{
						AnswerDynamicCall.Invoke(__instance, new object[1] { __instance.warningCall });
						GivenWarning.SetValue(__instance, true);
					}
					else if (GlobalVariables.currentDay == 6 && __instance.callersToday == 7 && !__instance.ScoreIsPassing(__instance.warningThreshold) && !(bool)GivenWarning.GetValue(__instance))
					{
						AnswerDynamicCall.Invoke(__instance, new object[1] { __instance.warningCall });
						GivenWarning.SetValue(__instance, true);
					}
					else
					{
						flag = true;
					}
				}
				else
				{
					LoggingHelper.DebugLog("Answering caller in custom campaign.");
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						return true;
					}
					int[] array = new int[6] { 3, 2, 3, 4, 5, 7 };
					if (!GlobalVariables.arcadeMode && __instance.IsLastCallOfDay() && !GlobalVariables.isXmasDLC && !__instance.ScoreIsPassing((float)activeCustomCampaign.GameOverThreshold) && GlobalVariables.currentDay > 1 && GlobalVariables.saveManagerScript.savedImmunityToggle == 0 && !activeCustomCampaign.GameOverImmunity)
					{
						__instance.TriggerGameOver();
					}
					else if (!__instance.ScoreIsPassing((float)activeCustomCampaign.WarningThreshold) && !(bool)GivenWarning.GetValue(__instance))
					{
						LoggingHelper.DebugLog("(Warning) Caller checks started.");
						int num = ((GlobalVariables.currentDay <= activeCustomCampaign.WarningCallThresholdCallerAmounts.Count) ? activeCustomCampaign.WarningCallThresholdCallerAmounts[GlobalVariables.currentDay - 1] : ((GlobalVariables.currentDay > array.Length) ? 7 : array[GlobalVariables.currentDay - 1]));
						LoggingHelper.DebugLog("Warning caller check for callers today required:" + $" {num}." + $" Current amount of callers: {__instance.callersToday}.");
						if (__instance.callersToday == num)
						{
							CustomCCaller customCCaller = null;
							if (activeCustomCampaign.CustomWarningCallersInCampaign.Count > 0)
							{
								if (activeCustomCampaign.CustomWarningCallersInCampaign.Exists((CustomCCaller warningCaller) => warningCaller.WarningCallDay <= -1))
								{
									List<CustomCCaller> list = activeCustomCampaign.CustomWarningCallersInCampaign.FindAll((CustomCCaller warningCaller) => warningCaller.WarningCallDay <= -1);
									if (list.Count > 0)
									{
										customCCaller = list[Random.Range(0, list.Count)];
									}
								}
								List<CustomCCaller> list2 = activeCustomCampaign.CustomWarningCallersInCampaign.FindAll((CustomCCaller warningCaller) => warningCaller.WarningCallDay == GlobalVariables.currentDay);
								if (list2.Count > 0)
								{
									customCCaller = list2[Random.Range(0, list2.Count)];
								}
							}
							if (customCCaller != null)
							{
								LoggingHelper.DebugLog("Warning caller found to replace! " + customCCaller.CallerName + ".");
								CallerProfile val = ScriptableObject.CreateInstance<CallerProfile>();
								val.callerName = customCCaller.CallerName;
								val.callTranscription = customCCaller.CallTranscript;
								if (GetRandomPicMethod == null || GetRandomClip == null)
								{
									LoggingHelper.ReflectionError("GetRandomPicMethod", "GetRandomClip");
									return true;
								}
								if ((Object)(object)customCCaller.CallerImage != (Object)null)
								{
									val.callerPortrait = customCCaller.CallerImage;
								}
								else
								{
									LoggingHelper.WarningLog("Warning-Caller has no caller image, using random image.");
									val.callerPortrait = (Sprite)GetRandomPicMethod.Invoke(__instance, null);
								}
								if ((Object)(object)customCCaller.CallerClip != (Object)null)
								{
									val.callerClip = customCCaller.CallerClip;
								}
								else
								{
									if (AudioImport.CurrentLoadingAudios.Count > 0)
									{
										LoggingHelper.WarningLog("Warning-Caller audio is still loading! Using fallback for now. If this happens often, please check if the audio is too large!");
									}
									else
									{
										LoggingHelper.WarningLog("Warning-Caller has no audio! Using audio fallback. If you provided an audio but this error shows up, check for any errors before!");
									}
									val.callerClip = (RichAudioClip)GetRandomClip.Invoke(__instance, null);
								}
								if (!string.IsNullOrEmpty(customCCaller.EntryNameAttached) || customCCaller.EntryIDAttached != -1)
								{
									LoggingHelper.WarningLog("An entry (monster) was provided for the warning caller, but warning callers do not use any entries! Will default to none.");
								}
								val.callerMonster = null;
								if (customCCaller.CallerIncreasesTier)
								{
									LoggingHelper.WarningLog("Increase tier was provided for a warning caller! It will be set to false!");
								}
								val.increaseTier = false;
								if (customCCaller.ConsequenceCallerID != -1)
								{
									LoggingHelper.WarningLog("Warning callers cannot be consequence caller, ignoring option.");
								}
								val.consequenceCallerProfile = null;
								__instance.warningCall = val;
							}
							AnswerDynamicCall.Invoke(__instance, new object[1] { __instance.warningCall });
							GivenWarning.SetValue(__instance, true);
						}
						else
						{
							flag = true;
						}
					}
					else
					{
						flag = true;
					}
				}
				if (flag)
				{
					if (!(bool)FirstCaller.GetValue(__instance) && !__instance.arcadeMode)
					{
						__instance.currentCallerID++;
					}
					if ((bool)FirstCaller.GetValue(__instance))
					{
						FirstCaller.SetValue(__instance, false);
					}
					__instance.UpdateCallerInfo((CallerProfile)null);
					if (!GlobalVariables.arcadeMode && (Object)(object)__instance.callers[__instance.currentCallerID].callerProfile.consequenceCallerProfile != (Object)null && !__instance.CanReceiveConsequenceCall(__instance.callers[__instance.currentCallerID].callerProfile.consequenceCallerProfile))
					{
						LoggingHelper.DebugLog("Caller is dynamic caller. " + $"Marking as correct. (Last Caller? {__instance.IsLastCallOfDay()}) " + "Next caller!");
						__instance.callers[__instance.currentCallerID].answeredCorrectly = true;
						if (__instance.IsLastCallOfDay())
						{
							LoggingHelper.DebugLog("Calling end day routine from answer caller.");
							((MonoBehaviour)GlobalVariables.mainCanvasScript).StartCoroutine(GlobalVariables.mainCanvasScript.EndDayRoutine());
							GlobalVariables.mainCanvasScript.NoCallerWindow();
							return false;
						}
						__instance.AnswerCaller();
					}
					else
					{
						if (CustomCampaignGlobal.InCustomCampaign && CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(__instance.currentCallerID) != null)
						{
							CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(__instance.currentCallerID);
							if (customCallerFromActiveCampaign != null && customCallerFromActiveCampaign.IsAccuracyCaller)
							{
								bool flag2 = AccuracyCallerHelper.CheckIfCallerIsToBeShown(customCallerFromActiveCampaign);
								LoggingHelper.DebugLog($"Should the accuracy caller be shown? '{flag2}'.");
								if (!flag2)
								{
									__instance.callers[__instance.currentCallerID].answeredCorrectly = true;
									if (__instance.IsLastCallOfDay())
									{
										LoggingHelper.DebugLog("Calling end day routine from answer caller (accuracy caller).");
										((MonoBehaviour)GlobalVariables.mainCanvasScript).StartCoroutine(GlobalVariables.mainCanvasScript.EndDayRoutine());
										GlobalVariables.mainCanvasScript.NoCallerWindow();
										return false;
									}
									__instance.AnswerCaller();
									return false;
								}
							}
						}
						if (GlobalVariables.UISoundControllerScript.myMonsterSampleAudioSource.isPlaying)
						{
							GlobalVariables.UISoundControllerScript.myMonsterSampleAudioSource.Stop();
						}
						if (GlobalVariables.mainCanvasScript.callWindow.activeSelf)
						{
							__instance.PlayCallAudio((CallerProfile)null);
						}
						if (DelayedLargeWindowDisplayRoutine == null || WaitTillCallEndRoutine == null)
						{
							LoggingHelper.ReflectionError("DelayedLargeWindowDisplayRoutine", "WaitTillCallEndRoutine");
							return true;
						}
						DelayedLargeWindowDisplayRoutine.SetValue(__instance, ((MonoBehaviour)__instance).StartCoroutine((IEnumerator)WaitTillCallEndRoutine.Invoke(__instance, new object[1] { __instance.callers[__instance.currentCallerID].callerProfile.callerClip.clip.length })));
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(CallerController), "NewCallRoutine", new Type[]
		{
			typeof(float),
			typeof(float)
		})]
		public static class NewCallRoutinePatch
		{
			private static bool Prefix(CallerController __instance, ref IEnumerator __result, ref float minTime, ref float maxTime)
			{
				__result = NewCallRoutine(minTime, maxTime);
				return false;
			}

			private static IEnumerator NewCallRoutine(float minTime, float maxTime)
			{
				float waitTimeBetweenCallers = Random.Range(minTime, maxTime);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						yield break;
					}
					if (customCampaign.EnableCustomWaitBetweenCallers)
					{
						float? waitTimeBetweenCallersCustomCampaign = RandomFromList.GetRandomFromList(customCampaign.WaitBetweenCallers);
						if (waitTimeBetweenCallersCustomCampaign.HasValue)
						{
							waitTimeBetweenCallers = waitTimeBetweenCallersCustomCampaign.Value;
						}
					}
					LoggingHelper.DebugLog($"Wait time has been chosen as: '{waitTimeBetweenCallers}'.");
				}
				yield return (object)new WaitForSeconds(waitTimeBetweenCallers);
				if ((Object)(object)GlobalVariables.mainCanvasScript != (Object)null && (Object)(object)GlobalVariables.mainCanvasScript.callWindow != (Object)null)
				{
					GlobalVariables.mainCanvasScript.callWindow.SetActive(true);
				}
			}
		}

		private static readonly MethodInfo GetRandomPicMethod = typeof(CallerController).GetMethod("PickRandomPic", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly MethodInfo GetRandomClip = typeof(CallerController).GetMethod("PickRandomClip", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo LastDayNum = typeof(CallerController).GetField("lastDayNum", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo CallerAudioSource = typeof(CallerController).GetField("callerAudioSource", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
	}
}
namespace NewSafetyHelp.Callers.UI
{
	public static class MainCanvasPatches
	{
		[HarmonyPatch(typeof(MainCanvasBehavior), "WriteDayString")]
		public static class WriteDayStringPatch
		{
			private static bool Prefix(MainCanvasBehavior __instance, ref string __result)
			{
				if (!GlobalVariables.isXmasDLC && !CustomCampaignGlobal.InCustomCampaign)
				{
					if (GlobalVariables.arcadeMode)
					{
						__result = "Arcade Mode";
					}
					__result = DefaultDayNames[GlobalVariables.currentDay - 1];
				}
				else if (GlobalVariables.isXmasDLC && !CustomCampaignGlobal.InCustomCampaign)
				{
					switch (GlobalVariables.currentDay)
					{
					case 1:
						__result = "3 Days Until Christmas";
						break;
					case 2:
						__result = "2 Days Until Christmas";
						break;
					case 3:
						__result = "1 Day Until Christmas";
						break;
					case 4:
						__result = "Christmas Day";
						break;
					}
				}
				else if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign != null)
					{
						string text;
						if (activeCustomCampaign.CampaignDayStrings.Count > 0)
						{
							if (GlobalVariables.currentDay > activeCustomCampaign.CampaignDayStrings.Count || activeCustomCampaign.CampaignDays > activeCustomCampaign.CampaignDayStrings.Count)
							{
								LoggingHelper.WarningLog("Amount of day strings does not correspond with the max amount of days for the custom campaign. Using default values.");
								text = DefaultDayNames[(GlobalVariables.currentDay - 1) % DefaultDayNames.Count];
							}
							else
							{
								text = activeCustomCampaign.CampaignDayStrings[(GlobalVariables.currentDay - 1) % activeCustomCampaign.CampaignDayStrings.Count];
							}
						}
						else
						{
							text = DefaultDayNames[(GlobalVariables.currentDay - 1) % DefaultDayNames.Count];
						}
						(bool, List<string>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DayTitleStrings, (List<string> v) => v != null && v.Count > 0);
						(bool, List<int>) activeModifierValue2 = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.UnlockDays, (List<int> v) => v != null && v.Count > 0);
						if (activeModifierValue.Item1)
						{
							if (activeModifierValue2.Item2 != null && activeModifierValue.Item2.Count != activeModifierValue2.Item2.Count && string.IsNullOrEmpty(text))
							{
								LoggingHelper.WarningLog("Amount of day strings does not correspond with the max amount of days for the custom campaign. Using default values.");
								text = DefaultDayNames[(GlobalVariables.currentDay - 1) % DefaultDayNames.Count];
							}
							else if (activeModifierValue2.Item2 == null)
							{
								if (activeCustomCampaign.CampaignDays > activeModifierValue.Item2.Count)
								{
									LoggingHelper.WarningLog("Amount of day strings does not correspond with the max amount of days for the custom campaign. Using modulated values.");
								}
								text = activeModifierValue.Item2[(GlobalVariables.currentDay - 1) % activeModifierValue.Item2.Count];
							}
							else if (activeModifierValue.Item2.Count != activeModifierValue2.Item2.Count)
							{
								LoggingHelper.WarningLog("Amount of day strings does not correspond with the max amount of days for the custom campaign. Using modulated values.");
								text = activeModifierValue.Item2[(GlobalVariables.currentDay - 1) % activeModifierValue.Item2.Count];
							}
							else
							{
								int num = activeModifierValue2.Item2.IndexOf(GlobalVariables.currentDay);
								if (num != -1)
								{
									text = activeModifierValue.Item2[num];
								}
							}
						}
						if (string.IsNullOrEmpty(text))
						{
							text = DefaultDayNames[(GlobalVariables.currentDay - 1) % DefaultDayNames.Count];
						}
						if (!string.IsNullOrEmpty(text))
						{
							__result = text;
						}
					}
					else
					{
						LoggingHelper.WarningLog("Was unable of finding the current campaign. Defaulting to default values.");
						__result = DefaultDayNames[GlobalVariables.currentDay - 1];
					}
				}
				else
				{
					__result = "Default";
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(MainCanvasBehavior), "StartSoftwareRoutine")]
		public static class SoftwareRoutinePatches
		{
			private static readonly MethodInfo LoadVarsMethod = typeof(MainCanvasBehavior).GetMethod("LoadVars", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo PopulateEntriesListMethod = typeof(MainCanvasBehavior).GetMethod("PopulateEntriesList", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo WriteDayStringMethod = typeof(MainCanvasBehavior).GetMethod("WriteDayString", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(MainCanvasBehavior __instance, ref IEnumerator __result)
			{
				EndDayRoutinePatch.IsDayEnding = false;
				__result = StartSoftwareRoutine(__instance);
				return false;
			}

			private static IEnumerator StartSoftwareRoutine(MainCanvasBehavior __instance)
			{
				if (LoadVarsMethod == null || PopulateEntriesListMethod == null || WriteDayStringMethod == null)
				{
					LoggingHelper.ReflectionError("LoadVarsMethod", "PopulateEntriesListMethod", "WriteDayStringMethod");
					yield break;
				}
				yield return null;
				LoadVarsMethod.Invoke(__instance, null);
				PopulateEntriesListMethod.Invoke(__instance, null);
				if (!GlobalVariables.arcadeMode && GlobalVariables.currentDay == 7 && !CustomCampaignGlobal.InCustomCampaign)
				{
					__instance.trialScreen.SetActive(true);
					__instance.postProcessVolume.profile = __instance.scaryProcessProfile;
				}
				else if (!CustomCampaignGlobal.InCustomCampaign)
				{
				}
				if (GlobalVariables.isXmasDLC && Object.op_Implicit((Object)(object)GlobalVariables.cheerMeterScript))
				{
					GlobalVariables.cheerMeterScript.UpdateMeterVisuals();
				}
				GlobalVariables.introIsPlaying = true;
				__instance.clockedIn = false;
				GlobalVariables.callerControllerScript.callersToday = 0;
				GlobalVariables.callerControllerScript.correctCallsToday = 0;
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					AccuracyCallerHelper.StartOfDayCallerID = GlobalVariables.callerControllerScript.currentCallerID;
					CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign == null)
					{
						LoggingHelper.CampaignNullError();
						yield break;
					}
					(bool foundModifier, VariableChanged<Sprite> value) inGameProgramIconVC = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.InGameProgramIcon, (VariableChanged<Sprite> vCs) => vCs.HasChanged);
					(bool foundModifier, VariableChanged<bool> value) inGameProgramIconCenter = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.InGameProgramIconCenter, (VariableChanged<bool> vCs) => vCs.HasChanged);
					GameObject inGameProgramIcon = GameObject.Find("MainCanvas/Panel/WindowsBar/ProgramLogo");
					if ((Object)(object)inGameProgramIcon == (Object)null)
					{
						LoggingHelper.ErrorLog("Could not find Program Logo to change.");
						yield break;
					}
					if (inGameProgramIconVC.foundModifier)
					{
						inGameProgramIcon.GetComponent<Image>().sprite = inGameProgramIconVC.value.Data;
					}
					if (inGameProgramIconCenter.foundModifier && inGameProgramIconCenter.value.Data)
					{
						inGameProgramIcon.GetComponent<RectTransform>().pivot = new Vector2(0.75f, 0.75f);
					}
					(bool foundModifier, VariableChanged<Sprite> value) inGamePhoneIcon = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.InGamePhoneIcon, (VariableChanged<Sprite> vCs) => vCs.HasChanged);
					(bool foundModifier, VariableChanged<bool> value) inGamePhoneIconCenter = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.InGamePhoneIconCenter, (VariableChanged<bool> vCs) => vCs.HasChanged);
					GameObject mainCanvas = GameObject.Find("MainCanvas");
					if (inGamePhoneIconCenter.foundModifier)
					{
						((Component)mainCanvas.transform.GetChild(3).GetChild(0).GetChild(2)).GetComponent<RectTransform>().pivot = new Vector2(0.75f, 0.75f);
					}
					if (inGamePhoneIcon.foundModifier)
					{
						((Component)mainCanvas.transform.GetChild(3).GetChild(0).GetChild(2)).GetComponent<Image>().sprite = inGamePhoneIcon.value.Data;
						((Component)mainCanvas.transform.GetChild(3).GetChild(1).GetChild(0)).GetComponent<Image>().sprite = inGamePhoneIcon.value.Data;
					}
					(bool foundModifier, VariableChanged<string> value) incomingCallTitle = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.IncomingCallTitle, (VariableChanged<string> vCs) => vCs.HasChanged);
					if (incomingCallTitle.foundModifier)
					{
						((TMP_Text)((Component)GameObject.Find("MainCanvas").transform.GetChild(3).GetChild(0).GetChild(3)).GetComponent<TextMeshProUGUI>()).text = incomingCallTitle.value.Data;
					}
					(bool foundModifier, VariableChanged<string> value) incomingCallLabel = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.IncomingCallLabel, (VariableChanged<string> vCs) => vCs.HasChanged);
					if (incomingCallLabel.foundModifier)
					{
						((TMP_Text)((Component)GameObject.Find("MainCanvas").transform.GetChild(3).GetChild(1).GetChild(1)).GetComponent<TextMeshProUGUI>()).text = incomingCallLabel.value.Data;
					}
					(bool foundModifier, VariableChanged<string> value) incomingCallAnswerButtonText = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.IncomingCallAnswerButtonText, (VariableChanged<string> vCs) => vCs.HasChanged);
					if (incomingCallAnswerButtonText.foundModifier)
					{
						((TMP_Text)((Component)GameObject.Find("MainCanvas").transform.GetChild(3).GetChild(1).GetChild(2)
							.GetChild(0)).GetComponent<TextMeshProUGUI>()).text = incomingCallAnswerButtonText.value.Data;
					}
					(bool foundModifier, VariableChanged<Sprite> value) incomingCallAnswerButtonImage = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.IncomingCallAnswerButtonImage, (VariableChanged<Sprite> vCs) => vCs.HasChanged);
					if (incomingCallAnswerButtonImage.foundModifier)
					{
						((Component)GameObject.Find("MainCanvas").transform.GetChild(3).GetChild(1).GetChild(2)
							.GetChild(1)).GetComponent<Image>().sprite = incomingCallAnswerButtonImage.value.Data;
					}
					(bool foundModifier, VariableChanged<RichAudioClip> value) inGameLogoFadeInAudio = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.InGameLogoFadeInAudio, (VariableChanged<RichAudioClip> vCs) => vCs.HasChanged);
					if (inGameLogoFadeInAudio.foundModifier)
					{
						AudioSource logoAudioSource = ((Component)GameObject.Find("MainCanvas").transform.GetChild(0).GetChild(12).GetChild(1)).GetComponent<AudioSource>();
						logoAudioSource.clip = inGameLogoFadeInAudio.value.Data.clip;
						logoAudioSource.volume = inGameLogoFadeInAudio.value.Data.volume;
					}
					(bool foundModifier, VariableChanged<string> value) submitWindowTitle = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.SubmitWindowTitle, (VariableChanged<string> vCs) => vCs.HasChanged);
					if (submitWindowTitle.foundModifier)
					{
						((TMP_Text)((Component)GameObject.Find("MainCanvas").transform.GetChild(2).GetChild(0).GetChild(3)).GetComponent<TextMeshProUGUI>()).text = submitWindowTitle.value.Data;
					}
					(bool foundModifier, VariableChanged<string> value) submitWindowText = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.SubmitWindowText, (VariableChanged<string> vCs) => vCs.HasChanged);
					if (submitWindowText.foundModifier)
					{
						((TMP_Text)((Component)GameObject.Find("MainCanvas").transform.GetChild(2).GetChild(1)).GetComponent<TextMeshProUGUI>()).text = submitWindowText.value.Data;
					}
					(bool foundModifier, VariableChanged<Sprite> value) submitWindowIcon = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.SubmitWindowIcon, (VariableChanged<Sprite> vCs) => vCs.HasChanged);
					if (submitWindowIcon.foundModifier)
					{
						((Component)GameObject.Find("MainCanvas").transform.GetChild(2).GetChild(0).GetChild(2)).GetComponent<Image>().sprite = submitWindowIcon.value.Data;
					}
					if (CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.ClockInLogoAnimation, (VariableChanged<List<Sprite>> vCs) => vCs.HasChanged).foundModifier)
					{
						GameObject logoAnimationGO = GameObject.Find("MainCanvas/Panel/SoftwareIntroPanel/LogoAnimation");
						((Behaviour)logoAnimationGO.GetComponent<Animator>()).enabled = false;
					}
					(bool foundModifier, VariableChanged<List<Sprite>> value) clockInAnimation = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.ClockInAnimation, (VariableChanged<List<Sprite>> vCs) => vCs.HasChanged);
					(bool foundModifier, VariableChanged<float> value) clockInAnimationDuration = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.ClockInAnimationDuration, (VariableChanged<float> vCs) => vCs.HasChanged);
					(bool foundModifier, VariableChanged<float> value) clockInAnimationScale = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.ClockInAnimationScale, (VariableChanged<float> vCs) => vCs.HasChanged);
					if (clockInAnimation.foundModifier)
					{
						GameObject clockInAnimationGO = ((Component)GameObject.Find("MainCanvas/Panel").transform.GetChild(12).GetChild(0)).gameObject;
						((Behaviour)clockInAnimationGO.GetComponent<Animator>()).enabled = false;
						float animationDuration = 2.25f;
						if (clockInAnimationDuration.foundModifier)
						{
							animationDuration = clockInAnimationDuration.value.Data;
						}
						Image clockInAnimationImage = clockInAnimationGO.GetComponent<Image>();
						clockInAnimationImage.preserveAspect = true;
						((MonoBehaviour)__instance).StartCoroutine(CustomClockInAnimation(clockInAnimationImage, clockInAnimation.value.Data, animationDuration));
					}
					if (clockInAnimationScale.foundModifier)
					{
						GameObject clockInAnimationGO2 = ((Component)GameObject.Find("MainCanvas/Panel").transform.GetChild(12).GetChild(0)).gameObject;
						RectTransform clockInAnimationRectTransform = clockInAnimationGO2.GetComponent<RectTransform>();
						clockInAnimationRectTransform.sizeDelta *= clockInAnimationScale.value.Data;
					}
				}
				if (!GlobalVariables.arcadeMode)
				{
					GlobalVariables.fade.FadeIn(1f, (string)WriteDayStringMethod.Invoke(__instance, null));
				}
				else
				{
					GlobalVariables.fade.FadeIn(1f, (string)null);
					__instance.arcadeStartPanel.SetActive(true);
					GlobalVariables.fade.FadeOut(1f);
				}
				if (GlobalPreferences.SkipDayClockIn.Value)
				{
					GlobalVariables.fade.FadeIn(1f, (string)null);
					__instance.clockInPanel.SetActive(false);
					__instance.clockOutElements.SetActive(false);
					__instance.clockInElements.SetActive(false);
					__instance.clockInButton.SetActive(false);
					GlobalVariables.fade.FadeOut(1f);
				}
				if (!GlobalVariables.arcadeMode)
				{
					if (!GlobalPreferences.SkipDayClockIn.Value)
					{
						yield return (object)new WaitForSeconds(6f);
						__instance.softwareStartupPanel.SetActive(true);
						__instance.clockInPanel.SetActive(false);
						__instance.logoPanel.SetActive(false);
						GlobalVariables.fade.FadeOut(1f);
						yield return (object)new WaitForSeconds(1f);
						__instance.logoPanel.SetActive(true);
						((MonoBehaviour)__instance).StartCoroutine(GlobalVariables.UISoundControllerScript.FadeInLoopingSound(GlobalVariables.UISoundControllerScript.computerFanSpin, GlobalVariables.UISoundControllerScript.myFanSpinLoopingSource, 0.5f));
						if (CustomCampaignGlobal.InCustomCampaign)
						{
							(bool foundModifier, VariableChanged<List<Sprite>> value) clockInLogoAnimation = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.ClockInLogoAnimation, (VariableChanged<List<Sprite>> vCs) => vCs.HasChanged);
							(bool foundModifier, VariableChanged<float> value) clockInLogoAnimationScale = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.ClockInLogoAnimationScale, (VariableChanged<float> vCs) => vCs.HasChanged);
							(bool foundModifier, VariableChanged<float> value) clockInLogoAnimationFadeDuration = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.ClockInLogoAnimationFadeDuration, (VariableChanged<float> vCs) => vCs.HasChanged);
							(bool foundModifier, VariableChanged<float> value) clockInLogoAnimationHoldDuration = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.ClockInLogoAnimationHoldDuration, (VariableChanged<float> vCs) => vCs.HasChanged);
							float totalFadeInOutDuration = 1.82f;
							float totalHoldFrameDuration = 1.42f;
							GameObject logoAnimationGameObject = GameObject.Find("MainCanvas/Panel/SoftwareIntroPanel/LogoAnimation");
							Image logoAnimationImageComponent = logoAnimationGameObject.GetComponent<Image>();
							if (clockInLogoAnimationFadeDuration.foundModifier)
							{
								totalFadeInOutDuration = clockInLogoAnimationFadeDuration.value.Data;
							}
							if (clockInLogoAnimationHoldDuration.foundModifier)
							{
								totalHoldFrameDuration = clockInLogoAnimationHoldDuration.value.Data;
							}
							if (clockInLogoAnimationScale.foundModifier)
							{
								((Transform)logoAnimationGameObject.GetComponent<RectTransform>()).localScale = new Vector3(clockInLogoAnimationScale.value.Data, clockInLogoAnimationScale.value.Data, clockInLogoAnimationScale.value.Data);
							}
							if (clockInLogoAnimation.foundModifier)
							{
								int frameAmount = clockInLogoAnimation.value.Data.Count;
								if (frameAmount > 0)
								{
									float frameDuration = totalFadeInOutDuration / (float)frameAmount;
									logoAnimationImageComponent.sprite = clockInLogoAnimation.value.Data[0];
									for (int i = 0; i < frameAmount; i++)
									{
										logoAnimationImageComponent.sprite = clockInLogoAnimation.value.Data[i];
										yield return (object)new WaitForSeconds(frameDuration);
									}
									yield return (object)new WaitForSeconds(totalHoldFrameDuration);
									for (int i2 = frameAmount - 1; i2 >= 0; i2--)
									{
										logoAnimationImageComponent.sprite = clockInLogoAnimation.value.Data[i2];
										yield return (object)new WaitForSeconds(frameDuration);
									}
								}
							}
							else
							{
								yield return (object)new WaitForSeconds(6f);
							}
						}
						else
						{
							yield return (object)new WaitForSeconds(6f);
						}
						if (CustomCampaignGlobal.InCustomCampaign)
						{
							(bool foundModifier, VariableChanged<RichAudioClip> value) clockDayStartedAudio = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.ClockDayStartedAudio, (VariableChanged<RichAudioClip> vCs) => vCs.HasChanged);
							if (clockDayStartedAudio.foundModifier)
							{
								GlobalVariables.UISoundControllerScript.PlayUISound(clockDayStartedAudio.value.Data, (AudioSource)null);
							}
							else
							{
								GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.correctSound, (AudioSource)null);
							}
						}
						else
						{
							GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.correctSound, (AudioSource)null);
						}
						if (GlobalVariables.currentDay == 7 && !CustomCampaignGlobal.InCustomCampaign)
						{
							__instance.cameraAnimator.SetTrigger(Glitch);
							GlobalVariables.fade.FadeIn(0.5f, (string)null);
							yield return (object)new WaitForSeconds(0.2f);
							GlobalVariables.fade.FadeOut(0.5f);
						}
						else if (!CustomCampaignGlobal.InCustomCampaign)
						{
						}
						__instance.logoPanel.SetActive(false);
						__instance.clockInPanel.SetActive(true);
						__instance.clockOutElements.SetActive(false);
						__instance.clockInElements.SetActive(true);
						__instance.clockInButton.SetActive(true);
						while (!__instance.clockedIn)
						{
							yield return null;
						}
						yield return (object)new WaitForSeconds(5f);
					}
				}
				else
				{
					while (!__instance.startArcadeMode)
					{
						yield return null;
					}
				}
				__instance.softwareStartupPanel.SetActive(false);
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					(bool foundModifier, VariableChanged<RichAudioClip> value) dayStartedAudio = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DayStartedAudio, (VariableChanged<RichAudioClip> vCs) => vCs.HasChanged);
					if (dayStartedAudio.foundModifier)
					{
						GlobalVariables.UISoundControllerScript.PlayUISound(dayStartedAudio.value.Data, (AudioSource)null);
					}
					else
					{
						GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.correctSound, (AudioSource)null);
					}
				}
				else
				{
					GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.correctSound, (AudioSource)null);
				}
				if (!GlobalVariables.arcadeMode && GlobalVariables.currentDay == 7 && !CustomCampaignGlobal.InCustomCampaign)
				{
					yield return (object)new WaitForSeconds(0.4f);
					__instance.cameraAnimator.SetTrigger(Glitch);
					GlobalVariables.fade.FadeIn(0.5f, (string)null);
					yield return (object)new WaitForSeconds(0.2f);
					GlobalVariables.fade.FadeOut(0.5f);
					GlobalVariables.musicControllerScript.StartTrialMusic();
				}
				else if (!CustomCampaignGlobal.InCustomCampaign)
				{
				}
				if (GlobalVariables.arcadeMode)
				{
					__instance.callTimer.SetActive(true);
					yield return (object)new WaitForSeconds(1f);
					GlobalVariables.fade.FadeOut(0.5f);
				}
				if (CustomCampaignGlobal.InCustomCampaign && (CustomCampaignGlobal.GetActiveCustomCampaign()?.AlwaysSkipCallButton ?? false))
				{
					CustomDesktopHelper.GetCallSkipButton().SetActive(true);
				}
				GlobalVariables.callerControllerScript.StartCallRoutine();
				GlobalVariables.introIsPlaying = false;
			}

			private static IEnumerator CustomClockInAnimation(Image clockInAnimationImage, List<Sprite> clockInAnimation, float clockInAnimationDuration)
			{
				if (clockInAnimation.Count <= 0)
				{
					LoggingHelper.WarningLog("Provided clock in animation has no images/frames to show.");
					yield break;
				}
				float frameLength = clockInAnimationDuration / (float)clockInAnimation.Count;
				clockInAnimationImage.sprite = clockInAnimation[0];
				int frameIndex = 0;
				while (true)
				{
					clockInAnimationImage.sprite = clockInAnimation[frameIndex];
					yield return (object)new WaitForSeconds(frameLength);
					frameIndex = ((frameIndex < clockInAnimation.Count - 1) ? (frameIndex + 1) : 0);
				}
			}
		}

		[HarmonyPatch(typeof(MainCanvasBehavior), "EndDayRoutine")]
		public static class EndDayRoutinePatch
		{
			public static bool IsDayEnding;

			private static readonly MethodInfo SaveCallerAnswers = typeof(MainCanvasBehavior).GetMethod("SaveCallerAnswers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo UnlockDailySteamAchievement = typeof(MainCanvasBehavior).GetMethod("UnlockDailySteamAchievement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly FieldInfo ProgressDay = typeof(MainCanvasBehavior).GetField("progressDay", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(MainCanvasBehavior __instance, ref IEnumerator __result)
			{
				LoggingHelper.DebugLog("Calling EndDayRoutine.");
				__result = EndDayRoutineChanged(__instance);
				return false;
			}

			private static IEnumerator EndDayRoutineChanged(MainCanvasBehavior __instance)
			{
				if (IsDayEnding)
				{
					LoggingHelper.DebugLog("Skipping EndDayRoutine.");
					yield break;
				}
				IsDayEnding = true;
				__instance.clockedOut = false;
				IntermissionMusicHelper.StopIntermissionMusicRoutine();
				yield return (object)new WaitForSeconds(5f);
				__instance.inputBlocker.SetActive(false);
				GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.correctSound, (AudioSource)null);
				GlobalVariables.UISoundControllerScript.myMonsterSampleAudioSource.Stop();
				__instance.softwareStartupPanel.SetActive(true);
				__instance.clockInPanel.SetActive(true);
				__instance.logoPanel.SetActive(false);
				__instance.clockOutElements.SetActive(true);
				__instance.clockOutButton.SetActive(true);
				__instance.clockInElements.SetActive(false);
				IsDayEnding = false;
				while (!__instance.clockedOut)
				{
					yield return null;
				}
				yield return (object)new WaitForSeconds(6f);
				if (!GlobalVariables.isXmasDLC)
				{
					if (UnlockDailySteamAchievement == null)
					{
						LoggingHelper.ReflectionError("UnlockDailySteamAchievement");
						yield break;
					}
					if (!CustomCampaignGlobal.InCustomCampaign)
					{
						UnlockDailySteamAchievement.Invoke(__instance, null);
					}
				}
				GlobalVariables.fade.FadeIn(2f, (string)null);
				((MonoBehaviour)__instance).StartCoroutine(GlobalVariables.UISoundControllerScript.FadeOutLoopingSound(GlobalVariables.UISoundControllerScript.myFanSpinLoopingSource, 0.5f));
				yield return (object)new WaitForSeconds(2f);
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					PlayerPrefs.SetFloat("SavedDayScore" + GlobalVariables.currentDay, GlobalVariables.callerControllerScript.GetScore());
				}
				else
				{
					CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign == null)
					{
						yield break;
					}
					float dayScore = GlobalVariables.callerControllerScript.GetScore();
					if (float.IsNaN(dayScore) || float.IsInfinity(dayScore))
					{
						dayScore = 100f;
					}
					customCampaign.SavedDayScores[GlobalVariables.currentDay] = dayScore;
					LoggingHelper.DebugLog($"Saving day score of day '{GlobalVariables.currentDay}'." + $"With the score of '{customCampaign.SavedDayScores[GlobalVariables.currentDay]}'.");
				}
				if (ProgressDay == null)
				{
					LoggingHelper.ReflectionError("ProgressDay");
					yield break;
				}
				if (!(bool)ProgressDay.GetValue(__instance))
				{
					GlobalVariables.currentDay++;
					ProgressDay.SetValue(__instance, true);
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					GlobalVariables.saveManagerScript.savedDay = GlobalVariables.currentDay;
					GlobalVariables.saveManagerScript.savedCurrentCaller = GlobalVariables.callerControllerScript.currentCallerID + 1;
					GlobalVariables.saveManagerScript.savedEntryTier = GlobalVariables.entryUnlockScript.currentTier;
					if (SaveCallerAnswers == null)
					{
						LoggingHelper.ReflectionError("SaveCallerAnswers");
						yield break;
					}
					SaveCallerAnswers.Invoke(__instance, null);
				}
				else
				{
					CustomCampaign customCampaign2 = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign2 == null)
					{
						yield break;
					}
					customCampaign2.CurrentDay = GlobalVariables.currentDay;
					customCampaign2.SavedCurrentCaller = GlobalVariables.callerControllerScript.currentCallerID + 1;
					customCampaign2.CurrentPermissionTier = GlobalVariables.entryUnlockScript.currentTier;
					List<bool> flagArray = new List<bool>();
					int index = 0;
					while (index < GlobalVariables.callerControllerScript.callers.Length)
					{
						flagArray.Add(item: false);
						int num = index + 1;
						index = num;
					}
					int index2 = 0;
					while (index2 < GlobalVariables.callerControllerScript.callers.Length)
					{
						if (GlobalVariables.callerControllerScript.callers[index2] != null)
						{
							flagArray[index2] = GlobalVariables.callerControllerScript.callers[index2].answeredCorrectly;
						}
						int num = index2 + 1;
						index2 = num;
					}
					customCampaign2.SavedCallersCorrectAnswer = flagArray;
					customCampaign2.SavedCallerArrayLength = GlobalVariables.callerControllerScript.callers.Length;
				}
				GlobalVariables.saveManagerScript.SaveGameProgress();
				yield return null;
				LoggingHelper.DebugLog("Ending the EndDayRoutine.");
				__instance.ExitToMenu();
				((MonoBehaviour)__instance).StartCoroutine(__instance.StartSoftwareRoutine());
			}
		}

		[HarmonyPatch(typeof(MainCanvasBehavior), "IsNetworkDown")]
		public static class IsNetworkDownPatch
		{
			private static bool Prefix(MainCanvasBehavior __instance, ref bool __result)
			{
				if (GlobalVariables.arcadeMode)
				{
					if (GlobalVariables.callerControllerScript.downedNetworkCall)
					{
						__result = true;
						return false;
					}
				}
				else if (!CustomCampaignGlobal.InCustomCampaign)
				{
					int[] downedNetworkCalls = GlobalVariables.callerControllerScript.downedNetworkCalls;
					foreach (int num in downedNetworkCalls)
					{
						if (num == GlobalVariables.callerControllerScript.currentCallerID)
						{
							__result = true;
							return false;
						}
					}
				}
				else
				{
					CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(GlobalVariables.callerControllerScript.currentCallerID);
					if (customCallerFromActiveCampaign == null)
					{
						LoggingHelper.ErrorLog("Custom campaign caller was null. Unable of checking for downed network parameter. Calling original function.");
						return true;
					}
					if (customCallerFromActiveCampaign.DownedNetworkCaller)
					{
						__result = true;
						return false;
					}
				}
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(MainCanvasBehavior), "LoadCallerAnswers")]
		public static class LoadCallerAnswersPatch
		{
			private static bool Prefix(MainCanvasBehavior __instance)
			{
				if (GlobalVariables.saveManagerScript.savedCallerCorrectAnswers.Length != GlobalVariables.callerControllerScript.callers.Length)
				{
					return false;
				}
				for (int i = 0; i < GlobalVariables.callerControllerScript.callers.Length; i++)
				{
					if (GlobalVariables.callerControllerScript.callers[i] != null)
					{
						GlobalVariables.callerControllerScript.callers[i].answeredCorrectly = GlobalVariables.saveManagerScript.savedCallerCorrectAnswers[i];
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(MainCanvasBehavior), "ExitToMenu")]
		public static class ExitToMenuPatch
		{
			private static bool Prefix(MainCanvasBehavior __instance)
			{
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					IntermissionMusicHelper.StopIntermissionMusicRoutine();
				}
				GlobalVariables.arcadeMode = false;
				if (!GlobalVariables.isXmasDLC)
				{
					SceneManager.LoadScene("MainMenuScene");
				}
				else
				{
					SceneManager.LoadScene("MainMenuSceneXmas");
				}
				return false;
			}
		}

		private static readonly int Glitch = Animator.StringToHash("glitch");

		private static readonly List<string> DefaultDayNames = new List<string> { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };
	}
	public static class NextCaller
	{
		[HarmonyPatch(typeof(MainCanvasBehavior), "NextCallButton")]
		public static class NextCallButtonPatch
		{
			private static bool Prefix(MainCanvasBehavior __instance)
			{
				if (CustomCampaignGlobal.InCustomCampaign && !GlobalVariables.arcadeMode && CallerSkipping.CheckIfAnyValidCallerLeft(GlobalVariables.callerControllerScript) > 0)
				{
					LoggingHelper.DebugLog("DEBUG: Last caller was the last one. Already ending the day.", LoggingHelper.LoggingCategory.NONE, ConsoleColor.DarkYellow);
					GlobalVariables.mainCanvasScript.CreateError("Day is ending. Please hold.");
					GlobalVariables.mainCanvasScript.NoCallerWindow();
					__instance.inputBlocker.SetActive(false);
					return false;
				}
				if (GlobalVariables.callerControllerScript.IsLastCallOfDay() && !GlobalVariables.arcadeMode)
				{
					GlobalVariables.mainCanvasScript.CreateError("Day is ending. Please hold.");
					GlobalVariables.mainCanvasScript.NoCallerWindow();
				}
				else
				{
					GlobalVariables.callerControllerScript.StopAllRoutines();
					__instance.callWindow.SetActive(true);
				}
				__instance.inputBlocker.SetActive(false);
				return false;
			}
		}
	}
	public static class UIFallbacks
	{
		[HarmonyPatch(typeof(CallerController), "PickRandomClip")]
		public static class PickRandomClipPatch
		{
			private static bool Prefix(CallerController __instance, ref RichAudioClip __result)
			{
				if (__instance.randomCallerClips.Length == 0)
				{
					LoggingHelper.WarningLog("No caller audio available for caller!");
					__result = null;
					return false;
				}
				int num = Random.Range(0, __instance.randomCallerClips.Length);
				__result = __instance.randomCallerClips[num];
				return false;
			}
		}

		[HarmonyPatch(typeof(CallerController), "PickRandomPic")]
		public static class PickRandomPicPatch
		{
			private static bool Prefix(CallerController __instance, ref Sprite __result)
			{
				if (__instance.randomCallerPics.Length == 0)
				{
					LoggingHelper.WarningLog("No image available for caller!");
					__result = null;
					return false;
				}
				int num = Random.Range(0, __instance.randomCallerPics.Length);
				__result = __instance.randomCallerPics[num];
				return false;
			}
		}
	}
}
namespace NewSafetyHelp.Callers.UI.AnimatedEntry
{
	public static class AnimatedImageHelper
	{
		public static GameObject CreateAnimatedPortrait(GameObject animatedPortrait, bool deleteChildren = false, bool deleteDaySpriteSwapper = false, bool setAsFirstChild = false, bool disableVideoClicking = true)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(animatedPortrait, animatedPortrait.transform);
			val.transform.localPosition = Vector3.zero;
			((Object)val).name = "Animated-Image-VideoPlayer";
			Object.DestroyImmediate((Object)(object)val.GetComponent<Image>());
			RawImage rawImageComponent = val.AddComponent<RawImage>();
			if (disableVideoClicking)
			{
				((Graphic)rawImageComponent).raycastTarget = false;
			}
			if (deleteChildren)
			{
				foreach (Transform item in val.transform)
				{
					Transform val2 = item;
					Object.Destroy((Object)(object)((Component)val2).gameObject);
				}
			}
			if (deleteDaySpriteSwapper)
			{
				Object.Destroy((Object)(object)val.GetComponent<DayNumSpriteSwapper>());
			}
			if (setAsFirstChild)
			{
				val.transform.SetAsFirstSibling();
			}
			VideoPlayer val3 = val.AddComponent<VideoPlayer>();
			val3.playOnAwake = true;
			val3.waitForFirstFrame = true;
			val3.isLooping = true;
			val3.renderMode = (VideoRenderMode)2;
			val3.aspectRatio = (VideoAspectRatio)3;
			val3.audioOutputMode = (VideoAudioOutputMode)0;
			AspectRatioFitter aspectFitter = val.AddComponent<AspectRatioFitter>();
			aspectFitter.aspectMode = (AspectMode)3;
			val3.prepareCompleted += (EventHandler)delegate(VideoPlayer videoPlayer)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Expected O, but got Unknown
				RenderTexture val4 = new RenderTexture((int)videoPlayer.width, (int)videoPlayer.height, 0);
				val4.Create();
				videoPlayer.targetTexture = val4;
				rawImageComponent.texture = (Texture)(object)val4;
				float aspectRatio = (float)videoPlayer.width / (float)videoPlayer.height;
				aspectFitter.aspectRatio = aspectRatio;
			};
			val.SetActive(false);
			return val;
		}

		public static void SetVideoUrl(string url, GameObject animatedPortrait)
		{
			VideoPlayer component = animatedPortrait.GetComponent<VideoPlayer>();
			component.Stop();
			if ((Object)(object)component.targetTexture != (Object)null)
			{
				component.targetTexture.Release();
				Object.Destroy((Object)(object)component.targetTexture);
			}
			component.url = url;
			animatedPortrait.SetActive(true);
		}

		public static void DisableVideoLoop(GameObject animatedPortrait)
		{
			VideoPlayer component = animatedPortrait.GetComponent<VideoPlayer>();
			component.isLooping = false;
		}

		public static void EnableVideoLoop(GameObject animatedPortrait)
		{
			VideoPlayer component = animatedPortrait.GetComponent<VideoPlayer>();
			component.isLooping = true;
		}
	}
	public static class EntryCanvasStandaloneEntry
	{
		[HarmonyPatch(typeof(EntryCanvasStandaloneBehavior), "Start")]
		public static class StartPatch
		{
			private static MethodInfo loadVars = typeof(EntryCanvasStandaloneBehavior).GetMethod("LoadVars", BindingFlags.Instance | BindingFlags.NonPublic);

			private static MethodInfo populateEntriesList = typeof(EntryCanvasStandaloneBehavior).GetMethod("PopulateEntriesList", BindingFlags.Instance | BindingFlags.NonPublic);

			private static bool Prefix(EntryCanvasStandaloneBehavior __instance)
			{
				if (CustomCampaignGlobal.InCustomCampaign && (Object)(object)animatedPortrait == (Object)null)
				{
					animatedPortrait = AnimatedImageHelper.CreateAnimatedPortrait(GetEntryPortrait());
				}
				loadVars.Invoke(__instance, null);
				populateEntriesList.Invoke(__instance, null);
				__instance.CloseWindow();
				return false;
			}
		}

		private static GameObject animatedPortrait;

		private static GameObject GetEntryPortrait()
		{
			return ((Component)((Component)((Component)((Component)((Component)GameObject.Find("EntryCanvasStandalone").transform.Find("Panel")).transform.Find("MainEntryScrollWindow")).transform.Find("Viewport")).transform.Find("Content")).transform.Find("Portrait")).gameObject;
		}

		private static void UpdateVisibilityNormalEntryPortrait(bool showEntryPortrait = false)
		{
			((Behaviour)GetEntryPortrait().GetComponent<Image>()).enabled = showEntryPortrait;
		}

		public static void SetVideoUrlEntryStandaloneCanvas(string url)
		{
			UpdateVisibilityNormalEntryPortrait();
			AnimatedImageHelper.SetVideoUrl(url, animatedPortrait);
		}

		public static void RestoreNormalPortrait()
		{
			UpdateVisibilityNormalEntryPortrait(showEntryPortrait: true);
			VideoPlayer component = animatedPortrait.GetComponent<VideoPlayer>();
			component.Stop();
			if ((Object)(object)component.targetTexture != (Object)null)
			{
				component.targetTexture.Release();
				Object.Destroy((Object)(object)component.targetTexture);
			}
			animatedPortrait.SetActive(false);
		}
	}
	public static class MainCanvasEntry
	{
		public enum PortraitType
		{
			ENTRY,
			CALLER,
			LARGE_CALLER,
			CORNER_CALLER
		}

		[HarmonyPatch(typeof(MainCanvasBehavior), "Start")]
		public static class StartPatch
		{
			private static bool Prefix(MainCanvasBehavior __instance)
			{
				FieldInfo field = typeof(MainCanvasBehavior).GetField("shakeAnimationString", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null)
				{
					LoggingHelper.ErrorLog("'shakeAnimationString' not found. Calling original function.");
					return true;
				}
				((MonoBehaviour)__instance).StartCoroutine(__instance.StartSoftwareRoutine());
				if (GlobalVariables.arcadeMode && Object.op_Implicit((Object)(object)__instance.callTimer))
				{
					__instance.callTimer.SetActive(true);
					__instance.livesPanel.SetActive(true);
				}
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					if ((Object)(object)animatedEntryPortrait == (Object)null)
					{
						animatedEntryPortrait = AnimatedImageHelper.CreateAnimatedPortrait(GetEntryPortrait());
					}
					if ((Object)(object)animatedCallerPortrait == (Object)null)
					{
						animatedCallerPortrait = AnimatedImageHelper.CreateAnimatedPortrait(GetCallerPortrait());
					}
					if ((Object)(object)animatedCallerLargePortrait == (Object)null)
					{
						animatedCallerLargePortrait = AnimatedImageHelper.CreateAnimatedPortrait(((Component)GlobalVariables.mainCanvasScript.largeCallerPortrait).gameObject);
					}
					if ((Object)(object)animatedCallerCornerPortrait == (Object)null)
					{
						animatedCallerCornerPortrait = AnimatedImageHelper.CreateAnimatedPortrait(((Component)GlobalVariables.mainCanvasScript.callerPortrait).gameObject);
					}
				}
				if (!GlobalVariables.isXmasDLC)
				{
					return false;
				}
				field.SetValue(__instance, "xmasShake");
				return false;
			}
		}

		private static GameObject animatedEntryPortrait;

		private static GameObject animatedCallerPortrait;

		private static GameObject animatedCallerLargePortrait;

		private static GameObject animatedCallerCornerPortrait;

		private static GameObject GetEntryPortrait()
		{
			return ((Component)((Component)((Component)((Component)((Component)GameObject.Find("MainCanvas").transform.Find("Panel")).transform.Find("MainEntryScrollWindow")).transform.Find("Viewport")).transform.Find("Content")).transform.Find("Portrait")).gameObject;
		}

		private static GameObject GetCallerPortrait()
		{
			return ((Component)((Component)((Component)GameObject.Find("MainCanvas").transform.Find("CallPopup")).transform.Find("CurrentCall")).transform.Find("CallerPortrait")).gameObject;
		}

		private static void UpdateVisibilityPortrait(PortraitType portraitToUpdate, bool showPortrait = false)
		{
			Image val = null;
			switch (portraitToUpdate)
			{
			case PortraitType.ENTRY:
				val = GetEntryPortrait().GetComponent<Image>();
				break;
			case PortraitType.CALLER:
				val = GetCallerPortrait().GetComponent<Image>();
				break;
			case PortraitType.LARGE_CALLER:
				val = GlobalVariables.mainCanvasScript.largeCallerPortrait;
				break;
			case PortraitType.CORNER_CALLER:
				val = GlobalVariables.mainCanvasScript.callerPortrait;
				break;
			}
			if ((Object)(object)val != (Object)null)
			{
				((Behaviour)val).enabled = showPortrait;
			}
		}

		public static void SetVideoLoop(bool shouldLoop, PortraitType chosenPortrait)
		{
			GameObject animatedPortrait = null;
			switch (chosenPortrait)
			{
			case PortraitType.ENTRY:
				animatedPortrait = animatedEntryPortrait;
				break;
			case PortraitType.CALLER:
				animatedPortrait = animatedCallerPortrait;
				break;
			case PortraitType.LARGE_CALLER:
				animatedPortrait = animatedCallerLargePortrait;
				break;
			case PortraitType.CORNER_CALLER:
				animatedPortrait = animatedCallerCornerPortrait;
				break;
			}
			if (shouldLoop)
			{
				AnimatedImageHelper.EnableVideoLoop(animatedPortrait);
			}
			else
			{
				AnimatedImageHelper.DisableVideoLoop(animatedPortrait);
			}
		}

		public static void SetVideoUrl(string url, PortraitType chosenPortrait)
		{
			GameObject val = null;
			UpdateVisibilityPortrait(chosenPortrait);
			switch (chosenPortrait)
			{
			case PortraitType.ENTRY:
				val = animatedEntryPortrait;
				break;
			case PortraitType.CALLER:
				val = animatedCallerPortrait;
				break;
			case PortraitType.LARGE_CALLER:
				val = animatedCallerLargePortrait;
				break;
			case PortraitType.CORNER_CALLER:
				val = animatedCallerCornerPortrait;
				break;
			}
			if ((Object)(object)val != (Object)null)
			{
				AnimatedImageHelper.SetVideoUrl(url, val);
			}
		}

		public static void RestorePortrait(PortraitType chosenPortrait)
		{
			GameObject val = null;
			switch (chosenPortrait)
			{
			case PortraitType.ENTRY:
				val = animatedEntryPortrait;
				break;
			case PortraitType.CALLER:
				val = animatedCallerPortrait;
				break;
			case PortraitType.LARGE_CALLER:
				if ((Object)(object)animatedCallerLargePortrait == (Object)null)
				{
					return;
				}
				animatedCallerLargePortrait.SetActive(false);
				val = animatedCallerLargePortrait;
				break;
			case PortraitType.CORNER_CALLER:
				val = animatedCallerCornerPortrait;
				break;
			}
			UpdateVisibilityPortrait(chosenPortrait, showPortrait: true);
			if ((Object)(object)val != (Object)null)
			{
				RestoreNormalPortrait(val);
			}
		}

		private static void RestoreNormalPortrait(GameObject animatedImageGameObject)
		{
			VideoPlayer component = animatedImageGameObject.GetComponent<VideoPlayer>();
			component.Stop();
			if ((Object)(object)component.targetTexture != (Object)null)
			{
				component.targetTexture.Release();
				Object.Destroy((Object)(object)component.targetTexture);
			}
			animatedImageGameObject.SetActive(false);
		}
	}
}
namespace NewSafetyHelp.Callers.IncomingCallWindow
{
	public static class AnimatedCallerPortraitPatches
	{
		[HarmonyPatch(typeof(CallWindowBehavior), "UpdateCallerInfo")]
		public static class UpdateCallerInfoPatch
		{
			private static readonly MethodInfo TypeText = typeof(CallWindowBehavior).GetMethod("TypeText", BindingFlags.Instance | BindingFlags.NonPublic);

			private static readonly FieldInfo TypeRoutine = typeof(CallWindowBehavior).GetField("typeRoutine", BindingFlags.Instance | BindingFlags.NonPublic);

			public static bool Prefix(CallWindowBehavior __instance)
			{
				if (TypeText == null || TypeRoutine == null)
				{
					LoggingHelper.ReflectionError("TypeText", "TypeRoutine");
					return true;
				}
				CallerProfile currentCallerProfile = GlobalVariables.callerControllerScript.currentCallerProfile;
				bool flag = (Object)(object)currentCallerProfile == (Object)(object)GlobalVariables.callerControllerScript.warningCall || (Object)(object)currentCallerProfile == (Object)(object)GlobalVariables.callerControllerScript.gameOverCall;
				__instance.myPortrait.sprite = currentCallerProfile.callerPortrait;
				if (CustomCampaignGlobal.InCustomCampaign && flag)
				{
					MainCanvasEntry.RestorePortrait(MainCanvasEntry.PortraitType.CALLER);
					MainCanvasEntry.SetVideoLoop(shouldLoop: true, MainCanvasEntry.PortraitType.CALLER);
				}
				if (CustomCampaignGlobal.InCustomCampaign && !flag)
				{
					CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(GlobalVariables.callerControllerScript.currentCallerID);
					if (customCallerFromActiveCampaign != null && customCallerFromActiveCampaign.CallerHasAnimatedPortrait)
					{
						MainCanvasEntry.SetVideoUrl(customCallerFromActiveCampaign.CallerAnimatedPortraitURL, MainCanvasEntry.PortraitType.CALLER);
						if (customCallerFromActiveCampaign.CallerAnimatedPortraitShouldLoop.HasChanged)
						{
							MainCanvasEntry.SetVideoLoop(customCallerFromActiveCampaign.CallerAnimatedPortraitShouldLoop.Data, MainCanvasEntry.PortraitType.CALLER);
						}
					}
					else
					{
						MainCanvasEntry.RestorePortrait(MainCanvasEntry.PortraitType.CALLER);
						MainCanvasEntry.SetVideoLoop(shouldLoop: true, MainCanvasEntry.PortraitType.CALLER);
					}
				}
				((TMP_Text)__instance.myName).text = "CURRENT CALLER: " + currentCallerProfile.callerName.ToUpper();
				((TMP_Text)__instance.myTranscription).text = currentCallerProfile.callTranscription;
				((TMP_Text)__instance.myTranscription).maxVisibleCharacters = 0;
				__instance.holdButton.SetActive(false);
				__instance.submitButton.SetActive(false);
				__instance.closeButton.SetActive(false);
				IEnumerator enumerator = (IEnumerator)TypeText.Invoke(__instance, new object[2] { currentCallerProfile, false });
				TypeRoutine.SetValue(__instance, ((MonoBehaviour)__instance).StartCoroutine(enumerator));
				return false;
			}
		}

		[HarmonyPatch(typeof(MainCanvasBehavior), "UpdateCallerInfo", new Type[] { typeof(CallerProfile) })]
		public static class UpdateCallerInfoCornerPortraitPatch
		{
			private static readonly MethodInfo UpdateLayoutGroup = typeof(MainCanvasBehavior).GetMethod("UpdateLayoutGroup", BindingFlags.Instance | BindingFlags.NonPublic);

			public static bool Prefix(MainCanvasBehavior __instance, ref CallerProfile profile)
			{
				if (UpdateLayoutGroup == null)
				{
					LoggingHelper.ReflectionError("UpdateLayoutGroup");
					return true;
				}
				((TMP_Text)__instance.callerNameText).text = "CURRENT CALLER: " + profile.callerName.ToUpper();
				__instance.callerPortrait.sprite = profile.callerPortrait;
				bool flag = (Object)(object)profile == (Object)(object)GlobalVariables.callerControllerScript.warningCall || (Object)(object)profile == (Object)(object)GlobalVariables.callerControllerScript.gameOverCall;
				if (CustomCampaignGlobal.InCustomCampaign && flag)
				{
					MainCanvasEntry.RestorePortrait(MainCanvasEntry.PortraitType.CORNER_CALLER);
					MainCanvasEntry.SetVideoLoop(shouldLoop: true, MainCanvasEntry.PortraitType.CORNER_CALLER);
					TimerCallerHelper.HideCallerTimerUI();
				}
				if (CustomCampaignGlobal.InCustomCampaign && !flag)
				{
					CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(GlobalVariables.callerControllerScript.currentCallerID);
					if (customCallerFromActiveCampaign != null && customCallerFromActiveCampaign.CallerHasAnimatedPortrait)
					{
						MainCanvasEntry.SetVideoUrl(customCallerFromActiveCampaign.CallerAnimatedPortraitURL, MainCanvasEntry.PortraitType.CORNER_CALLER);
						if (customCallerFromActiveCampaign.CallerAnimatedPortraitShouldLoop.HasChanged)
						{
							MainCanvasEntry.SetVideoLoop(customCallerFromActiveCampaign.CallerAnimatedPortraitShouldLoop.Data, MainCanvasEntry.PortraitType.CORNER_CALLER);
						}
					}
					else
					{
						MainCanvasEntry.RestorePortrait(MainCanvasEntry.PortraitType.CORNER_CALLER);
						MainCanvasEntry.SetVideoLoop(shouldLoop: true, MainCanvasEntry.PortraitType.CORNER_CALLER);
					}
					if (customCallerFromActiveCampaign != null && customCallerFromActiveCampaign.IsTimedCaller)
					{
						TimerCallerHelper.ShowCallerTimerUI(__instance, customCallerFromActiveCampaign);
					}
					else
					{
						TimerCallerHelper.HideCallerTimerUI();
					}
				}
				__instance.largeCallerPortrait.sprite = profile.callerPortrait;
				if (CustomCampaignGlobal.InCustomCampaign && flag)
				{
					MainCanvasEntry.RestorePortrait(MainCanvasEntry.PortraitType.LARGE_CALLER);
					MainCanvasEntry.SetVideoLoop(shouldLoop: true, MainCanvasEntry.PortraitType.LARGE_CALLER);
				}
				if (CustomCampaignGlobal.InCustomCampaign && !flag)
				{
					CustomCCaller customCallerFromActiveCampaign2 = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(GlobalVariables.callerControllerScript.currentCallerID);
					if (customCallerFromActiveCampaign2 != null && customCallerFromActiveCampaign2.CallerHasAnimatedPortrait)
					{
						MainCanvasEntry.SetVideoUrl(customCallerFromActiveCampaign2.CallerAnimatedPortraitURL, MainCanvasEntry.PortraitType.LARGE_CALLER);
						if (customCallerFromActiveCampaign2.CallerAnimatedPortraitShouldLoop.HasChanged)
						{
							MainCanvasEntry.SetVideoLoop(customCallerFromActiveCampaign2.CallerAnimatedPortraitShouldLoop.Data, MainCanvasEntry.PortraitType.LARGE_CALLER);
						}
					}
					else
					{
						MainCanvasEntry.RestorePortrait(MainCanvasEntry.PortraitType.LARGE_CALLER);
						MainCanvasEntry.SetVideoLoop(shouldLoop: true, MainCanvasEntry.PortraitType.LARGE_CALLER);
					}
				}
				((TMP_Text)__instance.callerTranscription).text = profile.callTranscription;
				IEnumerator enumerator = (IEnumerator)UpdateLayoutGroup.Invoke(__instance, new object[1] { __instance.transcriptionLayoutGroup });
				((MonoBehaviour)__instance).StartCoroutine(enumerator);
				return false;
			}
		}

		[HarmonyPatch(typeof(MainCanvasBehavior), "NoCallerWindow")]
		public static class NoCallerWindowPatch
		{
			public static bool Prefix(MainCanvasBehavior __instance)
			{
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					MainCanvasEntry.RestorePortrait(MainCanvasEntry.PortraitType.LARGE_CALLER);
				}
				__instance.largeCallerPortrait.sprite = __instance.noCallerSprite;
				((Component)__instance.largeCallerPortrait).gameObject.SetActive(true);
				((TMP_Text)__instance.callerNameText).text = "NO CURRENT CALLERS";
				((TMP_Text)__instance.callerTranscription).text = "";
				return false;
			}
		}
	}
	public static class CloseButtonPatches
	{
		[HarmonyPatch(typeof(CallWindowBehavior), "CloseCallButton")]
		public static class CloseCallPatches
		{
			private static bool Prefix(CallWindowBehavior __instance)
			{
				if (GlobalVariables.callerControllerScript.currentCallerID == GlobalVariables.callerControllerScript.callers.Length - 1)
				{
					if (CustomCampaignGlobal.InCustomCampaign)
					{
						LoggingHelper.InfoLog("Playing custom ending cutscene.", LoggingHelper.LoggingCategory.NONE, ConsoleColor.Green);
						GlobalVariables.callerControllerScript.callers[GlobalVariables.callerControllerScript.currentCallerID].answeredCorrectly = true;
						CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
						if (activeCustomCampaign != null)
						{
							float num = GlobalVariables.callerControllerScript.GetScore();
							if (float.IsNaN(num) || float.IsInfinity(num))
							{
								num = 100f;
							}
							activeCustomCampaign.SavedDayScores[GlobalVariables.currentDay] = num;
							LoggingHelper.DebugLog($"(Custom Ending) Saving day score of day '{GlobalVariables.currentDay}'. " + $"With the score of '{activeCustomCampaign.SavedDayScores[GlobalVariables.currentDay]}'.");
							GameObject gameObject = ((Component)((Component)__instance).gameObject.transform.Find("CurrentCall").Find("CloseButton")).gameObject;
							if ((Object)(object)gameObject != (Object)null)
							{
								Button val = default(Button);
								if (gameObject.TryGetComponent<Button>(ref val))
								{
									((Selectable)val).interactable = false;
								}
								SwapCursorHoverDisplayer val2 = default(SwapCursorHoverDisplayer);
								if (gameObject.TryGetComponent<SwapCursorHoverDisplayer>(ref val2))
								{
									((Behaviour)val2).enabled = false;
								}
								GameObject gameObject2 = ((Component)gameObject.transform.Find("Text (TMP)")).gameObject;
								TextMeshProUGUI val3 = default(TextMeshProUGUI);
								if ((Object)(object)gameObject2 != (Object)null && gameObject2.TryGetComponent<TextMeshProUGUI>(ref val3))
								{
									((TMP_Text)val3).text = "...";
								}
								(bool, VariableChanged<bool>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.FinalCutscenePreventClicks, (VariableChanged<bool> vCb) => vCb.HasChanged);
								bool flag = true;
								if (activeModifierValue.Item1)
								{
									flag = activeModifierValue.Item2.Data;
								}
								if (flag)
								{
									GlobalVariables.mainCanvasScript.inputBlocker.SetActive(true);
								}
							}
						}
						GlobalVariables.mainCanvasScript.PlayEndingCutscene();
					}
					else
					{
						GlobalVariables.callerControllerScript.callers[GlobalVariables.callerControllerScript.currentCallerID].answeredCorrectly = true;
						if (!GlobalVariables.isXmasDLC)
						{
							__instance.faeCarolRoot.SetActive(true);
							__instance.currentCallRoot.SetActive(false);
							GlobalVariables.callerControllerScript.StopCallAudio();
							GlobalVariables.UISoundControllerScript.StopUISoundLooping();
							GlobalVariables.callerControllerScript.StopLargeWindowRoutine();
							GlobalVariables.UISoundControllerScript.PlayUISound(__instance.faeCarolClip, (AudioSource)null);
						}
						GlobalVariables.mainCanvasScript.PlayEndingCutscene();
					}
				}
				else
				{
					GlobalVariables.callerControllerScript.SubmitAnswer((MonsterProfile)null);
					GlobalVariables.UISoundControllerScript.StopUISoundLooping();
					__instance.CloseButton(false, false);
					GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.disconnect, (AudioSource)null);
					if (CustomCampaignGlobal.InCustomCampaign && !GlobalVariables.arcadeMode)
					{
						int num2 = CallerSkipping.CheckIfAnyValidCallerLeft(GlobalVariables.callerControllerScript);
						if (num2 > 0)
						{
							LoggingHelper.DebugLog("Calling end day routine from close button.");
							MelonCoroutines.Start(IntermissionMusicHelper.StopIntermissionMusic());
							TimerCallerHelper.StopTimedCallerTimer();
							for (int num3 = 1; num3 < num2 + 1; num3++)
							{
								int num4 = GlobalVariables.callerControllerScript.currentCallerID + num3;
								if (num4 < GlobalVariables.callerControllerScript.callers.Length)
								{
									GlobalVariables.callerControllerScript.callers[num4].answeredCorrectly = true;
								}
							}
							CallerController callerControllerScript = GlobalVariables.callerControllerScript;
							callerControllerScript.currentCallerID += num2;
							((MonoBehaviour)GlobalVariables.mainCanvasScript).StartCoroutine(GlobalVariables.mainCanvasScript.EndDayRoutine());
							GlobalVariables.mainCanvasScript.NoCallerWindow();
							return false;
						}
					}
				}
				return false;
			}
		}
	}
	public static class CallWindowStartPatches
	{
		[HarmonyPatch(typeof(CallWindowBehavior), "OnEnable")]
		public static class OnEnablePatch
		{
			private static bool Prefix(CallWindowBehavior __instance)
			{
				__instance.answerButton.SetActive(true);
				__instance.loadingText.SetActive(false);
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					if (GlobalVariables.callerControllerScript.currentCallerID + 1 <= GlobalVariables.callerControllerScript.callers.Length)
					{
						int[] downedNetworkCalls = GlobalVariables.callerControllerScript.downedNetworkCalls;
						foreach (int num in downedNetworkCalls)
						{
							if (num == GlobalVariables.callerControllerScript.currentCallerID + 1)
							{
								if (!GlobalVariables.isXmasDLC)
								{
									GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.phoneCallWarped, (AudioSource)null);
									return false;
								}
								GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.xmasPhoneCallWarped, (AudioSource)null);
								return false;
							}
						}
						if (!GlobalVariables.isXmasDLC)
						{
							GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.phoneCall, (AudioSource)null);
						}
						else
						{
							GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.xmasPhoneCall, (AudioSource)null);
						}
					}
					else if (!GlobalVariables.isXmasDLC)
					{
						GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.phoneCall, (AudioSource)null);
					}
					else
					{
						GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.xmasPhoneCall, (AudioSource)null);
					}
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					if (activeCustomCampaign.CustomRingtones != null && activeCustomCampaign.CustomRingtones.Count > 0)
					{
						List<CustomRingtone> validRingtones = new List<CustomRingtone>();
						List<CustomRingtone> validRingtones2 = new List<CustomRingtone>();
						foreach (CustomRingtone item in activeCustomCampaign.CustomRingtones.Where((CustomRingtone c) => c.UnlockDay <= GlobalVariables.currentDay))
						{
							if (!item.OnlyOnUnlockDay || item.UnlockDay == GlobalVariables.currentDay)
							{
								if (item.IsGlitchedVersion)
								{
									validRingtones2.Add(item);
								}
								else
								{
									validRingtones.Add(item);
								}
							}
						}
						GlobalVariables.UISoundControllerScript.phoneCall = RingtoneHelper.ReplacePhoneRingtoneIfValid(ref validRingtones, activeCustomCampaign.DoNotAccountDefaultRingtone, ref UISoundPatch.StartPatch.DefaultRingtone);
						GlobalVariables.UISoundControllerScript.phoneCallWarped = RingtoneHelper.ReplacePhoneRingtoneIfValid(ref validRingtones2, activeCustomCampaign.DoNotAccountDefaultRingtone, ref UISoundPatch.StartPatch.DefaultWarpedRingtone);
					}
					if (GlobalVariables.callerControllerScript.currentCallerID + 1 <= GlobalVariables.callerControllerScript.callers.Length)
					{
						int currentCallerID = GlobalVariables.callerControllerScript.currentCallerID;
						int checkResult = CallerSkipping.GetCallersSkippedAmount(GlobalVariables.callerControllerScript);
						int callersLookedAhead = 1;
						if (checkResult > 0)
						{
							callersLookedAhead = checkResult + 1;
						}
						if ((bool)FirstCaller.GetValue(GlobalVariables.callerControllerScript))
						{
							LoggingHelper.DebugLog("First caller of the day. Callers ahead will be set to 0.", LoggingHelper.LoggingCategory.RINGTONE);
							callersLookedAhead = 0;
						}
						int callerToBeCalledID = currentCallerID + callersLookedAhead;
						LoggingHelper.DebugLog(() => $"Checking the ringtone for the caller with ID: '{callerToBeCalledID}' " + $"Check Result: '{checkResult}'. " + $"(Look ahead '{callersLookedAhead}').", LoggingHelper.LoggingCategory.RINGTONE);
						CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(callerToBeCalledID);
						if (customCallerFromActiveCampaign == null)
						{
							LoggingHelper.ErrorLog("Custom campaign caller was null. Unable of checking for downed network parameter. Calling original function.");
							return true;
						}
						if (CustomCampaignGlobal.InCustomCampaign)
						{
							MelonCoroutines.Start(IntermissionMusicHelper.StopIntermissionMusic());
							TimerCallerHelper.StopTimedCallerTimer();
						}
						if (!GlobalVariables.isXmasDLC && customCallerFromActiveCampaign.DownedNetworkCaller)
						{
							LoggingHelper.DebugLog("Custom caller is set to play warped phone call sound " + $"(INFO: Downed Network? {customCallerFromActiveCampaign.DownedNetworkCaller}; " + "Caller Name: " + customCallerFromActiveCampaign.CallerName + ").");
							GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.phoneCallWarped, (AudioSource)null);
							return false;
						}
						if (!GlobalVariables.isXmasDLC)
						{
							GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.phoneCall, (AudioSource)null);
						}
						else
						{
							GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.xmasPhoneCall, (AudioSource)null);
						}
					}
					else if (!GlobalVariables.isXmasDLC)
					{
						GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.phoneCall, (AudioSource)null);
					}
					else
					{
						GlobalVariables.UISoundControllerScript.PlayUISoundLooping(GlobalVariables.UISoundControllerScript.xmasPhoneCall, (AudioSource)null);
					}
				}
				return false;
			}
		}

		private static readonly FieldInfo FirstCaller = typeof(CallerController).GetField("firstCaller", BindingFlags.Instance | BindingFlags.NonPublic);
	}
	public static class TypeTextPatches
	{
		[HarmonyPatch(typeof(CallWindowBehavior), "TypeText", new Type[]
		{
			typeof(CallerProfile),
			typeof(bool)
		})]
		public static class TypeTextPatch
		{
			private static bool Prefix(CallWindowBehavior __instance, ref IEnumerator __result, ref CallerProfile profile, ref bool skip)
			{
				__result = TypeTextCoroutine(__instance, profile, skip);
				return false;
			}

			private static IEnumerator TypeTextCoroutine(CallWindowBehavior __instance, CallerProfile profile, bool skip)
			{
				yield return null;
				if ((Object)(object)profile == (Object)null)
				{
					LoggingHelper.WarningLog("Profile is null. Possibly missing something?");
					yield break;
				}
				int characterCount = ((TMP_Text)__instance.myTranscription).textInfo.characterCount;
				int counter = 0;
				float waitTime = 0f;
				if ((Object)(object)profile.callerClip != (Object)null && (Object)(object)profile.callerClip.clip != (Object)null)
				{
					waitTime = profile.callerClip.clip.length / (float)characterCount;
				}
				else
				{
					skip = true;
				}
				if (skip)
				{
					counter = characterCount + 1;
					((TMP_Text)__instance.myTranscription).maxVisibleCharacters = counter;
				}
				while (counter < characterCount + 1)
				{
					((TMP_Text)__instance.myTranscription).maxVisibleCharacters = counter;
					if ((double)waitTime > 0.006)
					{
						int num = counter + 1;
						counter = num;
					}
					else
					{
						counter += 2;
					}
					if ((double)waitTime > 0.005)
					{
						yield return (object)new WaitForSecondsRealtime(waitTime);
					}
					else
					{
						yield return null;
					}
				}
				((TMP_Text)__instance.myTranscription).maxVisibleCharacters = int.MaxValue;
				if ((Object)(object)profile.callerMonster != (Object)null)
				{
					__instance.holdButton.SetActive(true);
					if (GlobalVariables.arcadeMode)
					{
						GlobalVariables.callerControllerScript.StartCallTimerRoutine();
					}
				}
				else
				{
					__instance.closeButton.SetActive(true);
				}
			}
		}
	}
}
namespace NewSafetyHelp.Callers.CallerModel
{
	public class CustomCCaller : CustomCampaignElementBase
	{
		public RichAudioClip CallerClip = null;

		public string CallerClipPath = "";

		public bool IsCallerClipLoaded = false;

		public string CallTranscript = "NO_TRANSCRIPT";

		public string CallerName = "NO_CALLER_NAME";

		public Sprite CallerImage = null;

		public string CallerAnimatedPortraitURL = null;

		public bool CallerHasAnimatedPortrait = false;

		public VariableChanged<bool> CallerAnimatedPortraitShouldLoop = new VariableChanged<bool>
		{
			Data = true
		};

		public int ConsequenceCallerID = -1;

		public bool CallerIncreasesTier = false;

		public bool LastDayCaller = false;

		public bool DownedNetworkCaller = false;

		public string EntryNameAttached = "NO_MONSTER_NAME";

		public int EntryIDAttached = -1;

		public readonly int OrderInCampaign;

		public bool InCustomCampaign = false;

		public bool IsWarningCaller = false;

		public int WarningCallDay = -1;

		public bool IsGameOverCaller = false;

		public int GameOverCallDay = -1;

		public bool IsAccuracyCaller = false;

		public List<CallerAccuracyType> AccuracyChecks = new List<CallerAccuracyType>();

		public bool CountEveryCallerForLocalAccuracy = false;

		public bool IsTimedCaller = false;

		public float TimedCallerDuration = 0f;

		public CustomCCaller(int orderInCampaign)
		{
			OrderInCampaign = orderInCampaign;
		}
	}
}
namespace NewSafetyHelp.Callers.CallerHelpers
{
	public static class CallerSkipping
	{
		public static int CheckIfAnyValidCallerLeft(CallerController __instance)
		{
			int num = 0;
			for (int i = __instance.currentCallerID + 1; i < __instance.callers.Length; i++)
			{
				if (i >= __instance.callers.Length)
				{
					continue;
				}
				CustomCCaller customCCallerFound = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(i);
				if (customCCallerFound == null)
				{
					return -1;
				}
				int currentIndexCopy = i;
				LoggingHelper.DebugLog(() => $"Last caller of day (Caller ID: {currentIndexCopy}): '{customCCallerFound.LastDayCaller}'. " + $"Next caller name (Caller ID: {currentIndexCopy}): '{customCCallerFound.CallerName}'. " + $"Is a accuracy caller?: '{customCCallerFound.IsAccuracyCaller}'.", LoggingHelper.LoggingCategory.SKIPPED_CALLER);
				LoggingHelper.DebugLog(() => "Is ConsequenceProfile not null? (Meaning it's this current caller is a consequence caller): " + $"'{(Object)(object)GlobalVariables.callerControllerScript.callers[currentIndexCopy].callerProfile.consequenceCallerProfile != (Object)null}'." + "\nIs this caller allowed to be called? (Meaning we got the answer wrong from the previous caller): " + $"'{GlobalVariables.callerControllerScript.CanReceiveConsequenceCall(GlobalVariables.callerControllerScript.callers[currentIndexCopy].callerProfile.consequenceCallerProfile)}'." + "\n" + $"Is this caller the last one of the day? '{customCCallerFound.LastDayCaller}'.", LoggingHelper.LoggingCategory.SKIPPED_CALLER);
				bool flag = false;
				if ((Object)(object)GlobalVariables.callerControllerScript.callers[i].callerProfile.consequenceCallerProfile != (Object)null)
				{
					flag = true;
					if (GlobalVariables.callerControllerScript.CanReceiveConsequenceCall(GlobalVariables.callerControllerScript.callers[i].callerProfile.consequenceCallerProfile))
					{
						return -1;
					}
					num++;
					if (customCCallerFound.LastDayCaller)
					{
						return num;
					}
				}
				if (customCCallerFound.IsAccuracyCaller)
				{
					bool flag2 = AccuracyCallerHelper.CheckIfCallerIsToBeShown(customCCallerFound);
					if (customCCallerFound.IsAccuracyCaller && flag2)
					{
						return -1;
					}
					num++;
					if (customCCallerFound.LastDayCaller && !flag2)
					{
						return num;
					}
				}
				if (!flag && !customCCallerFound.IsAccuracyCaller)
				{
					return -1;
				}
			}
			return -1;
		}

		public static int GetCallersSkippedAmount(CallerController __instance)
		{
			int num = 0;
			for (int i = __instance.currentCallerID + 1; i < __instance.callers.Length; i++)
			{
				if (i >= __instance.callers.Length)
				{
					continue;
				}
				CustomCCaller customCCallerFound = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(i);
				if (customCCallerFound == null)
				{
					return num;
				}
				int currentIndexCopy = i;
				LoggingHelper.DebugLog(() => $"Last caller of day (Caller ID: {currentIndexCopy}): '{customCCallerFound.LastDayCaller}'. " + $"Next caller name (Caller ID: {currentIndexCopy}): '{customCCallerFound.CallerName}'. " + $"Is a accuracy caller?: '{customCCallerFound.IsAccuracyCaller}'.", LoggingHelper.LoggingCategory.SKIPPED_CALLER);
				LoggingHelper.DebugLog(() => "Is ConsequenceProfile not null? (Meaning it's this current caller is a consequence caller): " + $"'{(Object)(object)GlobalVariables.callerControllerScript.callers[currentIndexCopy].callerProfile.consequenceCallerProfile != (Object)null}'." + "\nIs this caller allowed to be called? (Meaning we got the answer wrong from the previous caller): " + $"'{GlobalVariables.callerControllerScript.CanReceiveConsequenceCall(GlobalVariables.callerControllerScript.callers[currentIndexCopy].callerProfile.consequenceCallerProfile)}'." + "\n" + $"Is this caller the last one of the day? '{customCCallerFound.LastDayCaller}'.", LoggingHelper.LoggingCategory.SKIPPED_CALLER);
				bool flag = false;
				if ((Object)(object)GlobalVariables.callerControllerScript.callers[i].callerProfile.consequenceCallerProfile != (Object)null)
				{
					flag = true;
					if (GlobalVariables.callerControllerScript.CanReceiveConsequenceCall(GlobalVariables.callerControllerScript.callers[i].callerProfile.consequenceCallerProfile))
					{
						return num;
					}
					num++;
					if (customCCallerFound.LastDayCaller)
					{
						return num;
					}
				}
				if (customCCallerFound.IsAccuracyCaller)
				{
					bool flag2 = AccuracyCallerHelper.CheckIfCallerIsToBeShown(customCCallerFound);
					if (customCCallerFound.IsAccuracyCaller && flag2)
					{
						return num;
					}
					num++;
					if (customCCallerFound.LastDayCaller && !flag2)
					{
						return num;
					}
				}
				if (!flag && !customCCallerFound.IsAccuracyCaller)
				{
					return num;
				}
			}
			return -1;
		}
	}
}
namespace NewSafetyHelp.Callers.CallerCreationAndUpdate
{
	public static class CreateAndUpdateCallerPatches
	{
		[HarmonyPatch(typeof(CallerController), "CreateCustomCaller")]
		public static class UpdateArcadeCallerAudio
		{
			private static readonly MethodInfo PickRandomClip = typeof(CallerController).GetMethod("PickRandomClip", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

			private static void Postfix(CallerController __instance)
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Expected O, but got Unknown
				foreach (EntryMetadata entriesMetadatum in GlobalParsingVariables.EntriesMetadata)
				{
					if (__instance.currentCustomCaller.callerMonster.monsterName == entriesMetadatum.Name || __instance.currentCustomCaller.callerMonster.monsterID == entriesMetadatum.ID)
					{
						__instance.currentCustomCaller.callerClip = entriesMetadatum.CallerClip;
					}
				}
				if ((Object)(object)__instance.currentCustomCaller.callerClip == (Object)null)
				{
					if (PickRandomClip == null)
					{
						LoggingHelper.ReflectionError("PickRandomClip");
					}
					else
					{
						__instance.currentCustomCaller.callerClip = (RichAudioClip)PickRandomClip.Invoke(__instance, null);
					}
				}
			}
		}

		[HarmonyPatch(typeof(CallerController), "PlayCallAudioRoutine", new Type[] { typeof(CallerProfile) })]
		public static class UpdateCampaignCallerAudio
		{
			private static readonly FieldInfo CallerAudioSource = typeof(CallerController).GetField("callerAudioSource", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(CallerController __instance, CallerProfile profile, ref IEnumerator __result)
			{
				__result = OriginalCaller(__instance, profile);
				return false;
			}

			private static IEnumerator OriginalCaller(CallerController __instance, CallerProfile profile)
			{
				if ((Object)(object)profile == (Object)null && !__instance.arcadeMode)
				{
					profile = __instance.callers[__instance.currentCallerID].callerProfile;
				}
				if (__instance.arcadeMode)
				{
					profile = __instance.currentCustomCaller;
				}
				yield return (object)new WaitForSeconds(__instance.playCallAudioDelayTime);
				if (CallerAudioSource == null)
				{
					LoggingHelper.ReflectionError("CallerAudioSource");
					yield break;
				}
				AudioSource callerAudioSource = (AudioSource)CallerAudioSource.GetValue(__instance);
				if ((Object)(object)callerAudioSource == (Object)null)
				{
					LoggingHelper.ErrorLog("CallerController: CallerAudioSource is null");
					yield break;
				}
				callerAudioSource.Stop();
				bool foundReplacementClip = false;
				if (!CustomCampaignGlobal.InCustomCampaign && (Object)(object)profile != (Object)null && (Object)(object)profile.callerMonster != (Object)null && !__instance.arcadeMode)
				{
					foreach (EntryMetadata item in GlobalParsingVariables.EntriesMetadata)
					{
						if (!item.CurrentlySelected)
						{
							continue;
						}
						item.AlreadyCalledOnce = true;
						if (!item.AllowCallAgainOverRestart)
						{
							if (!GlobalPreferences.PersistantEntrySave.HasEntry(item.Name + item.CallerName))
							{
								GlobalPreferences.PersistantEntrySave.CreateEntry<bool>(item.Name + item.CallerName, true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
							}
							else
							{
								GlobalPreferences.PersistantEntrySave.GetEntry<bool>(item.Name + item.CallerName).Value = true;
							}
						}
						else if (!GlobalPreferences.PersistantEntrySave.HasEntry(item.Name + item.CallerName))
						{
							GlobalPreferences.PersistantEntrySave.CreateEntry<bool>(item.Name + item.CallerName, false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
						}
						else
						{
							GlobalPreferences.PersistantEntrySave.GetEntry<bool>(item.Name + item.CallerName).Value = false;
						}
						if ((Object)(object)item.CallerClip != (Object)null && (Object)(object)item.CallerClip.clip != (Object)null)
						{
							callerAudioSource.clip = item.CallerClip.clip;
						}
						foundReplacementClip = true;
					}
				}
				if (!foundReplacementClip)
				{
					if ((Object)(object)profile != (Object)null && (Object)(object)profile.callerMonster != (Object)null)
					{
						LoggingHelper.DebugLog("Monster Name: " + profile.callerMonster.monsterName + " with ID: " + $"{profile.callerMonster.monsterID}.");
					}
					else if (!CustomCampaignGlobal.InCustomCampaign)
					{
						LoggingHelper.InfoLog("This caller does not have a monster entry. The caller audio will not be replaced.");
					}
					if ((Object)(object)profile != (Object)null && (Object)(object)profile.callerClip != (Object)null && (Object)(object)profile.callerClip.clip != (Object)null)
					{
						callerAudioSource.clip = profile.callerClip.clip;
					}
				}
				LoggingHelper.InfoLog("Caller Audio File Name: " + ((Object)callerAudioSource).name + " with " + ((Object)callerAudioSource.clip).name + " and " + $"{callerAudioSource.clip.length}.");
				if ((Object)(object)profile != (Object)null && (Object)(object)profile.callerClip != (Object)null)
				{
					callerAudioSource.volume = profile.callerClip.volume;
				}
				if ((Object)(object)callerAudioSource.clip != (Object)null)
				{
					callerAudioSource.Play();
				}
			}
		}

		[HarmonyPatch(typeof(CallerController), "UpdateCallerInfo", new Type[] { typeof(CallerProfile) })]
		public static class UpdateCampaignCallerRandom
		{
			private static bool Prefix(CallerController __instance, ref CallerProfile profile)
			{
				LoggingHelper.DebugLog("New caller is calling.");
				if ((Object)(object)profile == (Object)null)
				{
					if (__instance.callers[__instance.currentCallerID] == null)
					{
						LoggingHelper.ErrorLog("Caller is null. Unable of calling. You may have a duplicate caller (Meaning the same ID on two callers)!");
						return false;
					}
					profile = __instance.callers[__instance.currentCallerID].callerProfile;
				}
				if (__instance.arcadeMode)
				{
					profile = __instance.currentCustomCaller;
				}
				List<EntryMetadata> entries = new List<EntryMetadata>();
				bool flag = false;
				if (!CustomCampaignGlobal.InCustomCampaign && !__instance.arcadeMode)
				{
					foreach (EntryMetadata entriesMetadatum in GlobalParsingVariables.EntriesMetadata)
					{
						if (!entriesMetadatum.InMainCampaign || entriesMetadatum.AlreadyCalledOnce || entriesMetadatum.CurrentlySelected)
						{
							continue;
						}
						MelonPreferences_Entry<bool> val = (GlobalPreferences.PersistantEntrySave.HasEntry(entriesMetadatum.Name + entriesMetadatum.CallerName) ? GlobalPreferences.PersistantEntrySave.GetEntry<bool>(entriesMetadatum.Name + entriesMetadatum.CallerName) : GlobalPreferences.PersistantEntrySave.CreateEntry<bool>(entriesMetadatum.Name + entriesMetadatum.CallerName, false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null));
						if (entriesMetadatum.AllowCallAgainOverRestart)
						{
							LoggingHelper.DebugLog("Entry " + entriesMetadatum.Name + " is allowed to be called again even if called once in the past.");
							val.Value = false;
						}
						if (val.Value)
						{
							LoggingHelper.DebugLog("Entry " + entriesMetadatum.Name + " was already called once, so it will not be available for calling.");
						}
						if (!(Random.Range(0f, 1f) <= entriesMetadatum.CallerReplaceChance))
						{
							continue;
						}
						if (!entriesMetadatum.AllowCallAgainOverRestart)
						{
							if (val.Value || entriesMetadatum.PermissionLevel > GlobalVariables.currentDay)
							{
								continue;
							}
							if (GlobalVariables.isXmasDLC)
							{
								if (entriesMetadatum.IncludeInDlc || entriesMetadatum.OnlyDLC)
								{
									entries.Add(entriesMetadatum);
									flag = true;
									LoggingHelper.InfoLog("Saved Entry '" + entriesMetadatum.Name + "' to not be called in the future.");
									val.Value = true;
								}
								else
								{
									LoggingHelper.InfoLog("Entry '" + entriesMetadatum.Name + "' is not allowed to be called in DLC Mode.");
								}
							}
							else
							{
								entries.Add(entriesMetadatum);
								flag = true;
								LoggingHelper.InfoLog("Saved Entry '" + entriesMetadatum.Name + "' to not be called in the future.");
								val.Value = true;
							}
						}
						else
						{
							if (entriesMetadatum.PermissionLevel > GlobalVariables.currentDay)
							{
								continue;
							}
							if (GlobalVariables.isXmasDLC)
							{
								if (entriesMetadatum.IncludeInDlc || entriesMetadatum.OnlyDLC)
								{
									entries.Add(entriesMetadatum);
									flag = true;
								}
							}
							else
							{
								entries.Add(entriesMetadatum);
								flag = true;
							}
						}
					}
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					if ((Object)(object)profile != (Object)null && !__instance.arcadeMode && (Object)(object)profile.consequenceCallerProfile != (Object)null)
					{
						LoggingHelper.InfoLog("Current caller is a consequence Caller.");
						Caller callers = GetConsequenceCaller(profile, ref __instance.callers);
						if (callers != null)
						{
							LoggingHelper.InfoLog("Consequence Caller name: " + ((Object)callers.callerProfile).name);
							if (GlobalParsingVariables.EntriesMetadata.Exists((EntryMetadata item) => item.ReferenceProfileNameInternal == ((Object)callers.callerProfile.consequenceCallerProfile).name))
							{
								LoggingHelper.InfoLog("Consequence Caller to be replaced found!");
								EntryMetadata entryMetadata = GlobalParsingVariables.EntriesMetadata.Find((EntryMetadata item) => item.ReferenceProfileNameInternal == ((Object)callers.callerProfile.consequenceCallerProfile).name);
								if (entryMetadata == null)
								{
									LoggingHelper.ErrorLog("Did not find replacement caller.");
									return true;
								}
								profile.callTranscription = entryMetadata.ConsequenceTranscript;
								profile.callerName = entryMetadata.ConsequenceName;
								profile.callerPortrait = entryMetadata.ConsequenceCallerImage;
								profile.callerClip = entryMetadata.ConsequenceCallerClip;
								LoggingHelper.InfoLog("Replaced the current caller transcript with: " + profile.callTranscription + ".");
							}
						}
						else
						{
							LoggingHelper.ErrorLog("Did not find initial caller.");
						}
					}
					else if (flag && (Object)(object)profile != (Object)null && (Object)(object)profile.callerMonster != (Object)null && !__instance.arcadeMode && (Object)(object)profile.consequenceCallerProfile == (Object)null && entries.Count > 0)
					{
						int entrySelected = Random.Range(0, entries.Count - 1);
						GlobalParsingVariables.EntriesMetadata.Find((EntryMetadata item) => item.Equals(entries[entrySelected])).CurrentlySelected = true;
						EntryMetadata entryMetadata2 = entries[entrySelected];
						profile.callerName = entryMetadata2.CallerName;
						if ((Object)(object)entryMetadata2.CallerImage != (Object)null)
						{
							profile.callerPortrait = entryMetadata2.CallerImage;
						}
						profile.callTranscription = entryMetadata2.CallTranscript;
						if ((Object)(object)profile != (Object)null && (Object)(object)profile.callerMonster != (Object)null)
						{
							LoggingHelper.InfoLog("Replaced the current caller (" + profile.callerMonster.monsterName + " " + $"with ID: {profile.callerMonster.monsterID}) with a custom caller:" + $" {entryMetadata2.Name} with ID: {entryMetadata2.ID}.");
						}
						GlobalParsingVariables.EntriesMetadata.Find((EntryMetadata item) => item.Equals(entries[entrySelected])).ReferenceProfileNameInternal = ((Object)profile).name;
					}
					LoggingHelper.DebugLog("Finished handling the caller replacement.");
				}
				__instance.currentCallerProfile = profile;
				GlobalVariables.mainCanvasScript.UpdateCallerInfo(profile);
				LoggingHelper.DebugLog("Current caller calling is '" + profile.callerName + "'.");
				return false;
			}
		}

		[CanBeNull]
		private static Caller GetConsequenceCaller(CallerProfile profileToCheck, ref Caller[] callers)
		{
			Caller[] array = callers;
			foreach (Caller val in array)
			{
				if ((Object)(object)profileToCheck == (Object)(object)val.callerProfile)
				{
					return val;
				}
			}
			return null;
		}
	}
}
namespace NewSafetyHelp.Callers.Answer
{
	public static class ProvidingAnswer
	{
		[HarmonyPatch(typeof(CallerController), "CheckCallerAnswer", new Type[] { typeof(MonsterProfile) })]
		public static class ReplaceAnswerWithReplacedAnswer
		{
			private static readonly FieldInfo DynamicCaller = typeof(CallerController).GetField("dynamicCaller", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo TriggerXmasLight = typeof(CallerController).GetMethod("TriggerXmasLight", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(CallerController __instance, ref MonsterProfile monsterID)
			{
				if (DynamicCaller == null)
				{
					LoggingHelper.ReflectionError("DynamicCaller");
					return true;
				}
				if ((Object)(object)monsterID != (Object)null)
				{
					__instance.callersToday++;
					bool flag = false;
					MonsterProfile val = null;
					foreach (EntryMetadata entriesMetadatum in GlobalParsingVariables.EntriesMetadata)
					{
						if (entriesMetadatum.CurrentlySelected)
						{
							entriesMetadatum.CurrentlySelected = false;
							val = entriesMetadatum.ReferenceCopyEntry;
							flag = true;
						}
					}
					if (!flag)
					{
						val = __instance.callers[__instance.currentCallerID].callerProfile.callerMonster;
						LoggingHelper.InfoLog("The caller monster was: " + __instance.callers[__instance.currentCallerID].callerProfile.callerMonster.monsterName + ".");
						LoggingHelper.DebugLog("The previous caller was not replaced by any custom caller.");
					}
					if ((Object)(object)monsterID == (Object)(object)val)
					{
						__instance.callers[__instance.currentCallerID].answeredCorrectly = true;
						__instance.correctCallsToday++;
						if (flag)
						{
							LoggingHelper.DebugLog("Selected the correct replaced entry.");
						}
					}
					else if (CustomCampaignGlobal.InCustomCampaign)
					{
						CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
						if (activeCustomCampaign == null)
						{
							__instance.callers[__instance.currentCallerID].answeredCorrectly = false;
							return false;
						}
						if (activeCustomCampaign.SkipCallersCorrectly)
						{
							__instance.callers[__instance.currentCallerID].answeredCorrectly = true;
							__instance.correctCallsToday++;
						}
						else
						{
							__instance.callers[__instance.currentCallerID].answeredCorrectly = false;
						}
					}
					else
					{
						__instance.callers[__instance.currentCallerID].answeredCorrectly = false;
						if (GlobalVariables.isXmasDLC)
						{
							if (TriggerXmasLight == null)
							{
								LoggingHelper.ReflectionError("TriggerXmasLight");
								return true;
							}
							TriggerXmasLight.Invoke(__instance, null);
							GlobalVariables.cheerMeterScript.UpdateMeterVisuals();
						}
						if (flag)
						{
							LoggingHelper.InfoLog("Selected the wrong replaced entry.");
						}
					}
				}
				else if (!(bool)DynamicCaller.GetValue(__instance))
				{
					if (!CustomCampaignGlobal.InCustomCampaign)
					{
						LoggingHelper.DebugLog("The current caller is a dynamic caller. No replacement effects will happen. The caller will also be marked as correct.");
						__instance.callers[__instance.currentCallerID].answeredCorrectly = true;
					}
					else
					{
						CustomCampaign activeCustomCampaign2 = CustomCampaignGlobal.GetActiveCustomCampaign();
						if (activeCustomCampaign2 == null)
						{
							LoggingHelper.CampaignNullError();
							__instance.callers[__instance.currentCallerID].answeredCorrectly = false;
							return false;
						}
						CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(GlobalVariables.callerControllerScript.currentCallerID);
						if (customCallerFromActiveCampaign != null && customCallerFromActiveCampaign.IsTimedCaller)
						{
							__instance.callers[__instance.currentCallerID].answeredCorrectly = false;
							__instance.callersToday++;
						}
						else
						{
							__instance.callers[__instance.currentCallerID].answeredCorrectly = true;
						}
					}
				}
				DynamicCaller.SetValue(__instance, false);
				return false;
			}
		}

		[HarmonyPatch(typeof(CallerController), "SubmitAnswer", new Type[] { typeof(MonsterProfile) })]
		public static class SubmitAnswerPatch
		{
			private static readonly FieldInfo OnCallConcluded = typeof(CallerController).GetField("OnCallConcluded", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo NewCallRoutine = typeof(CallerController).GetMethod("NewCallRoutine", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly FieldInfo LastDayNum = typeof(CallerController).GetField("lastDayNum", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);

			private static readonly MethodInfo CheckCallerAnswer = typeof(CallerController).GetMethod("CheckCallerAnswer", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly FieldInfo CallerAudioSource = typeof(CallerController).GetField("callerAudioSource", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly FieldInfo TriggerGameOver = typeof(CallerController).GetField("triggerGameOver", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo ColorLifeImages = typeof(CallerController).GetMethod("ColorLifeImages", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo CameraShake = typeof(CallerController).GetMethod("CameraShake", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static readonly MethodInfo ArcadeFailureRoutine = typeof(CallerController).GetMethod("ArcadeFailureRoutine", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(CallerController __instance, ref MonsterProfile monsterID)
			{
				//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Expected O, but got Unknown
				LoggingHelper.DebugLog("SubmitAnswer called.", LoggingHelper.LoggingCategory.SKIPPED_CALLER);
				if (OnCallConcluded == null)
				{
					LoggingHelper.ReflectionError("OnCallConcluded");
					return true;
				}
				Delegate obj = (Delegate)OnCallConcluded.GetValue(null);
				if ((object)obj != null)
				{
					obj.DynamicInvoke();
				}
				else
				{
					LoggingHelper.DebugLog("OnCallConcluded has no subscribers unable of executing. Will skip executing OnCallConcluded.");
				}
				if (NewCallRoutine == null)
				{
					LoggingHelper.ReflectionError("NewCallRoutine");
					return true;
				}
				IEnumerator enumerator = (IEnumerator)NewCallRoutine.Invoke(__instance, new object[2] { 5f, 10f });
				IEnumerator enumerator2 = (IEnumerator)NewCallRoutine.Invoke(__instance, new object[2] { 5f, 30f });
				GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.disconnect, (AudioSource)null);
				if (CallerAudioSource == null)
				{
					LoggingHelper.ReflectionError("CallerAudioSource");
					return true;
				}
				if (TriggerGameOver == null)
				{
					LoggingHelper.ReflectionError("TriggerGameOver");
					return true;
				}
				AudioSource val = (AudioSource)CallerAudioSource.GetValue(__instance);
				val.Stop();
				if (__instance.arcadeMode)
				{
					CallerController obj2 = __instance;
					obj2.currentArcadeCallTotal++;
					if (__instance.callTimer > __instance.callTimerMinimum)
					{
						CallerController obj3 = __instance;
						obj3.callTimer -= 5;
					}
					if ((Object)(object)monsterID == (Object)(object)__instance.currentCustomCaller.callerMonster)
					{
						__instance.CreateCustomCaller();
						((MonoBehaviour)__instance).StartCoroutine(enumerator);
						GlobalVariables.mainCanvasScript.NoCallerWindow();
						CallerController obj4 = __instance;
						obj4.currentArcadeCombo++;
						float num = __instance.currentArcadeCombo;
						if ((double)num > 10.0)
						{
							num = 10f;
						}
						CallerController obj5 = __instance;
						obj5.playerScore += __instance.pointsPerCall * num;
						if (__instance.currentArcadeCombo <= __instance.highestArcadeCombo)
						{
							return false;
						}
						__instance.highestArcadeCombo = __instance.currentArcadeCombo;
					}
					else
					{
						__instance.currentArcadeCombo = 0;
						__instance.CreateCustomCaller();
						GlobalVariables.mainCanvasScript.NoCallerWindow();
						CallerController obj6 = __instance;
						obj6.currentStrikes++;
						if (ColorLifeImages == null || CameraShake == null || ArcadeFailureRoutine == null)
						{
							LoggingHelper.ReflectionError("ColorLifeImages", "CameraShake", "ArcadeFailureRoutine");
							return true;
						}
						ColorLifeImages.Invoke(__instance, null);
						IEnumerator enumerator3 = (IEnumerator)CameraShake.Invoke(__instance, new object[1] { 0.25f });
						if (enumerator3 != null)
						{
							((MonoBehaviour)__instance).StartCoroutine(enumerator3);
						}
						if (__instance.currentStrikes >= __instance.strikesToFailure)
						{
							IEnumerator enumerator4 = (IEnumerator)ArcadeFailureRoutine.Invoke(__instance, null);
							((MonoBehaviour)__instance).StartCoroutine(enumerator4);
						}
						else
						{
							((MonoBehaviour)__instance).StartCoroutine(enumerator);
						}
					}
				}
				else if ((bool)TriggerGameOver.GetValue(__instance))
				{
					GlobalVariables.mainCanvasScript.PlayGameOverCutscene();
				}
				else
				{
					if (CheckCallerAnswer == null)
					{
						LoggingHelper.ReflectionError("CheckCallerAnswer");
						return true;
					}
					CheckCallerAnswer.Invoke(__instance, new object[1] { monsterID });
					LoggingHelper.DebugLog(() => $"Was correct? '{__instance.callers[__instance.currentCallerID].answeredCorrectly}'.");
					LoggingHelper.DebugLog(() => "Increase tier? (For: " + __instance.callers[__instance.currentCallerID].callerProfile.callerName + ") " + $"{__instance.callers[__instance.currentCallerID].callerProfile.increaseTier}");
					if (__instance.callers[__instance.currentCallerID].callerProfile.increaseTier)
					{
						__instance.IncreaseTier();
					}
					if (__instance.IsLastCallOfDay())
					{
						if (!GlobalVariables.isXmasDLC && !__instance.ScoreIsPassing(__instance.gameOverThreshold) && GlobalVariables.currentDay > 1 && GlobalVariables.saveManagerScript.savedImmunityToggle == 0)
						{
							bool flag = true;
							if (CustomCampaignGlobal.InCustomCampaign)
							{
								CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
								if (activeCustomCampaign == null)
								{
									return true;
								}
								if (activeCustomCampaign.GameOverImmunity)
								{
									flag = false;
								}
							}
							if (flag)
							{
								((MonoBehaviour)__instance).StartCoroutine(enumerator2);
								GlobalVariables.mainCanvasScript.NoCallerWindow();
								return false;
							}
						}
						if (GlobalVariables.isXmasDLC && (double)GlobalVariables.cheerMeterScript.scoreDisplay * 100.0 <= (double)__instance.xmasGameOverThreshold && GlobalVariables.saveManagerScript.savedImmunityToggle == 0)
						{
							((MonoBehaviour)__instance).StartCoroutine(enumerator2);
							GlobalVariables.mainCanvasScript.NoCallerWindow();
							return false;
						}
						if (LastDayNum == null)
						{
							LoggingHelper.ReflectionError("LastDayNum");
							return true;
						}
						if (GlobalVariables.currentDay < (int)LastDayNum.GetValue(__instance))
						{
							((MonoBehaviour)GlobalVariables.mainCanvasScript).StartCoroutine(GlobalVariables.mainCanvasScript.EndDayRoutine());
							GlobalVariables.mainCanvasScript.NoCallerWindow();
							return false;
						}
					}
					if (CustomCampaignGlobal.InCustomCampaign && !GlobalVariables.arcadeMode)
					{
						int num2 = CallerSkipping.CheckIfAnyValidCallerLeft(GlobalVariables.callerControllerScript);
						if (num2 > 0)
						{
							LoggingHelper.DebugLog("Calling end day routine from submit answer.");
							MelonCoroutines.Start(IntermissionMusicHelper.StopIntermissionMusic());
							for (int num3 = 1; num3 < num2 + 1; num3++)
							{
								int num4 = __instance.currentCallerID + num3;
								if (num4 < __instance.callers.Length)
								{
									__instance.callers[num4].answeredCorrectly = true;
								}
							}
							CallerController callerControllerScript = GlobalVariables.callerControllerScript;
							callerControllerScript.currentCallerID += num2;
							((MonoBehaviour)GlobalVariables.mainCanvasScript).StartCoroutine(GlobalVariables.mainCanvasScript.EndDayRoutine());
							GlobalVariables.mainCanvasScript.NoCallerWindow();
							return false;
						}
						CustomCampaign activeCustomCampaign2 = CustomCampaignGlobal.GetActiveCustomCampaign();
						if (activeCustomCampaign2 == null)
						{
							return true;
						}
						if ((Object)(object)monsterID == (Object)null && activeCustomCampaign2.CustomIntermissionMusic.Count >= 0)
						{
							IntermissionMusicHelper.PlayIntermissionMusic();
						}
					}
					if (__instance.currentCallerID + 1 < __instance.callers.Length)
					{
						((MonoBehaviour)__instance).StartCoroutine(enumerator2);
						GlobalVariables.mainCanvasScript.NoCallerWindow();
					}
					if (GlobalVariables.isXmasDLC && __instance.currentCallerID == __instance.callers.Length - 4)
					{
						GlobalVariables.mainCanvasScript.cameraAnimator.SetBool(XmasTension, true);
					}
					else
					{
						GlobalVariables.mainCanvasScript.cameraAnimator.SetBool(XmasTension, false);
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(SubmitWindowBehavior), "SubmitRoutine")]
		public static class SubmitRoutinePatch
		{
			private static bool Prefix(SubmitWindowBehavior __instance, ref IEnumerator __result)
			{
				__result = SubmitRoutine(__instance);
				return false;
			}

			private static IEnumerator SubmitRoutine(SubmitWindowBehavior __instance)
			{
				bool permissionError = false;
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					TimerCallerHelper.StopTimedCallerTimer();
					TimerCallerHelper.HideCallerTimerUI();
				}
				if ((Object)(object)__instance.answerToSubmit == (Object)null)
				{
					GlobalVariables.mainCanvasScript.CreateError("ERROR: INSUFFICIENT PERMISSIONS.");
					permissionError = true;
				}
				else
				{
					__instance.submitButton.SetActive(false);
					__instance.loadingText.SetActive(true);
					if (GlobalVariables.arcadeMode)
					{
						((MonoBehaviour)GlobalVariables.callerControllerScript).StopCoroutine(GlobalVariables.callerControllerScript.callTimerRoutine);
					}
					yield return (object)new WaitForSeconds((float)Random.Range(4, 6));
					GlobalVariables.callerControllerScript.SubmitAnswer(__instance.answerToSubmit);
					if (!GlobalVariables.arcadeMode)
					{
						GlobalVariables.mainCanvasScript.CreateError("INFO SUCCESSFULLY SENT TO CLIENT. GOOD JOB!");
					}
					GlobalVariables.UISoundControllerScript.PlayUISound(GlobalVariables.UISoundControllerScript.correctSound, (AudioSource)null);
					GlobalVariables.musicControllerScript.StopMusic();
					GlobalVariables.UISoundControllerScript.StopUISoundLooping();
					__instance.submitButton.SetActive(true);
					__instance.loadingText.SetActive(false);
					((Component)__instance).gameObject.SetActive(false);
				}
				if (CustomCampaignGlobal.InCustomCampaign && !permissionError)
				{
					CustomCampaign customCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (customCampaign != null && customCampaign.CustomIntermissionMusic.Count >= 0)
					{
						IntermissionMusicHelper.PlayIntermissionMusic();
					}
				}
			}
		}

		private static readonly int XmasTension = Animator.StringToHash("xmasTension");
	}
}
namespace NewSafetyHelp.Audio
{
	public static class AudioCache
	{
		private static readonly Dictionary<string, AudioClip> audioCache = new Dictionary<string, AudioClip>();

		[CanBeNull]
		public static AudioClip TryGet(string audioFullPath, bool getRecentlyAddedAudio)
		{
			if (audioCache.TryGetValue(audioFullPath, out var value))
			{
				if (!getRecentlyAddedAudio)
				{
					LoggingHelper.DebugLog("Using audio cache for audio '" + audioFullPath + "'.", LoggingHelper.LoggingCategory.MEMORY);
				}
				return value;
			}
			return null;
		}

		public static void AddCache(string audioFullPath, AudioClip audio)
		{
			audioCache[audioFullPath] = audio;
		}

		public static void RemoveEntireCache()
		{
			foreach (AudioClip value in audioCache.Values)
			{
				Object.Destroy((Object)(object)value);
			}
			audioCache.Clear();
		}
	}
	public static class AudioImport
	{
		public static readonly List<string> CurrentLoadingAudios = new List<string>();

		private static readonly MethodInfo StartCallerController = typeof(CallerController).GetMethod("Start", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		public static void LoadEmbeddedAudio(Action<AudioClip> callback, string fileName, AudioType audioType = (AudioType)20)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			string audioPath = EmbedHelpers.ExtractEmbeddedResourceToTempFile(fileName);
			MelonCoroutines.Start(UpdateAudioClip(callback, audioPath, audioType));
		}

		public static IEnumerator UpdateAudioClip(Action<AudioClip> callback, string audioPath, AudioType audioType = (AudioType)20)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			AudioClip soundClip = null;
			if ((int)audioType > 0)
			{
				audioType = GetAudioType(audioPath);
				yield return MelonCoroutines.Start(LoadAudio(delegate(AudioClip myReturnValue)
				{
					soundClip = myReturnValue;
				}, audioPath, audioType));
			}
			callback(soundClip);
		}

		private unsafe static IEnumerator LoadAudio(Action<AudioClip> callback, string path, AudioType audioType = (AudioType)13)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (File.Exists(path))
			{
				long audioFileSize = new FileInfo(path).Length;
				if (CurrentLoadingAudios.Contains(path + ((object)(*(AudioType*)(&audioType))/*cast due to .constrained prefix*/).ToString()))
				{
					while (CurrentLoadingAudios.Contains(path + ((object)(*(AudioType*)(&audioType))/*cast due to .constrained prefix*/).ToString()))
					{
						yield return (object)new WaitForSecondsRealtime(Random.Range(0.1f, 0.7f));
					}
				}
				else
				{
					CurrentLoadingAudios.Add(path + ((object)(*(AudioType*)(&audioType))/*cast due to .constrained prefix*/).ToString());
				}
				bool fromHotReload = ReloadJSONParsing.IsInHotReload;
				LoggingHelper.DebugLog($"Current allocated memory (audio is waiting for slot): Allocated: '{Profiler.GetTotalAllocatedMemoryLong()}'; Reserved: {Profiler.GetTotalReservedMemoryLong()}' " + $"(File size '{audioFileSize}').", LoggingHelper.LoggingCategory.MEMORY);
				AudioClip cachedAudio = AudioCache.TryGet(path, getRecentlyAddedAudio: false);
				if ((Object)(object)cachedAudio != (Object)null)
				{
					callback(cachedAudio);
					finishAudioImport(path, audioType, audioFileSize, fromHotReload);
					yield break;
				}
				yield return AudioLoadThrottler.WaitForSlot(fromHotReload, audioFileSize);
				LoggingHelper.InfoLog("Attempting to add " + path + " as audio type " + ((object)(*(AudioType*)(&audioType))/*cast due to .constrained prefix*/).ToString() + ".");
				Time.timeScale = 0f;
				string url = "file://" + path;
				UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(url, audioType);
				try
				{
					UnityWebRequestAsyncOperation operation = www.SendWebRequest();
					while (!((AsyncOperation)operation).isDone)
					{
						yield return null;
					}
					if ((int)www.result == 1 && ((AsyncOperation)operation).isDone)
					{
						LoggingHelper.InfoLog(path + " as " + ((object)(*(AudioType*)(&audioType))/*cast due to .constrained prefix*/).ToString() + " has been successfully loaded.");
						AudioClip loadedClip = DownloadHandlerAudioClip.GetContent(www);
						AudioCache.AddCache(path, loadedClip);
						callback(loadedClip);
					}
					else
					{
						if (!((AsyncOperation)operation).isDone)
						{
							LoggingHelper.ErrorLog("Audio Loading was not finished. This an an unexpected error.");
						}
						LoggingHelper.ErrorLog("Was unable of loading " + path + " as audio type " + ((object)(*(AudioType*)(&audioType))/*cast due to .constrained prefix*/).ToString() + "." + $" \n Results in the error: {www.error} and the response code is: {www.responseCode}." + $" Was the process finished?: {www.isDone}");
					}
					finishAudioImport(path, audioType, audioFileSize, fromHotReload);
				}
				finally
				{
					((IDisposable)www)?.Dispose();
				}
			}
			else
			{
				LoggingHelper.ErrorLog("Given path to file " + path + " of type " + ((object)(*(AudioType*)(&audioType))/*cast due to .constrained prefix*/).ToString() + " does not exist.");
				CurrentLoadingAudios.Remove(path + ((object)(*(AudioType*)(&audioType))/*cast due to .constrained prefix*/).ToString());
				if (CurrentLoadingAudios.Count <= 0)
				{
					Time.timeScale = 1f;
				}
			}
		}

		private unsafe static void finishAudioImport(string path, AudioType audioType, long audioFileSize, bool fromHotReload)
		{
			CurrentLoadingAudios.Remove(path + ((object)(*(AudioType*)(&audioType))/*cast due to .constrained prefix*/).ToString());
			LoggingHelper.DebugLog($"CACHE: Current allocated memory (audio finished loading in): Allocated: '{Profiler.GetTotalAllocatedMemoryLong()}'; Reserved: {Profiler.GetTotalReservedMemoryLong()}' " + $"(File size '{audioFileSize}').", LoggingHelper.LoggingCategory.MEMORY);
			AudioLoadThrottler.ReleaseSlot(fromHotReload);
			if (CurrentLoadingAudios.Count <= 0)
			{
				Time.timeScale = 1f;
			}
		}

		public static void ReCallCallerListStart()
		{
			if (StartCallerController == null)
			{
				LoggingHelper.ReflectionError("StartCallerController");
				return;
			}
			GameObject val = GameObject.Find("CallerController");
			if ((Object)(object)val != (Object)null)
			{
				CallerController component = val.GetComponent<CallerController>();
				StartCallerController.Invoke(component, null);
			}
		}

		public static RichAudioClip CreateRichAudioClip(AudioClip newAudioClip, float volume = 0.5f)
		{
			RichAudioClip val = ScriptableObject.CreateInstance<RichAudioClip>();
			val.clip = newAudioClip;
			val.volume = volume;
			return val;
		}

		public static AudioType GetAudioType(string fileName)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			if (fileName.ToLower().EndsWith(".wav"))
			{
				return (AudioType)20;
			}
			if (fileName.ToLower().EndsWith(".ogg") || fileName.ToLower().EndsWith(".oga") || fileName.ToLower().EndsWith(".flac") || fileName.ToLower().EndsWith(".opus"))
			{
				return (AudioType)14;
			}
			if (fileName.ToLower().EndsWith(".acc") || fileName.ToLower().EndsWith(".aac") || fileName.ToLower().EndsWith(".m4a") || fileName.ToLower().EndsWith(".mp4"))
			{
				return (AudioType)1;
			}
			if (fileName.ToLower().EndsWith(".aiff") || fileName.ToLower().EndsWith(".aif") || fileName.ToLower().EndsWith(".aifc"))
			{
				return (AudioType)2;
			}
			if (fileName.ToLower().EndsWith(".it"))
			{
				return (AudioType)10;
			}
			if (fileName.ToLower().EndsWith(".mod"))
			{
				return (AudioType)12;
			}
			if (fileName.ToLower().EndsWith(".mp2") || fileName.ToLower().EndsWith(".mp3") || fileName.ToLower().EndsWith(".wma"))
			{
				return (AudioType)13;
			}
			if (fileName.ToLower().EndsWith(".s3m"))
			{
				return (AudioType)17;
			}
			if (fileName.ToLower().EndsWith(".xm"))
			{
				return (AudioType)21;
			}
			if (fileName.ToLower().EndsWith(".vag"))
			{
				return (AudioType)23;
			}
			if (fileName.ToLower().EndsWith(".alac"))
			{
				return (AudioType)24;
			}
			if (fileName.ToLower().EndsWith(".xma"))
			{
				return (AudioType)22;
			}
			LoggingHelper.ErrorLog("Unknown audio file type, attempting to still parse it. Expect failure.");
			return (AudioType)0;
		}
	}
	public static class AudioLoadThrottler
	{
		private static int activeLoadCount;

		private const int MaxConcurrentLoads = 5;

		private const long MemoryPressureThreshold = 2000000000L;

		public static IEnumerator WaitForSlot(bool isHotReload, long audioFileSize)
		{
			if (!isHotReload)
			{
				yield break;
			}
			while (activeLoadCount >= 5)
			{
				yield return null;
			}
			long allocatedMemory = Profiler.GetTotalReservedMemoryLong();
			int blockedTimes = 0;
			while (allocatedMemory > 2000000000 || audioFileSize + allocatedMemory > 2000000000)
			{
				yield return (object)new WaitForSecondsRealtime(Random.Range(0.1f, 0.7f));
				allocatedMemory = Profiler.GetTotalReservedMemoryLong();
				if (blockedTimes >= 5)
				{
					break;
				}
				blockedTimes++;
			}
			Interlocked.Increment(ref activeLoadCount);
		}

		public static void ReleaseSlot(bool fromHotReload)
		{
			if (fromHotReload)
			{
				Interlocked.Decrement(ref activeLoadCount);
			}
		}
	}
	public static class EmbeddedTimerData
	{
		[CanBeNull]
		public static RichAudioClip ClockFivePercent;

		[CanBeNull]
		public static RichAudioClip ClockHalfTime;

		[CanBeNull]
		public static RichAudioClip ClockStart;

		[CanBeNull]
		public static Sprite ClockBase;

		[CanBeNull]
		public static Sprite ClockHand;

		public static void Initialize()
		{
			AudioImport.LoadEmbeddedAudio(delegate(AudioClip audioClip)
			{
				if ((Object)(object)audioClip != (Object)null)
				{
					ClockFivePercent = AudioImport.CreateRichAudioClip(audioClip);
				}
				else
				{
					LoggingHelper.ErrorLog("Failed to load embedded 'ClockFivePercent' audio clip.");
				}
			}, "clock_10_percent.wav", (AudioType)20);
			AudioImport.LoadEmbeddedAudio(delegate(AudioClip audioClip)
			{
				if ((Object)(object)audioClip != (Object)null)
				{
					ClockHalfTime = AudioImport.CreateRichAudioClip(audioClip);
				}
				else
				{
					LoggingHelper.ErrorLog("Failed to load embedded 'ClockHalfTime' audio clip.");
				}
			}, "clock_half_time.wav", (AudioType)20);
			AudioImport.LoadEmbeddedAudio(delegate(AudioClip audioClip)
			{
				if ((Object)(object)audioClip != (Object)null)
				{
					ClockStart = AudioImport.CreateRichAudioClip(audioClip);
				}
				else
				{
					LoggingHelper.ErrorLog("Failed to load embedded 'ClockStart' audio clip.");
				}
			}, "clock_start.wav", (AudioType)20);
			ClockBase = ImageImport.LoadEmbeddedImage("clock_base.png");
			ClockHand = ImageImport.LoadEmbeddedImage("clock_hand.png");
			LoggingHelper.DebugLog("Finished the starting of the embed loading coroutines.");
		}
	}
}
namespace NewSafetyHelp.Audio.Music
{
	public static class MusicControllerPatches
	{
		[HarmonyPatch(typeof(MusicController), "StartRandomMusic")]
		public static class StartRandomMusicPatch
		{
			private static readonly FieldInfo PreviousHoldMusicIndex = typeof(MusicController).GetField("previousHoldMusicIndex", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

			private static bool Prefix(MusicController __instance)
			{
				if (!CustomCampaignGlobal.InCustomCampaign && GlobalVariables.currentDay == 7 && !GlobalVariables.arcadeMode)
				{
					return false;
				}
				int num = 0;
				bool flag = false;
				if (PreviousHoldMusicIndex == null)
				{
					LoggingHelper.ErrorLog("PreviousHoldMusicIndex is null. Unable of replacing MusicController StartNewRandomMusic. Calling original function.");
					return true;
				}
				List<CustomMusic> list = new List<CustomMusic>();
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					if (GlobalVariables.currentDay > 4)
					{
						int num2 = 0;
						while (num == (int)PreviousHoldMusicIndex.GetValue(__instance) && num2 < 3)
						{
							num = Random.Range(0, __instance.onHoldMusicClips.Length);
							num2++;
						}
						PreviousHoldMusicIndex.SetValue(__instance, num);
					}
					else
					{
						int num3 = 0;
						while (num == (int)PreviousHoldMusicIndex.GetValue(__instance) && num3 < 3)
						{
							num = Random.Range(0, GlobalVariables.currentDay);
							num3++;
						}
						PreviousHoldMusicIndex.SetValue(__instance, num);
					}
				}
				else
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						return true;
					}
					list = activeCustomCampaign.CustomMusic.Where((CustomMusic clip) => clip.OnlyPlayOnUnlockDay ? ((clip.UnlockDay <= 0) ? (1 == GlobalVariables.currentDay) : (clip.UnlockDay == GlobalVariables.currentDay)) : (clip.UnlockDay <= GlobalVariables.currentDay)).ToList();
					int count = list.Count;
					if (activeCustomCampaign.AlwaysRandomMusic || GlobalVariables.currentDay > 4)
					{
						int num4 = 0;
						if (!activeCustomCampaign.RemoveDefaultMusic)
						{
							num4 += __instance.onHoldMusicClips.Length;
						}
						if (activeCustomCampaign.CustomMusic.Count > 0)
						{
							num4 += count;
						}
						num = Random.Range(0, num4);
						int num5 = 0;
						while (num == (int)PreviousHoldMusicIndex.GetValue(__instance) && num5 < 3)
						{
							num = Random.Range(0, num4);
							num5++;
						}
						if (!activeCustomCampaign.RemoveDefaultMusic)
						{
							if (num >= __instance.onHoldMusicClips.Length)
							{
								flag = true;
								num -= __instance.onHoldMusicClips.Length;
							}
						}
						else
						{
							flag = true;
						}
						LoggingHelper.DebugLog($"Chose to play the music track: {num} with the previous being {(int)PreviousHoldMusicIndex.GetValue(__instance)}." + $" (From custom music? {flag})" + $" (Amount of clips: {num4})" + $" (Total clips: {activeCustomCampaign.CustomMusic.Count})" + $" (Remove default music? {activeCustomCampaign.RemoveDefaultMusic})" + $" (Current day: {GlobalVariables.currentDay})");
						if (flag)
						{
							LoggingHelper.DebugLog($"Amount of custom music: {count}.");
						}
						PreviousHoldMusicIndex.SetValue(__instance, num);
					}
					else
					{
						int num6 = 0;
						if (!activeCustomCampaign.RemoveDefaultMusic)
						{
							num6 += __instance.onHoldMusicClips.Length;
						}
						if (activeCustomCampaign.CustomMusic.Count > 0)
						{
							num6 += count;
						}
						if (activeCustomCampaign.RemoveDefaultMusic)
						{
							flag = true;
							int num7 = 0;
							while (num == (int)PreviousHoldMusicIndex.GetValue(__instance) && num7 < 3)
							{
								num = Random.Range(0, num6);
								num7++;
							}
						}
						else if (!activeCustomCampaign.RemoveDefaultMusic && count > 0)
						{
							switch (Random.Range(0, 2))
							{
							case 0:
							{
								int num9 = 0;
								while (num == (int)PreviousHoldMusicIndex.GetValue(__instance) && num9 < 3)
								{
									num = Random.Range(0, Mathf.Min(GlobalVariables.currentDay, 7));
									num9++;
								}
								break;
							}
							case 1:
							{
								flag = true;
								int num8 = 0;
								while (num == (int)PreviousHoldMusicIndex.GetValue(__instance) && num8 < 3)
								{
									num = Random.Range(0, num6);
									num8++;
								}
								break;
							}
							}
						}
						else if (!activeCustomCampaign.RemoveDefaultMusic && count <= 0)
						{
							int num10 = 0;
							while (num == (int)PreviousHoldMusicIndex.GetValue(__instance) && num10 < 3)
							{
								num = Random.Range(0, Mathf.Min(GlobalVariables.currentDay, 7));
								num10++;
							}
						}
						PreviousHoldMusicIndex.SetValue(__instance, num);
					}
				}
				if (!CustomCampaignGlobal.InCustomCampaign)
				{
					if (GlobalVariables.musicControllerScript.onHoldMusicClips.Length >= num)
					{
						__instance.StartMusic(GlobalVariables.musicControllerScript.onHoldMusicClips[num]);
					}
				}
				else
				{
					CustomCampaign activeCustomCampaign2 = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign2 == null)
					{
						return true;
					}
					if (flag)
					{
						if (list.Count > 0 && num < list.Count && (Object)(object)list[num].MusicClip != (Object)null)
						{
							__instance.StartMusic(list[num].MusicClip);
						}
						else
						{
							LoggingHelper.WarningLog("Music clip is empty! Possibly failed loading?");
						}
					}
					else if (!activeCustomCampaign2.RemoveDefaultMusic && GlobalVariables.musicControllerScript.onHoldMusicClips.Length >= num)
					{
						__instance.StartMusic(GlobalVariables.musicControllerScript.onHoldMusicClips[num]);
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(MusicController), "StartMusic", new Type[] { typeof(RichAudioClip) })]
		public static class StartMusicPatch
		{
			private static bool Prefix(MusicController __instance, ref RichAudioClip myMusicClip)
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				FieldInfo field = typeof(MusicController).GetField("myMusicSource", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null)
				{
					LoggingHelper.ErrorLog("'myMusicSource' was not found. Unable of changing StartMusic. Calling original function.");
					return true;
				}
				AudioSource val = (AudioSource)field.GetValue(__instance);
				if ((Object)(object)val == (Object)null)
				{
					LoggingHelper.ErrorLog("'myMusicSource' could not be cast. Unable of changing StartMusic. Calling original function.");
					return true;
				}
				val.pitch = 1f;
				val.clip = myMusicClip.clip;
				val.volume = myMusicClip.volume;
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
					if (activeCustomCampaign == null)
					{
						LoggingHelper.ErrorLog("Custom Campaign is null. Unable of changing StartMusic. Calling original.");
						return true;
					}
					CustomCCaller customCallerFromActiveCampaign = CustomCampaignGlobal.GetCustomCallerFromActiveCampaign(GlobalVariables.callerControllerScript.currentCallerID);
					if (customCallerFromActiveCampaign != null && customCallerFromActiveCampaign.DownedNetworkCaller)
					{
						val.pitch = 0.8f;
					}
					CustomMusic customMusicFromActiveCampaign = CustomCampaignGlobal.GetCustomMusicFromActiveCampaign(myMusicClip);
					if (customMusicFromActiveCampaign != null && !customMusicFromActiveCampaign.IsIntermissionMusic && customMusicFromActiveCampaign.StartRange != null && customMusicFromActiveCampaign.StartRange.Count > 0)
					{
						float? randomFromList = RandomFromList.GetRandomFromList(customMusicFromActiveCampaign.StartRange);
						if (randomFromList.HasValue)
						{
							val.time = randomFromList.Value;
							LoggingHelper.DebugLog($"Chosen starting music offset of: '{randomFromList}'.");
						}
						else
						{
							val.time = 0f;
						}
					}
					else
					{
						val.time = 0f;
					}
				}
				else
				{
					int[] downedNetworkCalls = GlobalVariables.callerControllerScript.downedNetworkCalls;
					foreach (int num in downedNetworkCalls)
					{
						if (num == GlobalVariables.callerControllerScript.currentCallerID)
						{
							val.pitch = 0.8f;
						}
					}
					if ((Object)(object)myMusicClip != (Object)(object)__instance.onHoldMusicClips[1])
					{
						val.time = 0f;
					}
					else
					{
						val.time = 19.6f;
					}
				}
				currentMusicClip = myMusicClip;
				val.Play();
				return false;
			}
		}

		[HarmonyPatch(typeof(MusicController), "TurnDownHoldMusicWhileHazardProfileSampleIsPlayingRoutine")]
		public static class TurnDownHoldMusicWhileHazardProfileSampleIsPlayingRoutinePatch
		{
			private static bool Prefix(MusicController __instance, ref IEnumerator __result)
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				FieldInfo field = typeof(MusicController).GetField("myMusicSource", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null)
				{
					LoggingHelper.ErrorLog("'myMusicSource' was not found. Unable of changing StartMusic. Calling original function.");
					return true;
				}
				AudioSource val = (AudioSource)field.GetValue(__instance);
				if ((Object)(object)val == (Object)null)
				{
					LoggingHelper.ErrorLog("'myMusicSource' could not be cast. Unable of changing StartMusic. Calling original function.");
					return true;
				}
				__result = TurnDownMusicIfEntryIsPlaying(val);
				return false;
			}

			private static IEnumerator TurnDownMusicIfEntryIsPlaying(AudioSource myMusicSourceCast)
			{
				if (myMusicSourceCast.isPlaying)
				{
					myMusicSourceCast.volume = 0.02f;
					while (GlobalVariables.UISoundControllerScript.myMonsterSampleAudioSource.isPlaying)
					{
						yield return (object)new WaitForSeconds(0.1f);
					}
					if ((Object)(object)currentMusicClip != (Object)null)
					{
						myMusicSourceCast.volume = currentMusicClip.volume;
					}
				}
			}
		}

		private static RichAudioClip currentMusicClip;
	}
}
namespace NewSafetyHelp.Audio.Music.Intermission
{
	public static class IntermissionMusicHelper
	{
		private static bool shouldPlayIntermissionMusic = true;

		private static object playIntermission;

		private static bool alreadyStoppingIntermissionMusic;

		private static readonly FieldInfo MyMusicSource = typeof(MusicController).GetField("myMusicSource", BindingFlags.Instance | BindingFlags.NonPublic);

		public static void PlayIntermissionMusic(CustomMusic audioClip = null)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			if (MyMusicSource == null)
			{
				LoggingHelper.ErrorLog("'myMusicSource' was not found. Unable of changing StartMusic.");
				return;
			}
			AudioSource val = (AudioSource)MyMusicSource.GetValue(GlobalVariables.musicControllerScript);
			if ((Object)(object)val == (Object)null)
			{
				LoggingHelper.ErrorLog("'myMusicSource' could not be cast. Unable of changing StartMusic.");
				return;
			}
			CustomCampaign activeCustomCampaign = CustomCampaignGlobal.GetActiveCustomCampaign();
			if (activeCustomCampaign == null)
			{
				LoggingHelper.CampaignNullError();
			}
			else if (activeCustomCampaign.CustomIntermissionMusic.Count > 0)
			{
				val.pitch = 1f;
				shouldPlayIntermissionMusic = true;
				alreadyStoppingIntermissionMusic = false;
				playIntermission = MelonCoroutines.Start(PlayIntermissionMusicLoop(val, audioClip, activeCustomCampaign));
			}
		}

		public static void StopIntermissionMusicRoutine()
		{
			LoggingHelper.DebugLog("Stopping the intermission music.");
			shouldPlayIntermissionMusic = false;
			alreadyStoppingIntermissionMusic = false;
			if (playIntermission != null)
			{
				MelonCoroutines.Stop(playIntermission);
			}
		}

		public static IEnumerator StopIntermissionMusic()
		{
			if (alreadyStoppingIntermissionMusic)
			{
				yield break;
			}
			alreadyStoppingIntermissionMusic = true;
			if (MyMusicSource == null)
			{
				LoggingHelper.CriticalErrorLog("'myMusicSource' was not found. Unable of changing StartMusic.");
				yield break;
			}
			AudioSource myMusicSourceCast = (AudioSource)MyMusicSource.GetValue(GlobalVariables.musicControllerScript);
			if ((Object)(object)myMusicSourceCast == (Object)null)
			{
				LoggingHelper.CriticalErrorLog("'myMusicSource' could not be cast. Unable of changing StartMusic.");
			}
			else if (playIntermission != null)
			{
				shouldPlayIntermissionMusic = false;
				MelonCoroutines.Stop(playIntermission);
				yield return FadeOutMusic(myMusicSourceCast);
				myMusicSourceCast.Stop();
				myMusicSourceCast.loop = true;
				myMusicSourceCast.volume = 1f;
				alreadyStoppingIntermissionMusic = false;
			}
		}

		private static IEnumerator PlayIntermissionMusicLoop(AudioSource myMusicSourceCast, CustomMusic audioClip, CustomCampaign customCampaign, bool shouldLoop = true)
		{
			bool wasProvidedNull = audioClip == null;
			bool shouldPlayIntermission = false;
			while (shouldPlayIntermissionMusic)
			{
				if (audioClip == null || wasProvidedNull)
				{
					audioClip = PickIntermissionMusic(ref shouldPlayIntermission, customCampaign);
					if (!shouldPlayIntermission)
					{
						break;
					}
				}
				myMusicSourceCast.volume = audioClip.MusicClip.volume;
				myMusicSourceCast.loop = false;
				float startAfterSeconds = MusicStartRange(audioClip);
				float musicStopAfterSeconds = MusicEndRange(audioClip);
				LoggingHelper.DebugLog($"Intermission music playing with start of: '{startAfterSeconds}' with" + $"end range of '{musicStopAfterSeconds}'.");
				if (musicStopAfterSeconds - startAfterSeconds <= 0f)
				{
					LoggingHelper.WarningLog("Provided music ranges overlap and cause the music not to play. Unable to play music.");
					break;
				}
				GlobalVariables.musicControllerScript.StartMusic(audioClip.MusicClip);
				myMusicSourceCast.time = startAfterSeconds;
				myMusicSourceCast.pitch = 1f;
				yield return (object)new WaitForSeconds(musicStopAfterSeconds - startAfterSeconds);
				yield return FadeOutMusic(myMusicSourceCast);
				myMusicSourceCast.Stop();
				myMusicSourceCast.loop = true;
				myMusicSourceCast.volume = 1f;
				if (!shouldLoop)
				{
					break;
				}
			}
		}

		private static float MusicEndRange(CustomMusic audioClip)
		{
			if (audioClip.EndRange == null)
			{
				return audioClip.MusicClip.clip.length;
			}
			if (audioClip.EndRange.Count <= 0)
			{
				return audioClip.MusicClip.clip.length;
			}
			switch (audioClip.EndRange.Count)
			{
			case 1:
				return audioClip.EndRange[0];
			case 2:
				return Random.Range(audioClip.EndRange[0], audioClip.EndRange[1]);
			default:
				if (audioClip.EndRange.Count > 2)
				{
					int index = Random.Range(0, audioClip.EndRange.Count);
					return audioClip.EndRange[index];
				}
				return audioClip.MusicClip.clip.length;
			}
		}

		private static float MusicStartRange(CustomMusic audioClip)
		{
			if (audioClip.StartRange == null)
			{
				return 0f;
			}
			if (audioClip.StartRange.Count <= 0)
			{
				return 0f;
			}
			switch (audioClip.StartRange.Count)
			{
			case 1:
				return audioClip.StartRange[0];
			case 2:
				return Random.Range(audioClip.StartRange[0], audioClip.StartRange[1]);
			default:
				if (audioClip.StartRange.Count > 2)
				{
					int index = Random.Range(0, audioClip.StartRange.Count);
					return audioClip.StartRange[index];
				}
				return 0f;
			}
		}

		private static CustomMusic PickIntermissionMusic(ref bool shouldPlayIntermission, CustomCampaign customCampaign)
		{
			shouldPlayIntermission = false;
			if (CustomCampaignGlobal.InCustomCampaign)
			{
				List<CustomMusic> list = customCampaign.CustomIntermissionMusic.Where((CustomMusic clip) => clip.OnlyPlayOnUnlockDay ? ((clip.UnlockDay <= 0) ? (1 == GlobalVariables.currentDay) : (clip.UnlockDay == GlobalVariables.currentDay)) : (clip.UnlockDay <= GlobalVariables.currentDay)).ToList();
				LoggingHelper.DebugLog($"Custom Intermission Music Available: {customCampaign.CustomIntermissionMusic.Count}." + $" Valid: '{list.Count}'.");
				if (list.Count <= 0)
				{
					return null;
				}
				shouldPlayIntermission = true;
				int index = Random.Range(0, list.Count);
				return list[index];
			}
			return null;
		}

		private static IEnumerator FadeOutMusic(AudioSource mySource, float interpolateScalar = 1f)
		{
			float interpolateValue = 0f;
			float maxVol = mySource.volume;
			while ((double)mySource.volume > 0.0)
			{
				mySource.volume = Mathf.Lerp(maxVol, 0f, interpolateValue);
				interpolateValue += interpolateScalar * Time.deltaTime;
				yield return null;
			}
			mySource.volume = 0f;
			mySource.Stop();
		}
	}
}
namespace NewSafetyHelp.Audio.Music.Data
{
	public class CustomMusic : CustomCampaignElementBase
	{
		public string MusicClipPath = "";

		public RichAudioClip MusicClip = null;

		public int UnlockDay = 0;

		public bool OnlyPlayOnUnlockDay = false;

		public bool IsIntermissionMusic = false;

		public List<float> StartRange = new List<float>();

		public List<float> EndRange = new List<float>();
	}
}
namespace NewSafetyHelp.Audio.AudioPatches
{
	public static class PlaySoundPatches
	{
		[HarmonyPatch(typeof(UISoundController), "PlayUISoundLooping", new Type[]
		{
			typeof(RichAudioClip),
			typeof(AudioSource)
		})]
		public static class PlayGlitchSoundPatch
		{
			private static bool Prefix(UISoundController __instance, ref RichAudioClip clip, ref AudioSource source)
			{
				if (CustomCampaignGlobal.InCustomCampaign)
				{
					(bool, VariableChanged<bool>) activeModifierValue = CustomCampaignGlobal.GetActiveModifierValue((CustomModifier c) => c.DisablePhoneStatic, (VariableChanged<bool> vCb) => vCb.HasChanged);
					if (activeModifierValue.Item1 && activeModifierValue.Item2.Data && (Object)(object)clip == (Object)(object)__instance.phoneStatic)
					{
						return false;
					}
				}
				if ((Object)(object)source != (Object)null)
				{
					source.clip = clip.clip;
					source.volume = clip.volume;
					source.Play();
				}
				else
				{
					__instance.myLoopingSource.clip = clip.clip;
					__instance.myLoopingSource.volume = clip.volume;
					__instance.myLoopingSource.Play();
				}
				return false;
			}
		}
	}
	public static class UISoundPatch
	{
		[HarmonyPatch(typeof(UISoundController), "Start")]
		public static class StartPatch
		{
			private static bool firstRun;

			public static RichAudioClip DefaultRingtone;

			public static RichAudioClip DefaultWarpedRingtone;

			private static void Postfix(UISoundController __instance)
			{
				if (!firstRun)
				{
					DefaultRingtone = __instance.phoneCall;
					DefaultWarpedRingtone = __instance.phoneCallWarped;
					firstRun = true;
				}
			}
		}

		[HarmonyPatch(typeof(UISoundController), "PlayGlitchSound")]
		public static class PlayGlitchSoundPatch
		{
			private static bool Prefix(UISoundController __instance)
			{
				if (__instance.myGlitchLoopingSource.isPlaying)
				{
					__instance.myGlitchLoopingSource.volume = 0f;
					__instance.myGlitchLoopingSource.Stop();
				}
				if (GlobalVariables.currentDay == 7 && !CustomCampaignGlobal.InCustomCampaign)
				{
					__instance.myGlitchLoopingSource.clip = __instance.scaryGlitch.clip;
					__instance.myGlitchLoopingSource.volume = __instance.scaryGlitch.volume;
				}
				else
				{
					__instance.myGlitchLoopingSource.clip = __instance.normalGlitch.clip;
					__instance.myGlitchLoopingSource.volume = __instance.normalGlitch.volume;
				}
				__instance.myGlitchLoopingSource.Play();
				return false;
			}
		}

		[HarmonyPatch(typeof(UISoundController), "PlayGlitchSoundWhileGlitchAnimationIsPlaying")]
		public static class PlayGlitchSoundWhileGlitchAnimationIsPlayingPatch
		{
			private static bool Prefix(UISoundController __instance, ref IEnumerator __result)
			{
				__result = PatchedPlayGlitchSound(__instance);
				return false;
			}

			private static IEnumerator PatchedPlayGlitchSound(UISoundController __instance)
			{
				if (!__instance.myGlitchLoopingSource.isPlaying)
				{
					if (GlobalVariables.currentDay == 7 && !CustomCampaignGlobal.InCustomCampaign)
					{
						__instance.myGlitchLoopingSource.clip = __instance.scaryGlitch.clip;
						__instance.myGlitchLoopingSource.volume = __instance.scaryGlitch.volume;
					}
					else
					{
						__instance.myGlitchLoopingSource.clip = __instance.normalGlitch.clip;
						__instance.myGlitchLoopingSource.volume = __instance.normalGlitch.volume;
					}
					__instance.myGlitchLoopingSource.Play();
				}
				if ((Object)(object)Camera.main == (Object)null)
				{
					LoggingHelper.ErrorLog("[UNITY] Camera is null! Cannot play glitch effect.");
					yield break;
				}
				while (((Component)Camera.main).GetComponent<Animator>().runtimeAnimatorController.animationClips.Length == 0)
				{
					LoggingHelper.DebugLog("[UNITY] Waiting for animationClips[] to populate.");
					yield return null;
				}
				while (((Component)Camera.main).GetComponent<Animator>().runtimeAnimatorController.animationClips.Length != 0)
				{
					yield return null;
				}
				((MonoBehaviour)__instance).StartCoroutine(__instance.FadeOutLoopingSound(__instance.myGlitchLoopingSource, 5f));
			}
		}
	}
}
namespace NewSafetyHelp.ARG
{
	public static class ARGHelper
	{
		public class ARGCaptureInput : MonoBehaviour
		{
			private static readonly List<KeyCode> KeyPresses = new List<KeyCode>
			{
				(KeyCode)274,
				(KeyCode)274,
				(KeyCode)273,
				(KeyCode)276,
				(KeyCode)275
			};

			private static float lastPressTime;

			private static int lastKeyPressedIndex;

			private const float TimeOutTime = 2f;

			private void Update()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				if (lastKeyPressedIndex > 0 && Time.time - lastPressTime > 2f)
				{
					lastKeyPressedIndex = 0;
				}
				KeyCode val = KeyPresses[lastKeyPressedIndex];
				if (Input.GetKeyDown(val))
				{
					lastKeyPressedIndex++;
					lastPressTime = Time.time;
					if (lastKeyPressedIndex >= KeyPresses.Count)
					{
						OpenARGHTML();
						lastKeyPressedIndex = 0;
					}
				}
				else if (Input.anyKeyDown)
				{
					lastKeyPressedIndex = 0;
				}
			}
		}

		private static readonly string ARGTestCampaignName = "TESHSH";

		private static readonly string ARGCampaignName = "Summer Cock Sucker";

		public static void OpenARGHTML()
		{
			LoggingHelper.InfoLog("Opening HTML file in browser.");
			string value = "<H1>In ■he blackest wake of an endless sea, An un■ealthy dosing of abno■mality, Only th■n will you truly see, Just what it is you can b■.</H1>";
			string text = Path.Combine(Path.GetTempPath(), string.Format("{0}secrets_{1}.html", "NewSafetyHelp_", Guid.NewGuid()));
			using (FileStream stream = new FileStream(text, FileMode.Create))
			{
				using StreamWriter streamWriter = new StreamWriter(stream, Encoding.UTF8);
				streamWriter.WriteLine(value);
			}
			Process.Start(new ProcessStartInfo
			{
				FileName = text,
				UseShellExecute = true
			});
		}

		public static void CreateInputCapture()
		{
			if (CustomCampaignGlobal.InCustomCampaign && (!(CustomCampaignGlobal.GetActiveCustomCampaign().CampaignName != ARGCampaignName) || !(CustomCampaignGlobal.GetActiveCustomCampaign().CampaignName != ARGTestCampaignName)))
			{
				GameObject.Find("MainMenuCanvas").gameObject.AddComponent<ARGCaptureInput>();
			}
		}
	}
}