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 BepInEx;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;

[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: AssemblyCompany("BerserkMenu")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BerserkMenu")]
[assembly: AssemblyTitle("BerserkMenu")]
[assembly: AssemblyVersion("1.0.0.0")]
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;
		}
	}
}
[BepInPlugin("DgDarel.BerserkMenu", "BerserkMenu", "1.0.0")]
public class BerserkMenu : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <InitializeMenu>d__13 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public BerserkMenu <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.CreateScreen();
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.LoadFrames());
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PlayAnimation());
				((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"BerserkMenu initialized");
				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 <LoadFrames>d__22 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public BerserkMenu <>4__this;

		private string[] <pngFiles>5__1;

		private string[] <>s__2;

		private int <>s__3;

		private string <file>5__4;

		private byte[] <imageData>5__5;

		private Texture2D <texture>5__6;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<pngFiles>5__1 = null;
			<>s__2 = null;
			<file>5__4 = null;
			<imageData>5__5 = null;
			<texture>5__6 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (!Directory.Exists(<>4__this.framesFolder))
				{
					((BaseUnityPlugin)<>4__this).Logger.LogError((object)"Frames folder missing");
					return false;
				}
				<pngFiles>5__1 = Directory.GetFiles(<>4__this.framesFolder, "*.png");
				Array.Sort(<pngFiles>5__1);
				<>s__2 = <pngFiles>5__1;
				<>s__3 = 0;
				break;
			case 1:
				<>1__state = -1;
				<imageData>5__5 = null;
				<texture>5__6 = null;
				<file>5__4 = null;
				<>s__3++;
				break;
			}
			if (<>s__3 < <>s__2.Length)
			{
				<file>5__4 = <>s__2[<>s__3];
				<imageData>5__5 = File.ReadAllBytes(<file>5__4);
				<texture>5__6 = new Texture2D(2, 2, (TextureFormat)4, true);
				ImageConversion.LoadImage(<texture>5__6, <imageData>5__5, false);
				((Texture)<texture>5__6).filterMode = (FilterMode)0;
				((Texture)<texture>5__6).anisoLevel = 16;
				((Texture)<texture>5__6).wrapMode = (TextureWrapMode)1;
				((Texture)<texture>5__6).mipMapBias = -3f;
				<>4__this.frames.Add(<texture>5__6);
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			<>s__2 = null;
			<>4__this.animationLoaded = true;
			((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("Frames loaded: " + <>4__this.frames.Count));
			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 <PlayAnimation>d__23 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public BerserkMenu <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<>4__this.animationLoaded && (Object)(object)<>4__this.runtimeMaterial != (Object)null && <>4__this.frames.Count > 0)
			{
				<>4__this.runtimeMaterial.mainTexture = (Texture)(object)<>4__this.frames[<>4__this.currentFrame];
				<>4__this.currentFrame++;
				if (<>4__this.currentFrame >= <>4__this.frames.Count)
				{
					<>4__this.currentFrame = 0;
				}
			}
			<>2__current = (object)new WaitForSeconds(0.016f);
			<>1__state = 1;
			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();
		}
	}

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

		private object <>2__current;

		public BerserkMenu <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.currentCamera = Camera.main;
				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 GameObject screenQuad;

	private MeshRenderer meshRenderer;

	private Material runtimeMaterial;

	private Camera currentCamera;

	private readonly List<Texture2D> frames = new List<Texture2D>();

	private int currentFrame = 0;

	private bool animationLoaded = false;

	private bool inGameplay = false;

	private string framesFolder;

	private readonly Vector3 quadScale = new Vector3(2.7f, 1.52f, 1f);

	private const float cameraDistance = 1.95f;

	private const float frameDelay = 0.016f;

	private void Awake()
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Expected O, but got Unknown
		string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
		framesFolder = Path.Combine(directoryName, "BerserkFrames");
		SceneManager.activeSceneChanged += OnSceneChanged;
		Application.logMessageReceived += new LogCallback(OnUnityLog);
		((MonoBehaviour)this).StartCoroutine(InitializeMenu());
	}

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

	private void OnUnityLog(string condition, string stackTrace, LogType type)
	{
		if (condition.Contains("Changed level to: Level - Lobby Menu"))
		{
			ReturnToMenu();
		}
		else if (condition.Contains("Changed level to: Level -"))
		{
			EnterGameplay();
		}
		if (condition.Contains("Leave to Main Menu"))
		{
			ReturnToMenu();
		}
	}

	private void EnterGameplay()
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		inGameplay = true;
		if ((Object)(object)screenQuad != (Object)null)
		{
			screenQuad.transform.position = new Vector3(99999f, 99999f, 99999f);
		}
	}

	private void ReturnToMenu()
	{
		inGameplay = false;
	}

	private void Update()
	{
		//IL_0061: 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_007b: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)currentCamera == (Object)null)
		{
			currentCamera = Camera.main;
		}
		if ((Object)(object)currentCamera != (Object)null && (Object)(object)screenQuad != (Object)null && !inGameplay)
		{
			screenQuad.transform.position = ((Component)currentCamera).transform.position + ((Component)currentCamera).transform.forward * 1.95f;
			screenQuad.transform.rotation = ((Component)currentCamera).transform.rotation;
		}
		MuteTruckSounds();
	}

	private void MuteTruckSounds()
	{
		AudioSource[] array = Object.FindObjectsOfType<AudioSource>();
		AudioSource[] array2 = array;
		foreach (AudioSource val in array2)
		{
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.clip == (Object)null))
			{
				string text = ((Object)val.clip).name.ToLower();
				if (!text.Contains("berserk") && !text.Contains("msc main menu") && (text.Contains("truck") || text.Contains("wheel") || text.Contains("engine") || text.Contains("door")))
				{
					val.volume = 0f;
				}
			}
		}
	}

	private void OnSceneChanged(Scene oldScene, Scene newScene)
	{
		((MonoBehaviour)this).StartCoroutine(RefreshCamera());
	}

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

	private void CreateScreen()
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Expected O, but got Unknown
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		screenQuad = GameObject.CreatePrimitive((PrimitiveType)5);
		Object.DontDestroyOnLoad((Object)(object)screenQuad);
		((Object)screenQuad).name = "BerserkScreen";
		Object.Destroy((Object)(object)screenQuad.GetComponent<Collider>());
		screenQuad.transform.localScale = quadScale;
		meshRenderer = screenQuad.GetComponent<MeshRenderer>();
		Shader val = Shader.Find("Sprites/Default");
		if ((Object)(object)val == (Object)null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Shader missing");
			return;
		}
		runtimeMaterial = new Material(val);
		runtimeMaterial.color = new Color(1.45f, 1.25f, 1.25f, 1f);
		((Renderer)meshRenderer).material = runtimeMaterial;
		((Renderer)meshRenderer).sortingOrder = 9999;
		((Renderer)meshRenderer).shadowCastingMode = (ShadowCastingMode)0;
		((Renderer)meshRenderer).receiveShadows = false;
		((Renderer)meshRenderer).lightProbeUsage = (LightProbeUsage)0;
		((Renderer)meshRenderer).reflectionProbeUsage = (ReflectionProbeUsage)0;
	}

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

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