using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MoreShipUpgrades.Managers;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("MoreShipUpgrades")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LGUContractHUD")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Contract HUD display for LateGameUpgrades")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+8c5521e37f37e3d76518a16d04e5d1051842f105")]
[assembly: AssemblyProduct("LGUContractHUD")]
[assembly: AssemblyTitle("LGUContractHUD")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LGUContractHUD
{
	internal class ContractHUDManager : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <AnimateSequence>d__31 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ContractHUDManager <>4__this;

			public string title;

			public string objective;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: 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_0090: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Expected O, but got Unknown
				//IL_016d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Expected O, but got Unknown
				int num = <>1__state;
				ContractHUDManager contractHUDManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					contractHUDManager._isShowing = true;
					contractHUDManager._cardRect.anchorMin = new Vector2(0.5f, 0.5f);
					contractHUDManager._cardRect.anchorMax = new Vector2(0.5f, 0.5f);
					contractHUDManager._cardRect.pivot = new Vector2(0.5f, 0.5f);
					contractHUDManager._cardRect.anchoredPosition = Vector2.zero;
					((Transform)contractHUDManager._cardRect).localScale = Vector3.one * 1f;
					contractHUDManager._canvasGroup.alpha = 1f;
					contractHUDManager.SetBorderVisible(visible: true);
					((TMP_Text)contractHUDManager._titleText).text = "";
					((TMP_Text)contractHUDManager._objectiveText).text = "";
					<>2__current = ((MonoBehaviour)contractHUDManager).StartCoroutine(contractHUDManager.TypewriterText(contractHUDManager._titleText, title));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.15f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = ((MonoBehaviour)contractHUDManager).StartCoroutine(contractHUDManager.TypewriterText(contractHUDManager._objectiveText, objective));
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.6f);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = ((MonoBehaviour)contractHUDManager).StartCoroutine(contractHUDManager.ShrinkAndMove());
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					contractHUDManager.SetBorderVisible(visible: false);
					contractHUDManager._isShowing = true;
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <FadeOut>d__34 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ContractHUDManager <>4__this;

			private float <duration>5__2;

			private float <start>5__3;

			private float <elapsed>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				ContractHUDManager contractHUDManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<duration>5__2 = 0.5f;
					<start>5__3 = contractHUDManager._canvasGroup.alpha;
					<elapsed>5__4 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__4 < <duration>5__2)
				{
					<elapsed>5__4 += Time.deltaTime;
					contractHUDManager._canvasGroup.alpha = Mathf.Lerp(<start>5__3, 0f, <elapsed>5__4 / <duration>5__2);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				contractHUDManager._canvasGroup.alpha = 0f;
				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();
			}
		}

		[CompilerGenerated]
		private sealed class <ShrinkAndMove>d__33 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ContractHUDManager <>4__this;

			private Vector2 <startPos>5__2;

			private Vector3 <startScale>5__3;

			private Vector2 <targetPos>5__4;

			private Vector3 <targetScale>5__5;

			private float <elapsed>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: 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_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				ContractHUDManager contractHUDManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<startPos>5__2 = contractHUDManager._cardRect.anchoredPosition;
					<startScale>5__3 = ((Transform)contractHUDManager._cardRect).localScale;
					<targetPos>5__4 = new Vector2(688f, 440f);
					<targetScale>5__5 = Vector3.one * 0.75f;
					<elapsed>5__6 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__6 < 1.2f)
				{
					<elapsed>5__6 += Time.deltaTime;
					float num2 = Mathf.Clamp01(<elapsed>5__6 / 1.2f);
					float num3 = num2 * num2 * (3f - 2f * num2);
					contractHUDManager._cardRect.anchoredPosition = Vector2.Lerp(<startPos>5__2, <targetPos>5__4, num3);
					((Transform)contractHUDManager._cardRect).localScale = Vector3.Lerp(<startScale>5__3, <targetScale>5__5, num3);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				contractHUDManager._cardRect.anchoredPosition = <targetPos>5__4;
				((Transform)contractHUDManager._cardRect).localScale = <targetScale>5__5;
				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();
			}
		}

		[CompilerGenerated]
		private sealed class <TypewriterText>d__32 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public TextMeshProUGUI tmp;

			public string fullText;

			private int <i>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0087;
				}
				<>1__state = -1;
				((TMP_Text)tmp).text = "";
				<i>5__2 = 0;
				goto IL_0097;
				IL_0087:
				<i>5__2++;
				goto IL_0097;
				IL_0097:
				if (<i>5__2 < fullText.Length)
				{
					((TMP_Text)tmp).text = fullText.Substring(0, <i>5__2 + 1);
					if (!char.IsWhiteSpace(fullText[<i>5__2]))
					{
						<>2__current = (object)new WaitForSeconds(0.035f);
						<>1__state = 1;
						return true;
					}
					goto IL_0087;
				}
				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();
			}
		}

		private Canvas _canvas;

		private CanvasGroup _canvasGroup;

		private RectTransform _cardRect;

		private Image _borderImage;

		private TextMeshProUGUI _titleText;

		private TextMeshProUGUI _objectiveText;

		private Coroutine _animCoroutine;

		private bool _isShowing;

		private static readonly Color LCTeal = new Color(0f, 1f, 0.87f, 1f);

		private static readonly Color BorderColor = new Color(0f, 1f, 0.87f, 0.6f);

		private const float CenteredScale = 1f;

		private const float SettledScale = 0.75f;

		private const float CardWidth = 620f;

		private const float CardHeight = 180f;

		private const float TypewriterCharDelay = 0.035f;

		private const float ShrinkMoveDuration = 1.2f;

		private const float PauseAfterTypewriter = 0.6f;

		private static readonly Dictionary<string, (string DisplayName, string Objective)> ContractInfo = new Dictionary<string, (string, string)>
		{
			{
				"Data",
				("DATA RETRIEVAL", "Locate the laptop, bruteforce its IP,\nlogin and extract the .db file")
			},
			{
				"Defusal",
				("BOMB DEFUSAL", "Find the bomb, lookup its serial number,\ncut the correct wires before time runs out")
			},
			{
				"Exorcism",
				("EXORCISM", "Find the ritual site, identify the demon,\ngather ritual items and complete the banishment")
			},
			{
				"Exterminator",
				("EXTERMINATOR", "Locate the bug nest\nand destroy it to clear the infestation")
			},
			{
				"Extraction",
				("EXTRACTION", "Find the lost operative,\nheal them with a medkit and bring them to the ship")
			}
		};

		internal static ContractHUDManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			BuildUI();
			Hide(immediate: true);
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (((Scene)(ref scene)).name != "SampleSceneRelay")
			{
				Hide(immediate: true);
			}
		}

		internal void ShowContract()
		{
			string activeContractType = GetActiveContractType();
			if (string.IsNullOrEmpty(activeContractType) || activeContractType == "None")
			{
				Plugin.Log.LogDebug((object)"No active contract - skipping HUD.");
				return;
			}
			if (!ContractInfo.TryGetValue(activeContractType, out (string, string) value))
			{
				Plugin.Log.LogWarning((object)("Unknown contract type '" + activeContractType + "' - skipping HUD."));
				return;
			}
			if (_animCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_animCoroutine);
			}
			_animCoroutine = ((MonoBehaviour)this).StartCoroutine(AnimateSequence(value.Item1, value.Item2));
		}

		internal void Hide(bool immediate = false)
		{
			if (_animCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_animCoroutine);
				_animCoroutine = null;
			}
			_isShowing = false;
			if (immediate)
			{
				_canvasGroup.alpha = 0f;
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(FadeOut());
			}
		}

		private void BuildUI()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Expected O, but got Unknown
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: 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)
			_canvas = ((Component)this).gameObject.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 100;
			CanvasScaler obj = ((Component)this).gameObject.AddComponent<CanvasScaler>();
			obj.uiScaleMode = (ScaleMode)1;
			obj.referenceResolution = new Vector2(1920f, 1080f);
			obj.matchWidthOrHeight = 1f;
			((Component)this).gameObject.AddComponent<GraphicRaycaster>();
			_canvasGroup = ((Component)this).gameObject.AddComponent<CanvasGroup>();
			_canvasGroup.interactable = false;
			_canvasGroup.blocksRaycasts = false;
			GameObject val = new GameObject("ContractCard");
			val.transform.SetParent(((Component)_canvas).transform, false);
			_cardRect = val.AddComponent<RectTransform>();
			_cardRect.sizeDelta = new Vector2(620f, 180f);
			_cardRect.anchorMin = new Vector2(0.5f, 0.5f);
			_cardRect.anchorMax = new Vector2(0.5f, 0.5f);
			_cardRect.pivot = new Vector2(0.5f, 0.5f);
			_cardRect.anchoredPosition = Vector2.zero;
			CreateBorder(val.transform);
			GameObject val2 = new GameObject("TitleText");
			val2.transform.SetParent(val.transform, false);
			_titleText = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)_titleText).fontSize = 32f;
			((TMP_Text)_titleText).fontStyle = (FontStyles)1;
			((Graphic)_titleText).color = LCTeal;
			((TMP_Text)_titleText).alignment = (TextAlignmentOptions)257;
			((TMP_Text)_titleText).enableWordWrapping = false;
			((TMP_Text)_titleText).overflowMode = (TextOverflowModes)0;
			RectTransform rectTransform = ((TMP_Text)_titleText).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 0.5f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.offsetMin = new Vector2(20f, 5f);
			rectTransform.offsetMax = new Vector2(-20f, -15f);
			AssignVanillaFont(_titleText);
			GameObject val3 = new GameObject("ObjectiveText");
			val3.transform.SetParent(val.transform, false);
			_objectiveText = val3.AddComponent<TextMeshProUGUI>();
			((TMP_Text)_objectiveText).fontSize = 22f;
			((TMP_Text)_objectiveText).fontStyle = (FontStyles)0;
			((Graphic)_objectiveText).color = LCTeal;
			((TMP_Text)_objectiveText).alignment = (TextAlignmentOptions)257;
			((TMP_Text)_objectiveText).enableWordWrapping = true;
			((TMP_Text)_objectiveText).overflowMode = (TextOverflowModes)0;
			RectTransform rectTransform2 = ((TMP_Text)_objectiveText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 0f);
			rectTransform2.anchorMax = new Vector2(1f, 0.5f);
			rectTransform2.pivot = new Vector2(0.5f, 0.5f);
			rectTransform2.offsetMin = new Vector2(20f, 10f);
			rectTransform2.offsetMax = new Vector2(-20f, -5f);
			AssignVanillaFont(_objectiveText);
		}

		private void AssignVanillaFont(TextMeshProUGUI tmp)
		{
			if ((Object)(object)HUDManager.Instance != (Object)null && (Object)(object)HUDManager.Instance.clockNumber != (Object)null)
			{
				TMP_FontAsset font = ((TMP_Text)HUDManager.Instance.clockNumber).font;
				if ((Object)(object)font != (Object)null)
				{
					((TMP_Text)tmp).font = font;
					return;
				}
			}
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset val in array)
			{
				if (((Object)val).name.Contains("3270") || ((Object)val).name.Contains("edunline") || ((Object)val).name.Contains("EdgeOf"))
				{
					((TMP_Text)tmp).font = val;
					break;
				}
			}
		}

		private void CreateBorder(Transform parent)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_008f: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: 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_0143: 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)
			float num = 2f;
			_borderImage = CreateBorderEdge(parent, "BorderTop", new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, 0f - num), new Vector2(0f, 0f));
			CreateBorderEdge(parent, "BorderBottom", new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 0f), new Vector2(0f, num));
			CreateBorderEdge(parent, "BorderLeft", new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(0f, 0.5f), new Vector2(0f, 0f), new Vector2(num, 0f));
			CreateBorderEdge(parent, "BorderRight", new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(1f, 0.5f), new Vector2(0f - num, 0f), new Vector2(0f, 0f));
		}

		private Image CreateBorderEdge(Transform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = anchorMin;
			obj.anchorMax = anchorMax;
			obj.pivot = pivot;
			obj.offsetMin = offsetMin;
			obj.offsetMax = offsetMax;
			Image obj2 = val.AddComponent<Image>();
			((Graphic)obj2).color = BorderColor;
			return obj2;
		}

		[IteratorStateMachine(typeof(<AnimateSequence>d__31))]
		private IEnumerator AnimateSequence(string title, string objective)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateSequence>d__31(0)
			{
				<>4__this = this,
				title = title,
				objective = objective
			};
		}

		[IteratorStateMachine(typeof(<TypewriterText>d__32))]
		private IEnumerator TypewriterText(TextMeshProUGUI tmp, string fullText)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TypewriterText>d__32(0)
			{
				tmp = tmp,
				fullText = fullText
			};
		}

		[IteratorStateMachine(typeof(<ShrinkAndMove>d__33))]
		private IEnumerator ShrinkAndMove()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ShrinkAndMove>d__33(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<FadeOut>d__34))]
		private IEnumerator FadeOut()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeOut>d__34(0)
			{
				<>4__this = this
			};
		}

		private void SetBorderVisible(bool visible)
		{
			Transform transform = ((Component)_cardRect).transform;
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform child = transform.GetChild(i);
				if (((Object)child).name.StartsWith("Border"))
				{
					((Component)child).gameObject.SetActive(visible);
				}
			}
		}

		private string GetActiveContractType()
		{
			if ((Object)(object)ContractManager.Instance == (Object)null)
			{
				return null;
			}
			return ContractManager.Instance.contractType;
		}

		internal static void EnsureInstance()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Instance != (Object)null))
			{
				new GameObject("LGUContractHUD_Canvas").AddComponent<ContractHUDManager>();
			}
		}
	}
	[BepInPlugin("com.lguhud.contracthud", "LGUContractHUD", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string PLUGIN_GUID = "com.lguhud.contracthud";

		public const string PLUGIN_NAME = "LGUContractHUD";

		public const string PLUGIN_VERSION = "1.0.0";

		internal static ManualLogSource Log;

		private Harmony _harmony;

		private void Awake()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			_harmony = new Harmony("com.lguhud.contracthud");
			_harmony.PatchAll(typeof(StartOfRoundPatches));
			Log.LogInfo((object)"LGUContractHUD v1.0.0 loaded.");
		}
	}
	internal static class StartOfRoundPatches
	{
		[CompilerGenerated]
		private sealed class <WrapWithContractHUD>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerator original;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0045;
				case 1:
					<>1__state = -1;
					goto IL_0045;
				case 2:
					{
						<>1__state = -1;
						ContractHUDManager.EnsureInstance();
						if ((Object)(object)ContractHUDManager.Instance != (Object)null)
						{
							ContractHUDManager.Instance.ShowContract();
						}
						return false;
					}
					IL_0045:
					if (original.MoveNext())
					{
						<>2__current = original.Current;
						<>1__state = 1;
						return true;
					}
					<>2__current = (object)new WaitForSeconds(1.5f);
					<>1__state = 2;
					return true;
				}
			}

			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(typeof(StartOfRound), "openingDoorsSequence")]
		[HarmonyPostfix]
		private static void AfterOpeningDoorsSequence(ref IEnumerator __result)
		{
			__result = WrapWithContractHUD(__result);
		}

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

		[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
		[HarmonyPostfix]
		private static void OnShipLeave()
		{
			if ((Object)(object)ContractHUDManager.Instance != (Object)null)
			{
				ContractHUDManager.Instance.Hide();
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ShipLeaveAutomatically")]
		[HarmonyPostfix]
		private static void OnShipLeaveAutomatically()
		{
			if ((Object)(object)ContractHUDManager.Instance != (Object)null)
			{
				ContractHUDManager.Instance.Hide();
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "SetShipReadyToLand")]
		[HarmonyPostfix]
		private static void OnSetShipReadyToLand()
		{
			if ((Object)(object)ContractHUDManager.Instance != (Object)null)
			{
				ContractHUDManager.Instance.Hide(immediate: true);
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
		[HarmonyPostfix]
		private static void OnDisconnect()
		{
			if ((Object)(object)ContractHUDManager.Instance != (Object)null)
			{
				ContractHUDManager.Instance.Hide(immediate: true);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "LGUContractHUD";

		public const string PLUGIN_NAME = "LGUContractHUD";

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