using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: AssemblyCompany("NoteBoxz.EndOfDayCountdown")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("2.1.0.0")]
[assembly: AssemblyInformationalVersion("2.1.0")]
[assembly: AssemblyProduct("EndOfDayCountdown")]
[assembly: AssemblyTitle("NoteBoxz.EndOfDayCountdown")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EndOfDayCountdown
{
	[BepInPlugin("NoteBoxz.EndOfDayCountdown", "EndOfDayCountdown", "2.1.0")]
	public class EndOfDayCountdown : BaseUnityPlugin
	{
		internal static AssetBundle assetBundle;

		public static Countdown? CountDownInstace;

		public static GameObject countdownPrefab;

		public static ConfigEntry<string> TextColor;

		public static ConfigEntry<string> CircleColor;

		public static ConfigEntry<float> CountdownAlertDuration;

		public static ConfigEntry<string> CountdownPosition;

		public static ConfigEntry<string> CountdownSize;

		public static ConfigEntry<string> CountdownRotation;

		public static ConfigEntry<float> CountdownVolume;

		public static ConfigEntry<bool> DebugShowCountdown;

		public static EndOfDayCountdown Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		internal static Harmony? Harmony { get; set; }

		public static ConfigEntry<bool> SpawnCountdownInfrountOfUI { get; private set; }

		public static ConfigEntry<bool> StopCountdownWhenDead { get; private set; }

		public static ConfigEntry<bool> StopCountdownWhenShipLeave { get; private set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			Patch();
			BindConfigs();
			LoadAssetBundle();
			countdownPrefab = assetBundle.LoadAsset<GameObject>("Assets/CountDownAssets/Countdown.prefab");
			Logger.LogInfo((object)"NoteBoxz.EndOfDayCountdown v2.1.0 has loaded!");
		}

		private void BindConfigs()
		{
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			SpawnCountdownInfrountOfUI = ((BaseUnityPlugin)this).Config.Bind<bool>("Countdown", "Show coundown in front", false, "Spawns the countdown infront of the main UI");
			TextColor = ((BaseUnityPlugin)this).Config.Bind<string>("Colors", "Text Color", "(255,50,0,255)", "Color for the text. Format: (R,G,B,A)");
			TextColor.SettingChanged += delegate
			{
				CountDownInstace?.UpdatePosConfigs();
			};
			CircleColor = ((BaseUnityPlugin)this).Config.Bind<string>("Colors", "Circle Color", "(255,50,0,255)", "Color for the circle. Format: (R,G,B,A)");
			CircleColor.SettingChanged += delegate
			{
				CountDownInstace?.UpdatePosConfigs();
			};
			CountdownAlertDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Countdown", "Countdown Alert Duration", 3.5f, "Duration of the countdown alert in seconds.");
			StopCountdownWhenDead = ((BaseUnityPlugin)this).Config.Bind<bool>("Countdown", "Stop Countdown When Dead", true, "Stops the countdown when the player is dead.");
			StopCountdownWhenShipLeave = ((BaseUnityPlugin)this).Config.Bind<bool>("Countdown", "Stop Countdown When Ship Leaves", true, "Stops the countdown when the ship is leaving.");
			CountdownPosition = ((BaseUnityPlugin)this).Config.Bind<string>("Countdown", "Countdown Position", "0 0 0", "Position of the countdown on the screen. Format: (X Y Z)");
			CountdownPosition.SettingChanged += delegate
			{
				CountDownInstace?.UpdatePosConfigs();
			};
			CountdownSize = ((BaseUnityPlugin)this).Config.Bind<string>("Countdown", "Countdown Size", "0.5 0.5 0.5", "Size of the countdown. Format: (X Y Z)");
			CountdownSize.SettingChanged += delegate
			{
				CountDownInstace?.UpdatePosConfigs();
			};
			CountdownRotation = ((BaseUnityPlugin)this).Config.Bind<string>("Countdown", "Countdown Rotation", "0 0 0", "Rotation of the countdown in degrees. Format: (X Y Z)");
			CountdownRotation.SettingChanged += delegate
			{
				CountDownInstace?.UpdatePosConfigs();
			};
			CountdownVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Countdown", "Countdown Volume", 1f, new ConfigDescription("Volume of the countdown sound effects.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			CountdownRotation.SettingChanged += delegate
			{
				CountDownInstace?.UpdatePosConfigs();
			};
			DebugShowCountdown = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "Show Countdown Always", false, "Shows the countdown always for debugging purposes.");
		}

		internal static void LoadAssetBundle()
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (directoryName == null)
			{
				throw new InvalidOperationException("Unable to determine assembly location.");
			}
			string text = Path.Combine(directoryName, "endofdaycountdown");
			assetBundle = AssetBundle.LoadFromFile(text);
			if ((Object)(object)assetBundle == (Object)null)
			{
				throw new InvalidOperationException("Failed to load AssetBundle.");
			}
		}

		internal static Color ParseColor(string colorString)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			string[] array = colorString.Trim('(', ')').Split(',');
			if (array.Length == 4 && int.TryParse(array[0], out var result) && int.TryParse(array[1], out var result2) && int.TryParse(array[2], out var result3) && int.TryParse(array[3], out var result4))
			{
				return new Color((float)result / 255f, (float)result2 / 255f, (float)result3 / 255f, (float)result4 / 255f);
			}
			Logger.LogWarning((object)("Unable to parse color config!!!: Input " + colorString + " The input should be somthing like (000,000,000,000) for (R,G,B,A)"));
			return Color.white;
		}

		internal static Vector3 ParseVector3(string vectorString)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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)
			string[] array = vectorString.Trim('(', ')').Split(' ');
			if (array.Length == 3 && float.TryParse(array[0], out var result) && float.TryParse(array[1], out var result2) && float.TryParse(array[2], out var result3))
			{
				return new Vector3(result, result2, result3);
			}
			Logger.LogWarning((object)("Unable to parse vector3 config!!!: Input " + vectorString + " The input should be somthing like 0 0 0 for (X Y Z)"));
			return Vector3.zero;
		}

		public static string GetClock(float timeNormalized, float numberOfHours)
		{
			int num = (int)(timeNormalized * (60f * numberOfHours)) + 360;
			int num2 = (int)Mathf.Floor((float)(num / 60));
			string text = "AM";
			if (num2 >= 24)
			{
				return "12:00\nAM";
			}
			text = ((num2 >= 12) ? "PM" : "AM");
			if (num2 > 12)
			{
				num2 %= 12;
			}
			int num3 = num % 60;
			return $"{num2:00}:{num3:00}".TrimStart('0') + text;
		}

		internal static void Patch()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("NoteBoxz.EndOfDayCountdown");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll();
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static void Unpatch()
		{
			Logger.LogDebug((object)"Unpatching...");
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Logger.LogDebug((object)"Finished unpatching!");
		}
	}
	public class Countdown : MonoBehaviour
	{
		public Animator anim = null;

		public AudioSource sfx = null;

		public TMP_Text text = null;

		public Image sprite = null;

		public CanvasGroup canvasGroup = null;

		public static Dictionary<float, string> TimeMap = new Dictionary<float, string>();

		public const int numbCountdownAlerts = 11;

		private bool wasDebugShown = false;

		private void Awake()
		{
			anim = ((Component)this).GetComponent<Animator>();
			sfx = ((Component)this).GetComponentInChildren<AudioSource>();
			text = ((Component)this).GetComponentInChildren<TMP_Text>();
			sprite = ((Component)this).GetComponentInChildren<Image>();
			canvasGroup = ((Component)this).GetComponent<CanvasGroup>();
		}

		private void Start()
		{
			UpdatePosConfigs();
		}

		private void Update()
		{
			if (EndOfDayCountdown.DebugShowCountdown.Value && !wasDebugShown)
			{
				((Behaviour)anim).enabled = false;
				wasDebugShown = true;
				canvasGroup.alpha = 1f;
				EndOfDayCountdown.Logger.LogInfo((object)"Debug countdown shown");
			}
			else if (!EndOfDayCountdown.DebugShowCountdown.Value && wasDebugShown)
			{
				wasDebugShown = false;
				canvasGroup.alpha = 0f;
				((Behaviour)anim).enabled = true;
				EndOfDayCountdown.Logger.LogInfo((object)"Debug countdown hidden");
			}
		}

		public void UpdatePosConfigs()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0078: 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)
			((Component)this).transform.localPosition = EndOfDayCountdown.ParseVector3(EndOfDayCountdown.CountdownPosition.Value);
			((Component)this).transform.localScale = EndOfDayCountdown.ParseVector3(EndOfDayCountdown.CountdownSize.Value);
			((Component)this).transform.eulerAngles = EndOfDayCountdown.ParseVector3(EndOfDayCountdown.CountdownRotation.Value);
			sfx.volume = EndOfDayCountdown.CountdownVolume.Value;
			((Graphic)text).color = EndOfDayCountdown.ParseColor(EndOfDayCountdown.TextColor.Value);
			((Graphic)sprite).color = EndOfDayCountdown.ParseColor(EndOfDayCountdown.CircleColor.Value);
		}

		public void CountdownAlert(string message, Color? OverrideColor = null)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (OverrideColor.HasValue)
			{
				((Graphic)text).color = OverrideColor.Value;
				((Graphic)sprite).color = OverrideColor.Value;
			}
			else
			{
				((Graphic)text).color = EndOfDayCountdown.ParseColor(EndOfDayCountdown.TextColor.Value);
				((Graphic)sprite).color = EndOfDayCountdown.ParseColor(EndOfDayCountdown.CircleColor.Value);
			}
			text.text = message;
			anim.Play("CountDown");
			sfx.Play();
		}

		public static void UpdateTimeMap(float? overrideEndTime = null)
		{
			TimeMap.Clear();
			TimeOfDay instance = TimeOfDay.Instance;
			int numberOfHours = instance.numberOfHours;
			float totalTime = instance.totalTime;
			float num = instance.shipLeaveAutomaticallyTime * totalTime;
			if (overrideEndTime.HasValue)
			{
				num = overrideEndTime.Value;
			}
			float num2 = num - EndOfDayCountdown.CountdownAlertDuration.Value * 11f;
			for (int i = 0; i < 11; i++)
			{
				float key = num2 + (float)i * EndOfDayCountdown.CountdownAlertDuration.Value;
				TimeMap.Add(key, $"{10 - i}");
			}
			EndOfDayCountdown.Logger.LogInfo((object)"═══════════════════════════════════");
			EndOfDayCountdown.Logger.LogInfo((object)"              TIME MAP             ");
			EndOfDayCountdown.Logger.LogInfo((object)"═══════════════════════════════════");
			foreach (KeyValuePair<float, string> item in TimeMap)
			{
				EndOfDayCountdown.Logger.LogInfo((object)$"({item.Value}) Time: {item.Key:F2} - Clock: {EndOfDayCountdown.GetClock(item.Key / totalTime, numberOfHours)}");
			}
			EndOfDayCountdown.Logger.LogInfo((object)"═══════════════════════════════════");
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	internal class HUDManagerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void MakeCountdown(HUDManager __instance)
		{
			try
			{
				EndOfDayCountdown.CountDownInstace = Object.Instantiate<GameObject>(EndOfDayCountdown.countdownPrefab, __instance.HUDContainer.transform.parent).AddComponent<Countdown>();
				Transform val = __instance.HUDContainer.transform.parent.Find("Panel");
				if ((Object)(object)val != (Object)null && !EndOfDayCountdown.SpawnCountdownInfrountOfUI.Value)
				{
					((Component)EndOfDayCountdown.CountDownInstace).transform.SetSiblingIndex(val.GetSiblingIndex() + 1);
				}
				else if (!EndOfDayCountdown.SpawnCountdownInfrountOfUI.Value)
				{
					EndOfDayCountdown.Logger.LogWarning((object)"No 'pannle' found");
				}
				EndOfDayCountdown.Logger.LogInfo((object)"Created countdown instance");
			}
			catch (Exception ex)
			{
				EndOfDayCountdown.Logger.LogError((object)("Error in HUDManagerPatch: " + ex.Message + "\n" + ex.StackTrace));
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[CompilerGenerated]
		private sealed class <MesureTimeDelayed>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public StartOfRound __instance;

			private TimeOfDay <time>5__1;

			private float <timeSpeedMultiplier>5__2;

			private float <hourLength>5__3;

			private int <hoursCount>5__4;

			private float <dayLength>5__5;

			private float <dayEndTime>5__6;

			private float <startOffset>5__7;

			private float <realTimeSecondsPerHour>5__8;

			private float <realTimeToReachDayEnd>5__9;

			private string <endClock>5__10;

			private int <i>5__11;

			private float <actualHourIndex>5__12;

			private float <gameTimeAtHour>5__13;

			private float <realTimeToReachHour>5__14;

			private string <gameClock>5__15;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<time>5__1 = null;
				<endClock>5__10 = null;
				<gameClock>5__15 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => TimeOfDay.Instance.timeHasStarted));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<time>5__1 = TimeOfDay.Instance;
					<timeSpeedMultiplier>5__2 = <time>5__1.globalTimeSpeedMultiplier;
					<hourLength>5__3 = <time>5__1.lengthOfHours;
					<hoursCount>5__4 = <time>5__1.numberOfHours;
					<dayLength>5__5 = <time>5__1.totalTime;
					<dayEndTime>5__6 = <time>5__1.shipLeaveAutomaticallyTime * <dayLength>5__5;
					<startOffset>5__7 = 100f;
					<realTimeSecondsPerHour>5__8 = <hourLength>5__3 / <timeSpeedMultiplier>5__2;
					EndOfDayCountdown.Logger.LogDebug((object)"═══════════════════════════════════");
					EndOfDayCountdown.Logger.LogDebug((object)"     TIME CALCULATION RESULTS      ");
					EndOfDayCountdown.Logger.LogDebug((object)"═══════════════════════════════════");
					EndOfDayCountdown.Logger.LogDebug((object)$"Time Speed: {<timeSpeedMultiplier>5__2}x");
					EndOfDayCountdown.Logger.LogDebug((object)$"Starting Time Offset: {<startOffset>5__7:F2}");
					EndOfDayCountdown.Logger.LogDebug((object)("1 Game Hour = " + FormatTime(<realTimeSecondsPerHour>5__8) + " real time"));
					EndOfDayCountdown.Logger.LogDebug((object)"───────────────────────────────────");
					EndOfDayCountdown.Logger.LogDebug((object)"HOUR-BY-HOUR BREAKDOWN:");
					<i>5__11 = 0;
					while (<i>5__11 < <hoursCount>5__4)
					{
						<actualHourIndex>5__12 = <i>5__11;
						<gameTimeAtHour>5__13 = <actualHourIndex>5__12 * <hourLength>5__3 + <startOffset>5__7;
						<realTimeToReachHour>5__14 = (<gameTimeAtHour>5__13 - <startOffset>5__7) / <timeSpeedMultiplier>5__2;
						<gameClock>5__15 = EndOfDayCountdown.GetClock(<gameTimeAtHour>5__13 / <dayLength>5__5, <hoursCount>5__4);
						EndOfDayCountdown.Logger.LogDebug((object)$"► Hour {<gameClock>5__15} ({<i>5__11}) - Reached after {FormatTime(<realTimeToReachHour>5__14)} real time");
						<gameClock>5__15 = null;
						<i>5__11++;
					}
					EndOfDayCountdown.Logger.LogDebug((object)"───────────────────────────────────");
					<realTimeToReachDayEnd>5__9 = (<dayEndTime>5__6 - <startOffset>5__7) / <timeSpeedMultiplier>5__2;
					<endClock>5__10 = EndOfDayCountdown.GetClock(<dayEndTime>5__6 / <dayLength>5__5, <hoursCount>5__4);
					EndOfDayCountdown.Logger.LogDebug((object)("⚠ SHIP LEAVES (" + <endClock>5__10 + ") - Reached after " + FormatTime(<realTimeToReachDayEnd>5__9) + " real time"));
					EndOfDayCountdown.Logger.LogDebug((object)"═══════════════════════════════════");
					Countdown.UpdateTimeMap();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

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

		[HarmonyPatch("openingDoorsSequence")]
		[HarmonyPostfix]
		private static void MesureTime(StartOfRound __instance)
		{
			try
			{
				((MonoBehaviour)__instance).StartCoroutine(MesureTimeDelayed(__instance));
			}
			catch (Exception ex)
			{
				EndOfDayCountdown.Logger.LogError((object)("Error in StartOfRoundPatch: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		[IteratorStateMachine(typeof(<MesureTimeDelayed>d__1))]
		private static IEnumerator MesureTimeDelayed(StartOfRound __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MesureTimeDelayed>d__1(0)
			{
				__instance = __instance
			};
		}

		private static string FormatTime(float seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			if (timeSpan.TotalHours >= 1.0)
			{
				return $"{(int)timeSpan.TotalHours}h {timeSpan.Minutes}m {timeSpan.Seconds}s";
			}
			if (timeSpan.TotalMinutes >= 1.0)
			{
				return $"{timeSpan.Minutes}m {timeSpan.Seconds}s";
			}
			return $"{timeSpan.Seconds}s";
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	internal class TimeOfDayPatch
	{
		[HarmonyPatch("MoveGlobalTime")]
		[HarmonyPostfix]
		private static void checkForCountdown(TimeOfDay __instance)
		{
			try
			{
				if ((Object)(object)EndOfDayCountdown.CountDownInstace == (Object)null || (!StartOfRound.Instance.localPlayerController.isPlayerControlled && EndOfDayCountdown.StopCountdownWhenDead.Value) || (StartOfRound.Instance.shipIsLeaving && EndOfDayCountdown.StopCountdownWhenShipLeave.Value))
				{
					return;
				}
				float globalTime = __instance.globalTime;
				float? num = null;
				foreach (KeyValuePair<float, string> item in Countdown.TimeMap)
				{
					if (Mathf.Abs(globalTime - item.Key) < 0.1f)
					{
						EndOfDayCountdown.Logger.LogDebug((object)$"Time match found: {globalTime:F2} matches {item.Key:F2} - {item.Value}");
						EndOfDayCountdown.CountDownInstace.CountdownAlert(item.Value);
						num = item.Key;
						break;
					}
				}
				if (num.HasValue)
				{
					Countdown.TimeMap.Remove(num.Value);
					num = null;
				}
			}
			catch (Exception ex)
			{
				EndOfDayCountdown.Logger.LogError((object)("Error in TimeOfDayPatch: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		[HarmonyPatch("SetShipLeaveEarlyClientRpc")]
		[HarmonyPrefix]
		private static void MesureTime(TimeOfDay __instance, float timeToLeaveEarly, int votes)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)__instance).NetworkManager;
			if (networkManager != null && networkManager.IsListening && (int)((NetworkBehaviour)__instance).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				Countdown.UpdateTimeMap(timeToLeaveEarly * TimeOfDay.Instance.totalTime);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "NoteBoxz.EndOfDayCountdown";

		public const string PLUGIN_NAME = "EndOfDayCountdown";

		public const string PLUGIN_VERSION = "2.1.0";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}