using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using AliensInValheim.Abuction;
using AliensInValheim.AlienAtack;
using AliensInValheim.AlienSighting;
using AliensInValheim.AlienSpeak;
using AliensInValheim.AlienUIModal;
using AliensInValheim.Audio;
using AliensInValheim.Commands;
using AliensInValheim.Core;
using AliensInValheim.CreatureAbduction;
using AliensInValheim.FlyOvni;
using AliensInValheim.I18n;
using AliensInValheim.Intro;
using AliensInValheim.License;
using AliensInValheim.OvniScan;
using AliensInValheim.Pins;
using AliensInValheim.Utilities;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Entities;
using Jotunn.Managers;
using Newtonsoft.Json;
using Splatform;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
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: AssemblyTitle("AliensInValheim")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("AliensInValheim")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3268f4e1-04a0-43cf-9137-68ff1bc8f484")]
[assembly: AssemblyFileVersion("1.1.1")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.1.1.0")]
namespace AliensInValheim
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "18.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					ResourceManager resourceManager = new ResourceManager("AliensInValheim.Resources", typeof(Resources).Assembly);
					resourceMan = resourceManager;
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static string PublicKey => ResourceManager.GetString("PublicKey", resourceCulture);

		internal Resources()
		{
		}
	}
}
namespace AliensInValheim.License
{
	public static class LicenseDesencriptor
	{
		private const string Passphrase = "clave-supersecreta-1234";

		public static LicenseInfo LoadLicense(string path)
		{
			if (!File.Exists(path))
			{
				throw new FileNotFoundException("No se encontró el archivo de licencia: " + path);
			}
			byte[] encrypted = File.ReadAllBytes(path);
			string text = DecryptWithAES(encrypted, "clave-supersecreta-1234");
			LicenseInfo licenseInfo = JsonConvert.DeserializeObject<LicenseInfo>(text);
			string licenseJson = GenerateUnsignedJson(licenseInfo);
			if (!VerifyLicenseSignature(licenseJson, licenseInfo.Signature))
			{
				throw new Exception("❌ La firma digital de la licencia no es válida.");
			}
			return licenseInfo;
		}

		private static bool VerifyLicenseSignature(string licenseJson, string base64Signature)
		{
			try
			{
				using RSACryptoServiceProvider rSACryptoServiceProvider = new RSACryptoServiceProvider();
				rSACryptoServiceProvider.PersistKeyInCsp = false;
				string publicKey = Resources.PublicKey;
				rSACryptoServiceProvider.FromXmlString(publicKey);
				byte[] bytes = Encoding.UTF8.GetBytes(licenseJson);
				byte[] array = Convert.FromBase64String(base64Signature);
				return true;
			}
			catch (Exception ex)
			{
				AliensInValheimMod.Logger.LogError((object)("❌ Error verificando firma: " + ex.Message));
				return false;
			}
		}

		public static bool IsLicenseExpired(LicenseInfo license, DateTime nowUtc)
		{
			DateTime dateTime = DateTime.ParseExact(license.IssueDate, "yyyy-MM-dd", null);
			return nowUtc.Date > dateTime.AddDays(license.ValidDays).Date;
		}

		public static bool IsSteamIdValid(LicenseInfo license, string localSteamId)
		{
			return license.SteamId == localSteamId;
		}

		private static string DecryptWithAES(byte[] encrypted, string passphrase)
		{
			using AesCryptoServiceProvider aesCryptoServiceProvider = new AesCryptoServiceProvider();
			aesCryptoServiceProvider.Key = SHA256.Create().ComputeHash(Encoding.UTF8.GetBytes(passphrase));
			aesCryptoServiceProvider.IV = new byte[16];
			using MemoryStream stream = new MemoryStream(encrypted);
			using CryptoStream stream2 = new CryptoStream(stream, aesCryptoServiceProvider.CreateDecryptor(), CryptoStreamMode.Read);
			using StreamReader streamReader = new StreamReader(stream2);
			return streamReader.ReadToEnd();
		}

		private static string GenerateUnsignedJson(LicenseInfo license)
		{
			return $"{{\"SteamId\":\"{license.SteamId}\",\"IssueDate\":\"{license.IssueDate}\",\"ValidDays\":{license.ValidDays}}}";
		}
	}
	internal static class LicenseValidator
	{
		[Serializable]
		public class TimeApiResponse
		{
			public string utc_datetime;
		}

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

			private object <>2__current;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>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>)(() => (Object)(object)ZNet.instance != (Object)null && ZRoutedRpc.instance != null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (ZNet.instance.IsServer())
					{
						ZRoutedRpc.instance.Register<ulong>("Aliens_RequestLicenseValidation", (Action<long, ulong>)Aliens_RequestLicenseValidation);
					}
					else
					{
						ZRoutedRpc.instance.Register<bool>("Aliens_ReceiveLicenseValidation", (Action<long, bool>)Aliens_ReceiveLicenseValidation);
					}
					AliensInValheimMod.Logger.LogInfo((object)"\ud83d\udef0\ufe0f RPCs de licencia registrados correctamente.");
					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 const string RPC_LICENSE_REQUEST = "Aliens_RequestLicenseValidation";

		private const string RPC_LICENSE_RECEIVE = "Aliens_ReceiveLicenseValidation";

		internal static bool isLicenseValid;

		public static LicenseInfo CurrentLicense;

		internal static void RegisterApi(MonoBehaviour context)
		{
			context.StartCoroutine(WaitForRpcReady());
		}

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

		internal static void ValidateRemoteLicense(ulong steamId)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(ZNet.instance.GetServerPeer().m_uid, "Aliens_RequestLicenseValidation", new object[1] { steamId });
		}

		private static void Aliens_ReceiveLicenseValidation(long sender, bool isValid)
		{
			if (!isValid)
			{
				AliensInValheimMod.Logger.LogWarning((object)"\ud83d\udeab Tu licencia no es válida. El mod se desactivará.");
				isLicenseValid = false;
			}
			else
			{
				AliensInValheimMod.Logger.LogInfo((object)"✅ Licencia validada por el servidor.");
				isLicenseValid = true;
			}
		}

		private static void Aliens_RequestLicenseValidation(long sender, ulong steamId)
		{
			AliensInValheimMod.Logger.LogMessage((object)string.Format("{0}❌ ValidateLocalLicense {1}", "AliensInValheim", steamId));
			bool flag = ValidateLocalLicense(steamId);
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "Aliens_ReceiveLicenseValidation", new object[1] { flag });
		}

		public static bool ValidateLocalLicense(ulong steamId)
		{
			bool flag = false;
			AliensInValheimMod.Logger.LogMessage((object)string.Format("{0}❌ ValidateLocalLicense {1}", "AliensInValheim", steamId));
			try
			{
				string[] files = Directory.GetFiles(AliensInValheimMod.modPath, "*.lic");
				if (files.Length == 0)
				{
					AliensInValheimMod.Logger.LogMessage((object)"AliensInValheim❌ No se encontró ningún archivo .lic");
					return false;
				}
				string path = files[0];
				AliensInValheimMod.Logger.LogMessage((object)("AliensInValheim\ud83d\udd0d Usando archivo de licencia: " + Path.GetFileName(path)));
				CurrentLicense = LicenseDesencriptor.LoadLicense(path);
				AliensInValheimMod.Logger.LogMessage((object)string.Format("{0} Licencia encontrada. Expira {1}", "AliensInValheim", CurrentLicense.ExpirationDate));
				if (CurrentLicense.SteamId == steamId.ToString())
				{
					DateTime trustedTime = GetTrustedTime();
					if (CurrentLicense.IsExpired(trustedTime))
					{
						AliensInValheimMod.Logger.LogWarning((object)"AliensInValheim\ud83d\udeab La licencia ha expirado.");
						flag = false;
					}
					else
					{
						AliensInValheimMod.Logger.LogWarning((object)"AliensInValheim✅ Licencia válida.");
						flag = true;
					}
				}
				else
				{
					AliensInValheimMod.Logger.LogWarning((object)"AliensInValheim\ud83d\udeab SteamID no coincide con el de la licencia.");
					flag = false;
				}
			}
			catch (Exception ex)
			{
				AliensInValheimMod.Logger.LogError((object)("❌ Error validando licencia: " + ex.Message));
				flag = false;
			}
			isLicenseValid = flag;
			return flag;
		}

		private static DateTime GetTrustedTime()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			try
			{
				UnityWebRequest val = UnityWebRequest.Get("https://worldtimeapi.org/api/timezone/Etc/UTC");
				val.SendWebRequest();
				while (!val.isDone)
				{
				}
				if ((int)val.result == 1)
				{
					TimeApiResponse timeApiResponse = JsonUtility.FromJson<TimeApiResponse>(val.downloadHandler.text);
					return DateTime.Parse(timeApiResponse.utc_datetime);
				}
			}
			catch (Exception)
			{
				AliensInValheimMod.Logger.LogWarning((object)"⚠\ufe0f No se pudo obtener la hora confiable");
				return DateTime.UtcNow;
			}
			return DateTime.UtcNow;
		}
	}
	public class LicenseInfo
	{
		public string SteamId;

		public string IssueDate;

		public int ValidDays;

		public string Signature;

		public DateTime ExpirationDate => DateTime.ParseExact(IssueDate, "yyyy-MM-dd", CultureInfo.InvariantCulture).AddDays(ValidDays);

		public bool IsExpired(DateTime currentTimeUtc)
		{
			return currentTimeUtc.Date > ExpirationDate.Date;
		}

		public static LicenseInfo FromJson(string json)
		{
			return JsonUtility.FromJson<LicenseInfo>(json);
		}
	}
}
namespace AliensInValheim.Intro
{
	public class MainMenuUFO : MonoBehaviour
	{
		private GameObject ufoInstance;

		private AudioSource ufoMusicSource;

		private void Start()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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: Unknown result type (might be due to invalid IL or missing references)
			OvniConfiguration ovniConfiguration = new OvniConfiguration();
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name.ToLower() != "start")
			{
				return;
			}
			AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] Menú principal detectado. Iniciando OVNI...");
			GameObject val = AliensInValheimMod.Instance.Library.LoadAsset<GameObject>(ovniConfiguration.PrefabName);
			if ((Object)(object)val == (Object)null)
			{
				AliensInValheimMod.Logger.LogWarning((object)"[AliensInValheim] ❌ No se pudo cargar el prefab del OVNI.");
				return;
			}
			ufoInstance = Object.Instantiate<GameObject>(val);
			((Object)ufoInstance).name = "MainMenuUFO";
			Camera main = Camera.main;
			if ((Object)(object)main == (Object)null)
			{
				AliensInValheimMod.Logger.LogWarning((object)"[AliensInValheim] ❌ No se encontró la cámara del menú.");
				return;
			}
			Vector3 val2 = ((Component)main).transform.forward * 100f + ((Component)main).transform.up * 20f;
			ufoInstance.transform.position = ((Component)main).transform.position + val2;
			ufoInstance.transform.LookAt(((Component)main).transform.position);
			ufoInstance.transform.localScale = Vector3.one * 10f;
			ufoMusicSource = ufoInstance.AddComponent<AudioSource>();
			ufoMusicSource.AttachToGameMixer(SoundGroup.Music);
			ufoMusicSource.clip = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>("assets/sounds/ufo_music2.mp3");
			ufoMusicSource.loop = true;
			ufoMusicSource.playOnAwake = false;
			ufoMusicSource.ignoreListenerVolume = true;
			if ((Object)(object)ufoMusicSource.clip != (Object)null)
			{
				ufoMusicSource.Play();
				AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] \ud83c\udfb5 Música del OVNI iniciada.");
			}
			else
			{
				AliensInValheimMod.Logger.LogWarning((object)"[AliensInValheim] ⚠\ufe0f No se encontró el AudioClip del OVNI.");
			}
		}

		private void Update()
		{
			//IL_0033: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			((MonoBehaviour)this).StartCoroutine(MusicDucker.Duck());
			if ((Object)(object)ufoInstance != (Object)null)
			{
				ufoInstance.transform.Rotate(Vector3.up * 20f * Time.deltaTime, (Space)0);
			}
		}

		private void OnDestroy()
		{
			((MonoBehaviour)this).StartCoroutine(MusicDucker.Unduck());
			Object.Destroy((Object)(object)ufoInstance);
			AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] \ud83d\udd0a Volumen restaurado al salir del menú.");
		}
	}
	internal class IntroductionScene : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <FadeIn>d__13 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public IntroductionScene <>4__this;

			private float <duration>5__1;

			private float <t>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<duration>5__1 = 1.5f;
					<t>5__2 = 0f;
					break;
				case 2:
					<>1__state = -1;
					<t>5__2 += Time.deltaTime;
					break;
				}
				if (<t>5__2 < <duration>5__1)
				{
					if ((Object)(object)<>4__this.introText != (Object)null)
					{
						((TMP_Text)<>4__this.introText).alpha = Mathf.Lerp(0f, 1f, <t>5__2 / <duration>5__1);
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				if ((Object)(object)<>4__this.introText != (Object)null)
				{
					((TMP_Text)<>4__this.introText).alpha = 1f;
				}
				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 TextMeshProUGUI introText;

		private AudioClip introMusic;

		private TMP_FontAsset introFont;

		private float crawlSpeed = 40f;

		private AudioSource audioSource;

		private RectTransform textRect;

		private bool duckStarted = false;

		private void Awake()
		{
			AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] Awake Introduccion...");
			TryLoadAssets();
			Inicialize();
			ConfigureText();
			ConfigureAudio();
		}

		private void TryLoadAssets()
		{
			introMusic = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>("assets/sounds/ufo_music1.mp3");
			TextMeshProUGUI val = Object.FindAnyObjectByType<TextMeshProUGUI>();
			if ((Object)(object)val != (Object)null && (Object)(object)((TMP_Text)val).font != (Object)null)
			{
				introFont = ((TMP_Text)val).font;
				AliensInValheimMod.Logger.LogInfo((object)("[Intro] Fuente del juego usada: " + ((Object)((TMP_Text)val).font).name));
			}
			else
			{
				AliensInValheimMod.Logger.LogWarning((object)"[Intro] No se encontró ninguna fuente TMP activa en el juego, se usará la default.");
			}
			if ((Object)(object)introFont == (Object)null)
			{
				AliensInValheimMod.Logger.LogWarning((object)"[Intro] TMP_FontAsset 'AlienFont SDF' no encontrado en el bundle. Asignar uno es obligatorio.");
			}
		}

		private void Inicialize()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			Camera main = Camera.main;
			Canvas val = ((Component)this).gameObject.AddComponent<Canvas>();
			val.renderMode = (RenderMode)2;
			val.worldCamera = main;
			CanvasScaler val2 = ((Component)this).gameObject.AddComponent<CanvasScaler>();
			val2.dynamicPixelsPerUnit = 10f;
			((Component)this).gameObject.AddComponent<GraphicRaycaster>();
			RectTransform component = ((Component)val).GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(1920f, 1080f);
			((Transform)component).localScale = Vector3.one * 0.005f;
			((Transform)component).position = ((Component)main).transform.position + ((Component)main).transform.forward * 5f;
			((Transform)component).rotation = Quaternion.Euler(30f, 0f, 0f);
			GameObject val3 = new GameObject("IntroText", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(((Component)this).gameObject.transform, false);
			introText = val3.AddComponent<TextMeshProUGUI>();
			((TMP_Text)introText).alignment = (TextAlignmentOptions)514;
			((Graphic)introText).color = Color.yellow;
			((TMP_Text)introText).fontSize = 120f;
			((TMP_Text)introText).enableAutoSizing = true;
			((TMP_Text)introText).enableWordWrapping = true;
			((Graphic)introText).raycastTarget = false;
			if ((Object)(object)introFont != (Object)null)
			{
				((TMP_Text)introText).font = introFont;
			}
			textRect = ((Component)introText).GetComponent<RectTransform>();
			textRect.sizeDelta = new Vector2(1800f, 4000f);
			((Transform)textRect).localPosition = new Vector3(0f, -2000f, 0f);
		}

		private void Start()
		{
			AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] Iniciando Introduccion...");
			if ((Object)(object)introText != (Object)null)
			{
				((TMP_Text)introText).alpha = 0f;
				((MonoBehaviour)this).StartCoroutine(FadeIn());
			}
			if (!duckStarted)
			{
				duckStarted = true;
				((MonoBehaviour)this).StartCoroutine(MusicDucker.Duck());
			}
		}

		private void ConfigureText()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)introText == (Object)null))
			{
				((TMP_Text)introText).text = Loc.T("aliens_intro");
				((Transform)textRect).localPosition = new Vector3(0f, -1600f, 0f);
			}
		}

		private void ConfigureAudio()
		{
			audioSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			audioSource.AttachToGameMixer(SoundGroup.Music);
			audioSource.clip = introMusic;
			audioSource.playOnAwake = false;
			audioSource.loop = false;
			audioSource.ignoreListenerVolume = true;
			if ((Object)(object)introMusic != (Object)null)
			{
				audioSource.Play();
			}
		}

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

		private void Update()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)textRect == (Object)null))
			{
				RectTransform obj = textRect;
				((Transform)obj).localPosition = ((Transform)obj).localPosition + new Vector3(0f, crawlSpeed * Time.deltaTime, 0f);
				if (((Transform)textRect).localPosition.y > 3000f)
				{
					Stop();
				}
			}
		}

		internal void Stop()
		{
			((MonoBehaviour)this).StartCoroutine(MusicDucker.Unduck());
			if ((Object)(object)audioSource != (Object)null)
			{
				audioSource.Stop();
			}
			Object.Destroy((Object)(object)((Component)((Component)this).transform.root).gameObject);
		}
	}
}
namespace AliensInValheim.Abuction
{
	public class AbductionCommand : ConsoleCommand
	{
		public override string Name => "abducir";

		public override string Help => "Abduce un jugador con un ovni. Uso: abducir [jugador] [ovni_id]\nEjemplos:\n - abducir => te abduce con OVNI aleatorio\n - abducir 2 => te abduce con OVNI #2 (índice 1)\n - abducir NombreJugador => abduce a ese jugador con OVNI aleatorio\n - abducir NombreJugador 3 => abduce a ese jugador con OVNI #3 (índice 2)";

		public override void Run(string[] args)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Player target = Player.m_localPlayer;
			PlayerExtensions.SolvePlayerAndConfiguration(args, out target, out var config);
			AbductionRPC instance = AbductionRPC.Instance;
			AbductionData abductionData = new AbductionData();
			ZDOID zDOID = ((Character)target).GetZDOID();
			abductionData.UserID = ((ZDOID)(ref zDOID)).UserID;
			abductionData.Config = config;
			instance.SendCommandToAll(AbductionRPC.CommandName.START_ABDUCTION, abductionData);
			AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] \ud83d\udef8 Abducción solicitada para " + target.GetPlayerName() + " con OVNI " + config.PrefabName));
		}
	}
	internal class AbductionEvent : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <EndAbuction>d__10 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AbductionEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					AliensInValheimMod.Logger.LogInfo((object)"AliensInValheim \ud83d\udef8 El ovni se retira.");
					((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.musicSource.FadeOutAudio(3f));
					((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.ovni.FadeOutAndStopAudio(SoundChannel.ENGINE, 3f));
					((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.ovni.FadeOutAndStopAudio(SoundChannel.BACKGROUND, 2f));
					((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FadeAndDestroy(<>4__this.ovni));
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					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 <FadeAndDestroy>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject obj;

			public AbductionEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = obj.FadeAndWarpAway();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Object.Destroy((Object)(object)obj);
					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 <HorizontalMovement>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public GameObject ovni;

			public AbductionEvent <>4__this;

			private Vector3 <start>5__1;

			private Vector3 <end>5__2;

			private float <horizontalDuration>5__3;

			private float <t>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: 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_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_005d: 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_0067: 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_0088: 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_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_00a6: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<start>5__1 = ((Component)player).transform.position + ((Component)player).transform.right * 80f + Vector3.up * 30f;
					<end>5__2 = ((Component)player).transform.position + ((Component)player).transform.right * 10f + Vector3.up * 30f;
					ovni.transform.position = <start>5__1;
					<horizontalDuration>5__3 = 5f;
					<t>5__4 = 0f;
					break;
				case 1:
					<>1__state = -1;
					<t>5__4 += Time.deltaTime;
					break;
				}
				if (<t>5__4 < <horizontalDuration>5__3)
				{
					ovni.transform.position = Vector3.Lerp(<start>5__1, <end>5__2, <t>5__4 / <horizontalDuration>5__3);
					<>2__current = null;
					<>1__state = 1;
					return 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 <RunAbductionSequence>d__9 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public OvniConfiguration config;

			public AbductionEvent <>4__this;

			private Vector3 <above>5__1;

			private Vector3 <start>5__2;

			private float <suspenseDuration>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 3)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: 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_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: 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_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<above>5__1 = ((Component)player).transform.position + Vector3.up * 30f;
						<start>5__2 = <above>5__1 + ((Component)player).transform.right * 80f;
						<>4__this.ovni = AliensInValheimMod.Instance.Library.CreateOvni(<start>5__2, config);
						AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] Secuencia de abduccion sobre " + player.GetPlayerName()));
						<>2__current = <>4__this.HorizontalMovement(player, <>4__this.ovni);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>4__this.PlayLoopingMusic(0.7f);
						<>4__this.ovni.PlaySound(SoundChannel.ENGINE);
						<>4__this.ovni.PlaySound(SoundChannel.BACKGROUND);
						<>2__current = <>4__this.VerticalDescend(player, <>4__this.ovni);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						<>1__state = -3;
						<suspenseDuration>5__3 = Random.Range(15f, 30f);
						<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.AbductionMiniGame.StartGame(player, <>4__this.ovni, <suspenseDuration>5__3));
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -3;
						<>m__Finally1();
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				<>1__state = -1;
				AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] Finalizando abduccion sobre " + player.GetPlayerName()));
				AbductionRPC instance = AbductionRPC.Instance;
				AbductionData abductionData = new AbductionData();
				ZDOID zDOID = ((Character)player).GetZDOID();
				abductionData.UserID = ((ZDOID)(ref zDOID)).UserID;
				abductionData.Config = new OvniConfiguration();
				instance.SendCommandToAll(AbductionRPC.CommandName.FINISH_ABDUCTION, abductionData);
			}

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

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

			private object <>2__current;

			public Player player;

			public GameObject ovni;

			public AbductionEvent <>4__this;

			private Vector3 <descentStart>5__1;

			private Vector3 <descentEnd>5__2;

			private float <descentDuration>5__3;

			private float <t>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: 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)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: 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_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<descentStart>5__1 = ovni.transform.position;
					<descentEnd>5__2 = ((Component)player).transform.position + Vector3.up * 10f;
					<descentDuration>5__3 = 4f;
					<t>5__4 = 0f;
					break;
				case 1:
					<>1__state = -1;
					<t>5__4 += Time.deltaTime;
					break;
				}
				if (<t>5__4 < <descentDuration>5__3)
				{
					ovni.transform.position = Vector3.Lerp(<descentStart>5__1, <descentEnd>5__2, <t>5__4 / <descentDuration>5__3);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				ovni.transform.position = <descentEnd>5__2;
				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 AudioSource musicSource;

		private GameObject ovni = null;

		private AbductionMiniGameEvent AbductionMiniGame => ((Component)this).gameObject.GetComponent<AbductionMiniGameEvent>();

		private void Awake()
		{
			musicSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			musicSource.volume = 0.4f;
			musicSource.spatialBlend = 0f;
			musicSource.playOnAwake = false;
			musicSource.loop = true;
			((Component)this).gameObject.AddComponent<AbductionMiniGameEvent>();
		}

		[IteratorStateMachine(typeof(<HorizontalMovement>d__4))]
		private IEnumerator HorizontalMovement(Player player, GameObject ovni)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HorizontalMovement>d__4(0)
			{
				<>4__this = this,
				player = player,
				ovni = ovni
			};
		}

		[IteratorStateMachine(typeof(<VerticalDescend>d__5))]
		private IEnumerator VerticalDescend(Player player, GameObject ovni)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <VerticalDescend>d__5(0)
			{
				<>4__this = this,
				player = player,
				ovni = ovni
			};
		}

		public void PlayLoopingMusic(float volume = 1f)
		{
			AudioClip val = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>("assets/sounds/ufo_music1.mp3");
			if (musicSource.isPlaying)
			{
				musicSource.Stop();
			}
			if (!musicSource.isPlaying)
			{
				musicSource.volume = volume;
				musicSource.clip = val;
				musicSource.loop = true;
				musicSource.Play();
				AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] Música reproducida: " + ((Object)val).name));
			}
			else
			{
				AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] La música ya está sonando, se omite reproducción duplicada.");
			}
		}

		[IteratorStateMachine(typeof(<FadeAndDestroy>d__7))]
		internal IEnumerator FadeAndDestroy(GameObject obj)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeAndDestroy>d__7(0)
			{
				<>4__this = this,
				obj = obj
			};
		}

		[IteratorStateMachine(typeof(<RunAbductionSequence>d__9))]
		public IEnumerator RunAbductionSequence(Player player, OvniConfiguration config)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RunAbductionSequence>d__9(0)
			{
				<>4__this = this,
				player = player,
				config = config
			};
		}

		[IteratorStateMachine(typeof(<EndAbuction>d__10))]
		internal IEnumerator EndAbuction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EndAbuction>d__10(0)
			{
				<>4__this = this
			};
		}
	}
	public class AbductionMiniGameEvent : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ShowRewardForPlayer>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public AbductionMiniGameEvent <>4__this;

			private Vector3 <groundPos>5__1;

			private GameObject <chestPrefab>5__2;

			private GameObject <coinPrefab>5__3;

			private GameObject <chest>5__4;

			private ZNetView <chestView>5__5;

			private Container <container>5__6;

			private AudioSource <coinAudioSource>5__7;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<chestPrefab>5__2 = null;
				<coinPrefab>5__3 = null;
				<chest>5__4 = null;
				<chestView>5__5 = null;
				<container>5__6 = null;
				<coinAudioSource>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: 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_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<groundPos>5__1 = ((Component)player).transform.position + ((Component)player).transform.right * 2f;
				<chestPrefab>5__2 = ZNetScene.instance.GetPrefab("piece_chest");
				<coinPrefab>5__3 = ZNetScene.instance.GetPrefab("Coins");
				if ((Object)(object)<chestPrefab>5__2 == (Object)null || (Object)(object)<coinPrefab>5__3 == (Object)null)
				{
					AliensInValheimMod.Logger.LogInfo((object)"⚠\ufe0f No se encontró el prefab de cofre o monedas.");
					return false;
				}
				AliensInValheimMod.Logger.LogInfo((object)"✅ Prefabs encontrados. Instanciando cofre...");
				<chest>5__4 = Object.Instantiate<GameObject>(<chestPrefab>5__2, <groundPos>5__1, Quaternion.identity);
				<chestView>5__5 = <chest>5__4.GetComponent<ZNetView>();
				if ((Object)(object)<chestView>5__5 == (Object)null || !<chestView>5__5.IsValid())
				{
					AliensInValheimMod.Logger.LogInfo((object)"❌ ZNetView inválido al instanciar el cofre.");
					return false;
				}
				<chestView>5__5.GetZDO().Set(ZDOVars.s_creator, player.GetPlayerID());
				<container>5__6 = <chest>5__4.GetComponent<Container>();
				if ((Object)(object)<container>5__6 != (Object)null && <container>5__6.GetInventory() != null)
				{
					<container>5__6.GetInventory().AddItem(<coinPrefab>5__3, 100);
					AliensInValheimMod.Logger.LogInfo((object)"\ud83d\udcb0 Monedas añadidas al cofre.");
				}
				else
				{
					AliensInValheimMod.Logger.LogInfo((object)"❌ Contenedor o inventario no válido en el cofre.");
				}
				<coinAudioSource>5__7 = <coinPrefab>5__3.GetComponentInChildren<AudioSource>();
				if ((Object)(object)<coinAudioSource>5__7 != (Object)null && (Object)(object)<coinAudioSource>5__7.clip != (Object)null)
				{
					AudioSource.PlayClipAtPoint(<coinAudioSource>5__7.clip, <groundPos>5__1, 1f);
					AliensInValheimMod.Logger.LogInfo((object)"\ud83d\udd0a Sonido de monedas reproducido.");
				}
				else
				{
					AliensInValheimMod.Logger.LogInfo((object)"⚠\ufe0f No se encontró clip de audio en prefab Coins.");
				}
				((Character)player).Message((MessageType)2, "<color=yellow>¡Has recibido una recompensa alienígena!</color>", 0, (Sprite)null);
				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 <StartAbduction>d__10 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public AbductionMiniGameEvent <>4__this;

			private Vector3 <basePos>5__1;

			private Vector3 <side>5__2;

			private Vector3 <spawnPos>5__3;

			private GameObject <alien>5__4;

			private AlienParalysis <paralysis>5__5;

			private Coroutine <paralysisCo>5__6;

			private Light <light>5__7;

			private Vector3 <lootPos>5__8;

			private Vector3 <targetPos>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<alien>5__4 = null;
				<paralysis>5__5 = null;
				<paralysisCo>5__6 = null;
				<light>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_029d: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ee: Expected O, but got Unknown
				//IL_0310: Unknown result type (might be due to invalid IL or missing references)
				//IL_031a: Unknown result type (might be due to invalid IL or missing references)
				//IL_031f: Unknown result type (might be due to invalid IL or missing references)
				//IL_032b: Unknown result type (might be due to invalid IL or missing references)
				//IL_033b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0270: Unknown result type (might be due to invalid IL or missing references)
				//IL_0281: Unknown result type (might be due to invalid IL or missing references)
				//IL_028b: Expected O, but got Unknown
				//IL_0353: Unknown result type (might be due to invalid IL or missing references)
				//IL_0364: Unknown result type (might be due to invalid IL or missing references)
				//IL_036a: Unknown result type (might be due to invalid IL or missing references)
				//IL_039c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: 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_00a1: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if ((Object)(object)player == (Object)null || ((Character)player).IsDead() || ((Character)player).IsTeleporting())
					{
						AliensInValheimMod.Logger.LogInfo((object)"\ud83d\udeab Jugador no válido para abducción forzada.");
						return false;
					}
					<basePos>5__1 = ((Component)player).transform.position;
					<side>5__2 = ((Component)player).transform.right;
					<spawnPos>5__3 = <basePos>5__1 + <side>5__2 * 2.2f;
					<alien>5__4 = AliensInValheimMod.Instance.Library.CreateAlien(<spawnPos>5__3, "Assets/Alien1/Prefab/alien1.prefab");
					if ((Object)(object)<alien>5__4 == (Object)null)
					{
						AliensInValheimMod.Logger.LogWarning((object)"⚠\ufe0f No se pudo instanciar el Alien.");
						return false;
					}
					LookAtHorizontal(<alien>5__4.transform, ((Component)player).transform.position);
					AliensInValheimMod.Logger.LogInfo((object)("\ud83d\udc80 Jugador " + player.GetPlayerName() + " perdió el minijuego. Abducción forzada iniciada."));
					<paralysis>5__5 = ((Component)player).GetComponent<AlienParalysis>();
					if ((Object)(object)<paralysis>5__5 == (Object)null)
					{
						<paralysis>5__5 = ((Component)player).gameObject.AddComponent<AlienParalysis>();
					}
					<paralysisCo>5__6 = ((MonoBehaviour)<>4__this).StartCoroutine(<paralysis>5__5.DoParalysis(player, 30f));
					Chat instance2 = Chat.instance;
					if (instance2 != null)
					{
						instance2.SendText((Type)2, "¡" + player.GetPlayerName() + " ha sido derrotado y será abducido!");
					}
					((Character)player).Message((MessageType)1, "<color=red>Has perdido... algo se acerca.</color>", 0, (Sprite)null);
					<>2__current = <>4__this.TeleportInAlien(<spawnPos>5__3, <alien>5__4);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					<light>5__7 = <alien>5__4.GetComponent<Light>() ?? <alien>5__4.AddComponent<Light>();
					<light>5__7.type = (LightType)2;
					<light>5__7.range = 10f;
					<light>5__7.intensity = 4f;
					<light>5__7.color = Color.red;
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<lootPos>5__8 = <basePos>5__1 + ((Component)player).transform.forward * 2f;
					<>4__this.DropInventory(player, <lootPos>5__8);
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 3;
					return true;
				case 3:
				{
					<>1__state = -1;
					<targetPos>5__9 = <>4__this.FindSafeTeleportLocation(((Component)player).transform.position, 200f);
					((Character)player).TeleportTo(<targetPos>5__9, ((Component)player).transform.rotation, true);
					Minimap instance = Minimap.instance;
					if (instance != null)
					{
						instance.AddPin(<targetPos>5__9, (PinType)4, "Abducción", true, false, 0L, default(PlatformUserID));
					}
					((Character)player).Message((MessageType)1, "<color=gray>Despiertas en un lugar extraño... más frío.</color>", 0, (Sprite)null);
					AliensInValheimMod.Logger.LogInfo((object)$"\ud83d\udef8 {player.GetPlayerName()} abducido tras perder. Teleportado a {<targetPos>5__9}");
					Object.Destroy((Object)(object)<alien>5__4);
					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 <StartGame>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player targetPlayer;

			public GameObject ovni;

			public float suspenseDuration;

			public AbductionMiniGameEvent <>4__this;

			private GameObject <beam>5__1;

			private float <timer>5__2;

			private float <progress>5__3;

			private bool <uiShown>5__4;

			private Vector3 <targetPosition>5__5;

			private Vector3 <from>5__6;

			private Vector3 <to>5__7;

			private float <distance>5__8;

			private Exception <exPerFrame>5__9;

			private Exception <exHidePB>5__10;

			private Exception <exHide>5__11;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<beam>5__1 = null;
				<exPerFrame>5__9 = null;
				<exHidePB>5__10 = null;
				<exHide>5__11 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_0197: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_020b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0210: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_021f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0224: Unknown result type (might be due to invalid IL or missing references)
				//IL_0235: Unknown result type (might be due to invalid IL or missing references)
				//IL_023b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				//IL_024a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0261: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0274: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						AliensInValheimMod.Logger.LogDebug((object)"[AbductionMiniGame] Iniciando minijuego...");
						<beam>5__1 = null;
						<timer>5__2 = 0f;
						<progress>5__3 = 0f;
						<uiShown>5__4 = false;
						<>1__state = -3;
						<beam>5__1 = ovni.transform.CreateBeam(((Component)targetPlayer).transform);
						<uiShown>5__4 = true;
						<>4__this.progressBar.Show();
						goto IL_030c;
					case 1:
						<>1__state = -3;
						goto IL_030c;
					case 2:
						<>1__state = -1;
						break;
					case 3:
						{
							<>1__state = -1;
							break;
						}
						IL_030c:
						if (<timer>5__2 < suspenseDuration)
						{
							try
							{
								<timer>5__2 += Time.deltaTime;
								if (!Input.GetKeyDown(<>4__this.jumpKey))
								{
									<progress>5__3 -= 10f * Time.deltaTime;
									if (<progress>5__3 < 0f)
									{
										<progress>5__3 = 0f;
									}
									goto IL_0155;
								}
								<progress>5__3 += 9f;
								if (!(<progress>5__3 >= 100f))
								{
									goto IL_0155;
								}
								<progress>5__3 = 100f;
								goto end_IL_00bb;
								IL_0155:
								<>4__this.progressBar.SetValue(<progress>5__3 / 100f);
								<targetPosition>5__5 = ((Component)targetPlayer).transform.position + Vector3.up * 10f;
								ovni.transform.position = Vector3.Lerp(ovni.transform.position, <targetPosition>5__5, Time.deltaTime * 5f);
								if ((Object)(object)<beam>5__1 != (Object)null)
								{
									<from>5__6 = ovni.transform.position;
									<to>5__7 = ((Component)targetPlayer).transform.position + Vector3.up * 1.5f;
									<beam>5__1.transform.position = (<from>5__6 + <to>5__7) / 2f;
									<beam>5__1.transform.LookAt(<to>5__7);
									<distance>5__8 = Vector3.Distance(<from>5__6, <to>5__7);
									<beam>5__1.transform.localScale = new Vector3(1f, <distance>5__8 / 2f, 1f);
								}
								<>4__this.KillNearbyEnemies(targetPlayer);
								goto IL_02ee;
								end_IL_00bb:;
							}
							catch (Exception ex)
							{
								<exPerFrame>5__9 = ex;
								AliensInValheimMod.Logger.LogWarning((object)$"[AbductionMiniGame] Excepción frame: {<exPerFrame>5__9}");
								goto IL_02ee;
							}
						}
						<>m__Finally1();
						if (<progress>5__3 >= 100f)
						{
							AliensInValheimMod.Logger.LogInfo((object)"\ud83d\ude4c El jugador escapó de la abducción.");
							<>2__current = <>4__this.ShowRewardForPlayer(targetPlayer);
							<>1__state = 2;
							return true;
						}
						<>2__current = <>4__this.StartAbduction(targetPlayer);
						<>1__state = 3;
						return true;
						IL_02ee:
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				try
				{
					<>4__this.progressBar.Hide();
				}
				catch (Exception ex)
				{
					<exHidePB>5__10 = ex;
					AliensInValheimMod.Logger.LogWarning((object)$"[AbductionMiniGame] progressBar.Hide() falló: {<exHidePB>5__10}");
				}
				if (<uiShown>5__4)
				{
					try
					{
						AlienUI.Hide();
						AliensInValheimMod.Logger.LogDebug((object)"[AbductionMiniGame] AlienUI.Hide() ejecutado.");
					}
					catch (Exception ex)
					{
						<exHide>5__11 = ex;
						AliensInValheimMod.Logger.LogWarning((object)$"[AbductionMiniGame] AlienUI.Hide() falló: {<exHide>5__11}");
					}
				}
				if ((Object)(object)<beam>5__1 != (Object)null)
				{
					Object.Destroy((Object)(object)<beam>5__1);
				}
			}

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

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

			private object <>2__current;

			public Player targetPlayer;

			public GameObject ovni;

			public float suspenseDuration;

			public AbductionMiniGameEvent <>4__this;

			private GameObject <beam>5__1;

			private float <timer>5__2;

			private bool <uiShown>5__3;

			private GameObject <obj>5__4;

			private AbductionEvent <abduction>5__5;

			private Vector3 <targetPosition>5__6;

			private Vector3 <from>5__7;

			private Vector3 <to>5__8;

			private float <distance>5__9;

			private Exception <exPerFrame>5__10;

			private Exception <exHide>5__11;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<beam>5__1 = null;
				<obj>5__4 = null;
				<abduction>5__5 = null;
				<exPerFrame>5__10 = null;
				<exHide>5__11 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_024c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0256: Expected O, but got Unknown
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: 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_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_014c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: Unknown result type (might be due to invalid IL or missing references)
				//IL_016d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: 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)
				//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						AliensInValheimMod.Logger.LogDebug((object)"[AbductionMiniGame] Iniciando minijuego (viewer)...");
						<beam>5__1 = null;
						<timer>5__2 = 0f;
						<uiShown>5__3 = false;
						<>1__state = -3;
						<beam>5__1 = ovni.transform.CreateBeam(((Component)targetPlayer).transform);
						AlienUI.ShowProgressBar("¡Presiona ESPACIO para resistir la abducción!");
						<uiShown>5__3 = true;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<timer>5__2 < suspenseDuration)
					{
						try
						{
							<timer>5__2 += Time.deltaTime;
							<targetPosition>5__6 = ((Component)targetPlayer).transform.position + Vector3.up * 10f;
							ovni.transform.position = Vector3.Lerp(ovni.transform.position, <targetPosition>5__6, Time.deltaTime * 5f);
							if ((Object)(object)<beam>5__1 != (Object)null)
							{
								<from>5__7 = ovni.transform.position;
								<to>5__8 = ((Component)targetPlayer).transform.position + Vector3.up * 1.5f;
								<beam>5__1.transform.position = (<from>5__7 + <to>5__8) / 2f;
								<beam>5__1.transform.LookAt(<to>5__8);
								<distance>5__9 = Vector3.Distance(<from>5__7, <to>5__8);
								<beam>5__1.transform.localScale = new Vector3(1f, <distance>5__9 / 2f, 1f);
							}
						}
						catch (Exception ex)
						{
							<exPerFrame>5__10 = ex;
							AliensInValheimMod.Logger.LogWarning((object)$"[AbductionMiniGame Viewer] Excepción frame: {<exPerFrame>5__10}");
						}
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<obj>5__4 = new GameObject("AbductionEvent");
					<abduction>5__5 = <obj>5__4.AddComponent<AbductionEvent>();
					Object.DontDestroyOnLoad((Object)(object)<obj>5__4);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				try
				{
					if (<uiShown>5__3)
					{
						AlienUI.Hide();
					}
				}
				catch (Exception ex)
				{
					<exHide>5__11 = ex;
					AliensInValheimMod.Logger.LogWarning((object)$"[Viewer] AlienUI.Hide() falló: {<exHide>5__11}");
				}
				if ((Object)(object)<beam>5__1 != (Object)null)
				{
					Object.Destroy((Object)(object)<beam>5__1);
				}
			}

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

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

			private object <>2__current;

			public Vector3 spawnPos;

			public GameObject alien;

			public AbductionMiniGameEvent <>4__this;

			private GameObject <lightObj>5__1;

			private Light <beamLight>5__2;

			private GameObject <particleObj>5__3;

			private ParticleSystem <ps>5__4;

			private MainModule <main>5__5;

			private ShapeModule <shape>5__6;

			private EmissionModule <emission>5__7;

			private float <duration>5__8;

			private float <t>5__9;

			private float <progress>5__10;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: 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)
				<lightObj>5__1 = null;
				<beamLight>5__2 = null;
				<particleObj>5__3 = null;
				<ps>5__4 = null;
				<main>5__5 = default(MainModule);
				<shape>5__6 = default(ShapeModule);
				<emission>5__7 = default(EmissionModule);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Expected O, but got Unknown
				//IL_00e6: 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_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: 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_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0266: Unknown result type (might be due to invalid IL or missing references)
				//IL_0280: Unknown result type (might be due to invalid IL or missing references)
				//IL_0311: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<lightObj>5__1 = new GameObject("TeleportBeamLight");
					<lightObj>5__1.transform.position = spawnPos + Vector3.up * 1.5f;
					<beamLight>5__2 = <lightObj>5__1.AddComponent<Light>();
					<beamLight>5__2.type = (LightType)2;
					<beamLight>5__2.range = 8f;
					<beamLight>5__2.intensity = 0f;
					<beamLight>5__2.color = Color.cyan;
					<beamLight>5__2.shadows = (LightShadows)2;
					<particleObj>5__3 = new GameObject("TeleportParticles");
					<particleObj>5__3.transform.position = spawnPos;
					<ps>5__4 = <particleObj>5__3.AddComponent<ParticleSystem>();
					<main>5__5 = <ps>5__4.main;
					((MainModule)(ref <main>5__5)).duration = 2f;
					((MainModule)(ref <main>5__5)).startLifetime = MinMaxCurve.op_Implicit(1f);
					((MainModule)(ref <main>5__5)).startSpeed = MinMaxCurve.op_Implicit(2f);
					((MainModule)(ref <main>5__5)).startSize = MinMaxCurve.op_Implicit(0.3f);
					((MainModule)(ref <main>5__5)).loop = false;
					((MainModule)(ref <main>5__5)).simulationSpace = (ParticleSystemSimulationSpace)1;
					<shape>5__6 = <ps>5__4.shape;
					((ShapeModule)(ref <shape>5__6)).shapeType = (ParticleSystemShapeType)8;
					((ShapeModule)(ref <shape>5__6)).angle = 0f;
					((ShapeModule)(ref <shape>5__6)).radius = 0.5f;
					((ShapeModule)(ref <shape>5__6)).length = 3f;
					<emission>5__7 = <ps>5__4.emission;
					((EmissionModule)(ref <emission>5__7)).rateOverTime = MinMaxCurve.op_Implicit(40f);
					<ps>5__4.Play();
					alien.transform.localScale = Vector3.zero;
					<duration>5__8 = 2f;
					<t>5__9 = 0f;
					goto IL_02cf;
				case 1:
					<>1__state = -1;
					goto IL_02cf;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_02cf:
					if (<t>5__9 < <duration>5__8)
					{
						<t>5__9 += Time.deltaTime;
						<progress>5__10 = <t>5__9 / <duration>5__8;
						alien.transform.localScale = Vector3.one * Mathf.SmoothStep(0f, 1f, <progress>5__10);
						<beamLight>5__2.intensity = Mathf.Lerp(0f, 6f, Mathf.Sin(<progress>5__10 * (float)Math.PI));
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					Object.Destroy((Object)(object)<particleObj>5__3, 2f);
					Object.Destroy((Object)(object)<lightObj>5__1, 2f);
					alien.transform.localScale = Vector3.one;
					<>2__current = alien;
					<>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();
			}
		}

		internal KeyCode jumpKey = (KeyCode)32;

		private const float MaxProgress = 100f;

		private AlienProgressBar progressBar => ((Component)this).gameObject.GetComponent<AlienProgressBar>();

		private void Awake()
		{
			AliensInValheimMod.Logger.LogDebug((object)"[AbductionMiniGame] AbductionMiniGameEvent Awake");
			((Component)this).gameObject.AddComponent<AlienProgressBar>();
		}

		[IteratorStateMachine(typeof(<ShowRewardForPlayer>d__5))]
		internal IEnumerator ShowRewardForPlayer(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ShowRewardForPlayer>d__5(0)
			{
				<>4__this = this,
				player = player
			};
		}

		[IteratorStateMachine(typeof(<StartGame>d__6))]
		public IEnumerator StartGame(Player targetPlayer, GameObject ovni, float suspenseDuration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartGame>d__6(0)
			{
				<>4__this = this,
				targetPlayer = targetPlayer,
				ovni = ovni,
				suspenseDuration = suspenseDuration
			};
		}

		[IteratorStateMachine(typeof(<TeleportInAlien>d__7))]
		private IEnumerator TeleportInAlien(Vector3 spawnPos, GameObject alien)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TeleportInAlien>d__7(0)
			{
				<>4__this = this,
				spawnPos = spawnPos,
				alien = alien
			};
		}

		private Vector3 FindSafeTeleportLocation(Vector3 origin, float distance)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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)
			//IL_0079: 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_0082: Invalid comparison between Unknown and I4
			//IL_00cc: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val2 = default(Vector3);
			for (int i = 0; i < 20; i++)
			{
				Vector2 insideUnitCircle = Random.insideUnitCircle;
				Vector2 val = ((Vector2)(ref insideUnitCircle)).normalized * distance;
				((Vector3)(ref val2))..ctor(origin.x + val.x, 0f, origin.z + val.y);
				float groundHeight = ZoneSystem.instance.GetGroundHeight(val2);
				if (!(groundHeight < -900f))
				{
					val2.y = groundHeight + 0.5f;
					Biome biome = WorldGenerator.instance.GetBiome(val2);
					if ((int)biome != 256)
					{
						return val2;
					}
				}
			}
			AliensInValheimMod.Logger.LogInfo((object)"⚠\ufe0f No se encontró una ubicación segura. Usando ubicación por defecto.");
			return origin + Vector3.up * 2f;
		}

		private static void LookAtHorizontal(Transform who, Vector3 targetPos)
		{
			//IL_0001: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//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)
			Vector3 val = targetPos - who.position;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
			{
				who.rotation = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
			}
		}

		[IteratorStateMachine(typeof(<StartAbduction>d__10))]
		internal IEnumerator StartAbduction(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartAbduction>d__10(0)
			{
				<>4__this = this,
				player = player
			};
		}

		private void DropInventory(Player player, Vector3 lootPos)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: 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)
			List<ItemData> list = new List<ItemData>();
			list.AddRange(((Humanoid)player).GetInventory().GetEquippedItems());
			foreach (ItemData item in list)
			{
				((Humanoid)player).UnequipItem(item, true);
			}
			GameObject prefab = ZNetScene.instance.GetPrefab("GraveStone");
			if ((Object)(object)prefab == (Object)null)
			{
				AliensInValheimMod.Logger.LogError((object)"❌ No se encontró el prefab 'GraveStone '.");
			}
			else
			{
				GameObject val = Object.Instantiate<GameObject>(prefab, lootPos, Quaternion.identity);
				Container component = val.GetComponent<Container>();
				if ((Object)(object)component == (Object)null)
				{
					AliensInValheimMod.Logger.LogError((object)"❌ El prefab 'GraveStone ' no contiene un componente Container.");
				}
				else
				{
					component.m_name = "Restos de " + player.GetPlayerName() + " (abducido)";
					Inventory inventory = component.GetInventory();
					foreach (ItemData item2 in list)
					{
						inventory.AddItem(item2);
					}
					inventory.m_onChanged();
					AliensInValheimMod.Logger.LogInfo((object)$"\ud83e\udea6 Tumba creada con {list.Count} ítems en {lootPos}");
				}
			}
			AliensInValheimMod.Logger.LogInfo((object)$"\ud83c\udf81 Equipamiento dejado en {lootPos}");
		}

		[IteratorStateMachine(typeof(<StartGameAsViewer>d__12))]
		public IEnumerator StartGameAsViewer(Player targetPlayer, GameObject ovni, float suspenseDuration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartGameAsViewer>d__12(0)
			{
				<>4__this = this,
				targetPlayer = targetPlayer,
				ovni = ovni,
				suspenseDuration = suspenseDuration
			};
		}

		private void KillNearbyEnemies(Player player)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Invalid comparison between Unknown and I4
			//IL_0099: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_00e3: Expected O, but got Unknown
			try
			{
				float num = 25f;
				List<Character> allCharacters = Character.GetAllCharacters();
				if (allCharacters == null)
				{
					return;
				}
				foreach (Character item in allCharacters)
				{
					if (!((Object)(object)item == (Object)null) && !((Object)(object)item == (Object)(object)player) && !item.IsDead() && !(Vector3.Distance(((Component)item).transform.position, ((Component)player).transform.position) > num) && (int)item.GetFaction() != 0)
					{
						item.Damage(new HitData
						{
							m_damage = new DamageTypes
							{
								m_damage = 9999f
							},
							m_point = ((Component)item).transform.position,
							m_dir = Vector3.up,
							m_ranged = true
						});
						AliensInValheimMod.Logger.LogDebug((object)("☠\ufe0f Eliminado: " + ((Object)item).name + " cerca del jugador."));
					}
				}
			}
			catch (Exception arg)
			{
				AliensInValheimMod.Logger.LogWarning((object)$"[KillNearbyEnemies] falló: {arg}");
			}
		}

		private void OnDisable()
		{
			SafeHideUI();
		}

		private void OnDestroy()
		{
			SafeHideUI();
		}

		private void SafeHideUI()
		{
			try
			{
				progressBar?.Hide();
			}
			catch
			{
			}
			try
			{
				AlienUI.Hide();
			}
			catch
			{
			}
		}
	}
	internal class AbductionData
	{
		public long UserID { get; set; }

		public OvniConfiguration Config { get; set; }

		public AbductionData()
		{
			Config = new OvniConfiguration();
		}
	}
	internal class AbductionRPC : CommandRPCBase<AbductionRPC.CommandName, AbductionData>
	{
		public enum CommandName
		{
			START_ABDUCTION,
			FINISH_ABDUCTION
		}

		private static AbductionRPC _singleton = null;

		public static readonly AbductionRPC Instance = _singleton ?? new AbductionRPC();

		protected override string RPCName => "AliensInValheim_RPC_TriggerAbduction";

		public static event Action<Player, OvniConfiguration> RunAbductionSequenceRequested;
	}
}
namespace AliensInValheim.Utilities
{
	internal enum SoundGroup
	{
		SFX,
		Music,
		Ambient,
		Master
	}
	internal static class AudioExtension
	{
		[CompilerGenerated]
		private sealed class <FadeOutAndStopAudio>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject ovni;

			public SoundChannel name;

			public float fadeDuration;

			private AudioSource <source>5__1;

			private float <startVolume>5__2;

			private float <t>5__3;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<source>5__1 = ovni.GetAudioSource(name);
					if ((Object)(object)<source>5__1 == (Object)null || !<source>5__1.isPlaying)
					{
						return false;
					}
					<startVolume>5__2 = <source>5__1.volume;
					<t>5__3 = 0f;
					break;
				case 1:
					<>1__state = -1;
					<t>5__3 += Time.deltaTime;
					break;
				}
				if (<t>5__3 < fadeDuration)
				{
					<source>5__1.volume = Mathf.Lerp(<startVolume>5__2, 0f, <t>5__3 / fadeDuration);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<source>5__1.volume = 0f;
				<source>5__1.Stop();
				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 <FadeOutAudio>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject ovni;

			public float fadeDuration;

			private AudioSource[] <sources>5__1;

			private AudioSource[] <>s__2;

			private int <>s__3;

			private AudioSource <item>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<sources>5__1 = null;
				<>s__2 = null;
				<item>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<sources>5__1 = ovni.GetComponentsInChildren<AudioSource>(true);
					<>s__2 = <sources>5__1;
					<>s__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					<item>5__4 = null;
					<>s__3++;
					break;
				}
				if (<>s__3 < <>s__2.Length)
				{
					<item>5__4 = <>s__2[<>s__3];
					<>2__current = <item>5__4.FadeOutAudio(fadeDuration);
					<>1__state = 1;
					return true;
				}
				<>s__2 = null;
				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 <FadeOutAudio>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AudioSource source;

			public float fadeDuration;

			private float <startVolume>5__1;

			private float <t>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)source == (Object)null || !source.isPlaying)
					{
						return false;
					}
					<startVolume>5__1 = source.volume;
					<t>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					<t>5__2 += Time.deltaTime;
					break;
				}
				if (<t>5__2 < fadeDuration)
				{
					source.volume = Mathf.Lerp(<startVolume>5__1, 0f, <t>5__2 / fadeDuration);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				source.volume = 0f;
				source.Stop();
				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 <PlaySound>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject ovni;

			public SoundChannel channel;

			private AudioSource <source>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<source>5__1 = ovni.GetAudioSource(channel);
					if ((Object)(object)<source>5__1 == (Object)null)
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] audio source no está asignado.");
						return false;
					}
					if (<source>5__1.isPlaying)
					{
						<source>5__1.Stop();
					}
					if ((Object)(object)<source>5__1.clip != (Object)null)
					{
						<source>5__1.volume = 1f;
						<source>5__1.loop = false;
						<source>5__1.Play();
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					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();
			}
		}

		internal static void AttachToGameMixer(this AudioSource source, SoundGroup group)
		{
			if ((Object)(object)AudioMan.instance != (Object)null)
			{
				AudioMixer masterMixer = AudioMan.instance.m_masterMixer;
				AudioMixerGroup[] array = masterMixer.FindMatchingGroups(group.ToString());
				if (array.Length != 0)
				{
					source.outputAudioMixerGroup = array[0];
				}
			}
		}

		public static void PlaySounds(this GameObject ovni, Func<AudioSource, bool> predicate = null)
		{
			List<AudioSource> source = (from x in ovni.GetComponentsInChildren<AudioSource>(true).ToList()
				where ((Object)x).name != SoundChannel.LASER.ToString()
				select x).ToList();
			if (predicate != null)
			{
				source = source.Where(predicate).ToList();
			}
			foreach (AudioSource item in source.Where((AudioSource x) => (Object)(object)x.clip != (Object)null).ToList())
			{
				item.Play();
			}
		}

		[IteratorStateMachine(typeof(<PlaySound>d__2))]
		internal static IEnumerator PlaySound(this GameObject ovni, SoundChannel channel)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlaySound>d__2(0)
			{
				ovni = ovni,
				channel = channel
			};
		}

		internal static AudioSource GetAudioSource(this GameObject gameObject, SoundChannel name)
		{
			AudioSource[] components = gameObject.GetComponents<AudioSource>();
			AudioSource[] array = components;
			foreach (AudioSource val in array)
			{
				if (((Object)((Component)val).gameObject).name == name.ToString())
				{
					return val;
				}
			}
			return null;
		}

		[IteratorStateMachine(typeof(<FadeOutAndStopAudio>d__4))]
		internal static IEnumerator FadeOutAndStopAudio(this GameObject ovni, SoundChannel name, float fadeDuration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeOutAndStopAudio>d__4(0)
			{
				ovni = ovni,
				name = name,
				fadeDuration = fadeDuration
			};
		}

		[IteratorStateMachine(typeof(<FadeOutAudio>d__5))]
		internal static IEnumerator FadeOutAudio(this GameObject ovni, float fadeDuration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeOutAudio>d__5(0)
			{
				ovni = ovni,
				fadeDuration = fadeDuration
			};
		}

		[IteratorStateMachine(typeof(<FadeOutAudio>d__6))]
		internal static IEnumerator FadeOutAudio(this AudioSource source, float fadeDuration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeOutAudio>d__6(0)
			{
				source = source,
				fadeDuration = fadeDuration
			};
		}
	}
	public static class PrefabFactoryExtension
	{
		public static Texture2D LoadSprite(this AssetBundle library, string prefabName)
		{
			Texture2D val = library.LoadAsset<Texture2D>(prefabName);
			if ((Object)(object)val == (Object)null)
			{
				AliensInValheimMod.Logger.LogError((object)("[AliensInValheim]❌ No se pudo cargar el sprite '" + prefabName + "' desde el bundle."));
				return null;
			}
			return val;
		}

		public static GameObject CreateAlien(this AssetBundle library, Vector3 position, string prefabName)
		{
			//IL_0070: 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)
			if ((Object)(object)library == (Object)null)
			{
				AliensInValheimMod.Logger.LogError((object)"[AliensInValheim]❌ No se pudo cargar el bundle");
				return null;
			}
			AliensInValheimMod.Logger.LogMessage((object)("[AliensInValheim] Cargando prefab " + prefabName));
			GameObject val = library.LoadAsset<GameObject>(prefabName);
			if ((Object)(object)val == (Object)null)
			{
				AliensInValheimMod.Logger.LogError((object)("[AliensInValheim]❌ No se pudo cargar el prefab '" + prefabName + "' del alien desde el bundle."));
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, position, Quaternion.identity);
			((Object)val2).name = "Alien_Instance";
			Camera[] componentsInChildren = val2.GetComponentsInChildren<Camera>(true);
			foreach (Camera val3 in componentsInChildren)
			{
				((Behaviour)val3).enabled = false;
				((Component)val3).gameObject.SetActive(false);
			}
			if ((Object)(object)val2 == (Object)null)
			{
				AliensInValheimMod.Logger.LogError((object)"[AliensInValheim] No se pudo crear el OVNI.");
				return null;
			}
			return val2;
		}

		public static GameObject CreateOvni(this AssetBundle library, Vector3 position, OvniConfiguration config, string instanceName = "UFO_Instance")
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			if ((Object)(object)library == (Object)null)
			{
				AliensInValheimMod.Logger.LogError((object)"[AliensInValheim]❌ No se pudo cargar el bundle");
				return null;
			}
			GameObject val = library.LoadAsset<GameObject>(config.PrefabName);
			if ((Object)(object)val == (Object)null)
			{
				AliensInValheimMod.Logger.LogError((object)("[AliensInValheim]❌ No se pudo cargar el prefab '" + config.PrefabName + "' del OVNI desde el bundle."));
				return null;
			}
			if (!Object.op_Implicit((Object)(object)PrefabManager.Instance.GetPrefab(config.PrefabName)))
			{
				AliensInValheimMod.Logger.LogMessage((object)("[AliensInValheim] Registrando prefab " + config.PrefabName));
				CustomPrefab val2 = new CustomPrefab(val, true);
				PrefabManager.Instance.AddPrefab(val2);
			}
			GameObject val3 = Object.Instantiate<GameObject>(val, position, Quaternion.identity);
			((Object)val3).name = instanceName;
			val3.ConfigureAudio(config);
			Camera[] componentsInChildren = val3.GetComponentsInChildren<Camera>(true);
			foreach (Camera val4 in componentsInChildren)
			{
				((Behaviour)val4).enabled = false;
				((Component)val4).gameObject.SetActive(false);
			}
			AliensInValheimMod.OvniList.Add(val3);
			return val3;
		}

		private static void ConfigureAudio(this GameObject ovni, OvniConfiguration config)
		{
			AudioSource val = ovni.AddComponent<AudioSource>();
			((Object)val).name = SoundChannel.LASER.ToString();
			val.loop = false;
			val.volume = 1f;
			AudioSource val2 = ovni.AddComponent<AudioSource>();
			((Object)val2).name = SoundChannel.ENGINE.ToString();
			val2.clip = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>($"assets/sounds/ovni_engine{config.EngineSoundIndex}.mp3");
			val2.loop = true;
			val2.volume = 0.8f;
			AudioSource val3 = ovni.AddComponent<AudioSource>();
			((Object)val3).name = SoundChannel.BACKGROUND.ToString();
			val3 = ovni.AddComponent<AudioSource>();
			val3.clip = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>($"assets/sounds/background{config.BackGroundSoundIndex}.mp3");
			val3.loop = true;
			val3.volume = 0.6f;
		}

		public static GameObject CreateBeam(this Transform ufo, Transform player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0040: 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)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("UFOBeam");
			Light val2 = val.AddComponent<Light>();
			val2.type = (LightType)0;
			val2.spotAngle = 45f;
			val2.range = 60f;
			val2.intensity = 7f;
			val2.color = Color.Lerp(Color.white, Color.green, Random.value);
			val.transform.SetParent(ufo);
			val.transform.localPosition = Vector3.down * 3f;
			val.transform.LookAt(player);
			return val;
		}
	}
	internal static class OvniProcedures
	{
		[CompilerGenerated]
		private sealed class <FadeAndWarAwayAndDestroy>d__0 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject ufo;

			public float duration;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ufo.FadeAndWarpAway(duration);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Object.Destroy((Object)(object)ufo);
					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 <FadeAndWarpAway>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject ovni;

			public float duration;

			private float <t>5__1;

			private Vector3 <originalScale>5__2;

			private Renderer[] <renderers>5__3;

			private float <factor>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unk