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.MainMenu;
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 UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[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.3")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.1.3.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)
				{
					resourceMan = new ResourceManager("AliensInValheim.Resources", typeof(Resources).Assembly);
				}
				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);
			}
			LicenseInfo licenseInfo = JsonConvert.DeserializeObject<LicenseInfo>(DecryptWithAES(File.ReadAllBytes(path), "clave-supersecreta-1234"));
			if (!VerifyLicenseSignature(GenerateUnsignedJson(licenseInfo), 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);
				Encoding.UTF8.GetBytes(licenseJson);
				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
	{
		[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_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: 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()
		{
			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 JsonConvert.DeserializeObject<LicenseInfo>(json);
		}
	}
}
namespace AliensInValheim.MainMenu
{
	public class MainMenuUFO : MonoBehaviour
	{
		private GameObject ufoInstance;

		private AudioSource ufoMusicSource;

		private void Start()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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)
			//IL_00af: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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)
			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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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ú.");
		}
	}
}
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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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()
			{
				int num = <>1__state;
				AbductionEvent abductionEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					AliensInValheimMod.Logger.LogInfo((object)"AliensInValheim \ud83d\udef8 El ovni se retira.");
					((MonoBehaviour)abductionEvent).StartCoroutine(abductionEvent.musicSource.FadeOutAudio(3f));
					((MonoBehaviour)abductionEvent).StartCoroutine(abductionEvent.ovni.FadeOutAndStopAudio(SoundChannel.ENGINE, 3f));
					((MonoBehaviour)abductionEvent).StartCoroutine(abductionEvent.ovni.FadeOutAndStopAudio(SoundChannel.BACKGROUND, 2f));
					((MonoBehaviour)abductionEvent).StartCoroutine(abductionEvent.FadeAndDestroy(abductionEvent.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;

			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;

			private Vector3 <start>5__2;

			private Vector3 <end>5__3;

			private float <horizontalDuration>5__4;

			private float <t>5__5;

			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_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_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_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: 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_00a7: 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_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_00fe: 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__2 = ((Component)player).transform.position + ((Component)player).transform.right * 80f + Vector3.up * 30f;
					<end>5__3 = ((Component)player).transform.position + ((Component)player).transform.right * 10f + Vector3.up * 30f;
					ovni.transform.position = <start>5__2;
					<horizontalDuration>5__4 = 5f;
					<t>5__5 = 0f;
					break;
				case 1:
					<>1__state = -1;
					<t>5__5 += Time.deltaTime;
					break;
				}
				if (<t>5__5 < <horizontalDuration>5__4)
				{
					ovni.transform.position = Vector3.Lerp(<start>5__2, <end>5__3, <t>5__5 / <horizontalDuration>5__4);
					<>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 AbductionEvent <>4__this;

			public OvniConfiguration config;

			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_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: 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_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: 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)
				try
				{
					int num = <>1__state;
					AbductionEvent abductionEvent = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						Vector3 position = ((Component)player).transform.position + Vector3.up * 30f + ((Component)player).transform.right * 80f;
						abductionEvent.ovni = AliensInValheimMod.Instance.Library.CreateOvni(position, config);
						AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] Secuencia de abduccion sobre " + player.GetPlayerName()));
						<>2__current = abductionEvent.HorizontalMovement(player, abductionEvent.ovni);
						<>1__state = 1;
						return true;
					}
					case 1:
						<>1__state = -1;
						abductionEvent.PlayLoopingMusic(0.7f);
						abductionEvent.ovni.PlaySound(SoundChannel.ENGINE);
						abductionEvent.ovni.PlaySound(SoundChannel.BACKGROUND);
						<>2__current = abductionEvent.VerticalDescend(player, abductionEvent.ovni);
						<>1__state = 2;
						return true;
					case 2:
					{
						<>1__state = -1;
						<>1__state = -3;
						float suspenseDuration = Random.Range(15f, 30f);
						<>2__current = ((MonoBehaviour)abductionEvent).StartCoroutine(abductionEvent.AbductionMiniGame.StartGame(player, abductionEvent.ovni, suspenseDuration));
						<>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_0038: 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)
				<>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 GameObject ovni;

			public Player player;

			private Vector3 <descentStart>5__2;

			private Vector3 <descentEnd>5__3;

			private float <descentDuration>5__4;

			private float <t>5__5;

			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_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: 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)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<descentStart>5__2 = ovni.transform.position;
					<descentEnd>5__3 = ((Component)player).transform.position + Vector3.up * 10f;
					<descentDuration>5__4 = 4f;
					<t>5__5 = 0f;
					break;
				case 1:
					<>1__state = -1;
					<t>5__5 += Time.deltaTime;
					break;
				}
				if (<t>5__5 < <descentDuration>5__4)
				{
					ovni.transform.position = Vector3.Lerp(<descentStart>5__2, <descentEnd>5__3, <t>5__5 / <descentDuration>5__4);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				ovni.transform.position = <descentEnd>5__3;
				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;

		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)
			{
				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)
			{
				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)
			{
				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;

			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()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001e: 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_0038: 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_0042: 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_0097: 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)
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				Vector3 val = ((Component)player).transform.position + ((Component)player).transform.right * 2f;
				GameObject prefab = ZNetScene.instance.GetPrefab("piece_chest");
				GameObject prefab2 = ZNetScene.instance.GetPrefab("Coins");
				if ((Object)(object)prefab == (Object)null || (Object)(object)prefab2 == (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...");
				GameObject val2 = Object.Instantiate<GameObject>(prefab, val, Quaternion.identity);
				ZNetView component = val2.GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					AliensInValheimMod.Logger.LogInfo((object)"❌ ZNetView inválido al instanciar el cofre.");
					return false;
				}
				component.GetZDO().Set(ZDOVars.s_creator, player.GetPlayerID());
				Container component2 = val2.GetComponent<Container>();
				if ((Object)(object)component2 != (Object)null && component2.GetInventory() != null)
				{
					component2.GetInventory().AddItem(prefab2, 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.");
				}
				AudioSource componentInChildren = prefab2.GetComponentInChildren<AudioSource>();
				if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.clip != (Object)null)
				{
					AudioSource.PlayClipAtPoint(componentInChildren.clip, val, 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__2;

			private GameObject <alien>5__3;

			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__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Unknown result type (might be due to invalid IL or missing references)
				//IL_0246: Unknown result type (might be due to invalid IL or missing references)
				//IL_024b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0254: 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_026b: Expected O, but got Unknown
				//IL_0287: Unknown result type (might be due to invalid IL or missing references)
				//IL_0291: Unknown result type (might be due to invalid IL or missing references)
				//IL_0296: Unknown result type (might be due to invalid IL or missing references)
				//IL_029e: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_020c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0216: Expected O, but got Unknown
				//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0306: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: 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)
				//IL_0087: 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_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				AbductionMiniGameEvent abductionMiniGameEvent = <>4__this;
				switch (num)
				{
				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__2 = ((Component)player).transform.position;
					Vector3 right = ((Component)player).transform.right;
					Vector3 val2 = <basePos>5__2 + right * 2.2f;
					<alien>5__3 = AliensInValheimMod.Instance.Library.CreateAlien(val2, "assets/alien1/prefab/alien1.prefab");
					if ((Object)(object)<alien>5__3 == (Object)null)
					{
						AliensInValheimMod.Logger.LogWarning((object)"⚠\ufe0f No se pudo instanciar el Alien.");
						return false;
					}
					LookAtHorizontal(<alien>5__3.transform, ((Component)player).transform.position);
					AliensInValheimMod.Logger.LogInfo((object)("\ud83d\udc80 Jugador " + player.GetPlayerName() + " perdió el minijuego. Abducción forzada iniciada."));
					AlienParalysis alienParalysis = ((Component)player).GetComponent<AlienParalysis>();
					if ((Object)(object)alienParalysis == (Object)null)
					{
						alienParalysis = ((Component)player).gameObject.AddComponent<AlienParalysis>();
					}
					((MonoBehaviour)abductionMiniGameEvent).StartCoroutine(alienParalysis.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 = abductionMiniGameEvent.TeleportInAlien(val2, <alien>5__3);
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					Light obj = <alien>5__3.GetComponent<Light>() ?? <alien>5__3.AddComponent<Light>();
					obj.type = (LightType)2;
					obj.range = 10f;
					obj.intensity = 4f;
					obj.color = Color.red;
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 2;
					return true;
				}
				case 2:
				{
					<>1__state = -1;
					Vector3 lootPos = <basePos>5__2 + ((Component)player).transform.forward * 2f;
					abductionMiniGameEvent.DropInventory(player, lootPos);
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 3;
					return true;
				}
				case 3:
				{
					<>1__state = -1;
					Vector3 val = abductionMiniGameEvent.FindSafeTeleportLocation(((Component)player).transform.position, 200f);
					((Character)player).TeleportTo(val, ((Component)player).transform.rotation, true);
					Minimap instance = Minimap.instance;
					if (instance != null)
					{
						instance.AddPin(val, (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 {val}");
					Object.Destroy((Object)(object)<alien>5__3);
					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 AbductionMiniGameEvent <>4__this;

			public float suspenseDuration;

			private GameObject <beam>5__2;

			private float <timer>5__3;

			private float <progress>5__4;

			private bool <uiShown>5__5;

			private bool <isLocalPlayer>5__6;

			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__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d3: 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_01e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0249: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_025d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0262: Unknown result type (might be due to invalid IL or missing references)
				//IL_026f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0271: Unknown result type (might be due to invalid IL or missing references)
				//IL_0273: Unknown result type (might be due to invalid IL or missing references)
				//IL_027d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0292: Unknown result type (might be due to invalid IL or missing references)
				//IL_0299: Unknown result type (might be due to invalid IL or missing references)
				//IL_029b: 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)
				try
				{
					int num = <>1__state;
					AbductionMiniGameEvent abductionMiniGameEvent = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						AliensInValheimMod.Logger.LogDebug((object)"[AbductionMiniGame] Iniciando minijuego...");
						<beam>5__2 = null;
						<timer>5__3 = 0f;
						<progress>5__4 = 0f;
						<uiShown>5__5 = false;
						<isLocalPlayer>5__6 = (Object)(object)targetPlayer == (Object)(object)Player.m_localPlayer;
						AliensInValheimMod.Logger.LogInfo((object)$"[AbductionMiniGame] Target: {targetPlayer.GetPlayerName()}, Es jugador local: {<isLocalPlayer>5__6}");
						<>1__state = -3;
						<beam>5__2 = ovni.transform.CreateBeam(((Component)targetPlayer).transform);
						<uiShown>5__5 = true;
						abductionMiniGameEvent.progressBar.Show();
						goto IL_0310;
					case 1:
						<>1__state = -3;
						goto IL_0310;
					case 2:
						<>1__state = -1;
						break;
					case 3:
						{
							<>1__state = -1;
							break;
						}
						IL_0310:
						if (<timer>5__3 < suspenseDuration)
						{
							try
							{
								<timer>5__3 += Time.deltaTime;
								bool flag = false;
								if (<isLocalPlayer>5__6 && ZInput.instance != null)
								{
									flag = ZInput.GetKey((KeyCode)32, true);
								}
								if (!flag)
								{
									<progress>5__4 -= 10f * Time.deltaTime;
									if (<progress>5__4 < 0f)
									{
										<progress>5__4 = 0f;
									}
									goto IL_01ac;
								}
								<progress>5__4 += 9f;
								AliensInValheimMod.Logger.LogDebug((object)$"[AbductionMiniGame] Espacio presionado! Progress: {<progress>5__4:F1}/{100f}");
								if (!(<progress>5__4 >= 100f))
								{
									goto IL_01ac;
								}
								<progress>5__4 = 100f;
								AliensInValheimMod.Logger.LogInfo((object)"[AbductionMiniGame] El jugador ha llenado la barra completamente!");
								goto end_IL_00e6;
								IL_01ac:
								abductionMiniGameEvent.progressBar.SetValue(<progress>5__4 / 100f);
								Vector3 val = ((Component)targetPlayer).transform.position + Vector3.up * 10f;
								ovni.transform.position = Vector3.Lerp(ovni.transform.position, val, Time.deltaTime * 5f);
								if ((Object)(object)<beam>5__2 != (Object)null)
								{
									Vector3 position = ovni.transform.position;
									Vector3 val2 = ((Component)targetPlayer).transform.position + Vector3.up * 1.5f;
									<beam>5__2.transform.position = (position + val2) / 2f;
									<beam>5__2.transform.LookAt(val2);
									float num2 = Vector3.Distance(position, val2);
									<beam>5__2.transform.localScale = new Vector3(1f, num2 / 2f, 1f);
								}
								abductionMiniGameEvent.KillNearbyEnemies(targetPlayer);
								goto IL_02f3;
								end_IL_00e6:;
							}
							catch (Exception arg)
							{
								AliensInValheimMod.Logger.LogWarning((object)$"[AbductionMiniGame] Excepción frame: {arg}");
								goto IL_02f3;
							}
						}
						<>m__Finally1();
						if (<progress>5__4 >= 100f)
						{
							AliensInValheimMod.Logger.LogInfo((object)"\ud83d\ude4c El jugador escapó de la abducción.");
							<>2__current = abductionMiniGameEvent.ShowRewardForPlayer(targetPlayer);
							<>1__state = 2;
							return true;
						}
						<>2__current = abductionMiniGameEvent.StartAbduction(targetPlayer);
						<>1__state = 3;
						return true;
						IL_02f3:
						<>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;
				AbductionMiniGameEvent abductionMiniGameEvent = <>4__this;
				try
				{
					abductionMiniGameEvent.progressBar.Hide();
				}
				catch (Exception arg)
				{
					AliensInValheimMod.Logger.LogWarning((object)$"[AbductionMiniGame] progressBar.Hide() falló: {arg}");
				}
				if (<uiShown>5__5)
				{
					try
					{
						AlienUI.Hide();
						AliensInValheimMod.Logger.LogDebug((object)"[AbductionMiniGame] AlienUI.Hide() ejecutado.");
					}
					catch (Exception arg2)
					{
						AliensInValheimMod.Logger.LogWarning((object)$"[AbductionMiniGame] AlienUI.Hide() falló: {arg2}");
					}
				}
				if ((Object)(object)<beam>5__2 != (Object)null)
				{
					Object.Destroy((Object)(object)<beam>5__2);
				}
			}

			[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 GameObject ovni;

			public Player targetPlayer;

			public float suspenseDuration;

			private GameObject <beam>5__2;

			private float <timer>5__3;

			private bool <uiShown>5__4;

			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__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Expected O, but got Unknown
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: 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_00d4: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: 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_0143: 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_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: 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__2 = null;
						<timer>5__3 = 0f;
						<uiShown>5__4 = false;
						<>1__state = -3;
						<beam>5__2 = ovni.transform.CreateBeam(((Component)targetPlayer).transform);
						AlienUI.ShowProgressBar("¡Presiona ESPACIO para resistir la abducción!");
						<uiShown>5__4 = true;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<timer>5__3 < suspenseDuration)
					{
						try
						{
							<timer>5__3 += Time.deltaTime;
							Vector3 val = ((Component)targetPlayer).transform.position + Vector3.up * 10f;
							ovni.transform.position = Vector3.Lerp(ovni.transform.position, val, Time.deltaTime * 5f);
							if ((Object)(object)<beam>5__2 != (Object)null)
							{
								Vector3 position = ovni.transform.position;
								Vector3 val2 = ((Component)targetPlayer).transform.position + Vector3.up * 1.5f;
								<beam>5__2.transform.position = (position + val2) / 2f;
								<beam>5__2.transform.LookAt(val2);
								float num = Vector3.Distance(position, val2);
								<beam>5__2.transform.localScale = new Vector3(1f, num / 2f, 1f);
							}
						}
						catch (Exception arg)
						{
							AliensInValheimMod.Logger.LogWarning((object)$"[AbductionMiniGame Viewer] Excepción frame: {arg}");
						}
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					GameObject val3 = new GameObject("AbductionEvent");
					val3.AddComponent<AbductionEvent>();
					Object.DontDestroyOnLoad((Object)val3);
					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__4)
					{
						AlienUI.Hide();
					}
				}
				catch (Exception arg)
				{
					AliensInValheimMod.Logger.LogWarning((object)$"[Viewer] AlienUI.Hide() falló: {arg}");
				}
				if ((Object)(object)<beam>5__2 != (Object)null)
				{
					Object.Destroy((Object)(object)<beam>5__2);
				}
			}

			[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;

			private GameObject <lightObj>5__2;

			private Light <beamLight>5__3;

			private GameObject <particleObj>5__4;

			private float <duration>5__5;

			private float <t>5__6;

			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()
			{
				<lightObj>5__2 = null;
				<beamLight>5__3 = null;
				<particleObj>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				//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_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_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Expected O, but got Unknown
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: 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_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: 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_0170: Unknown result type (might be due to invalid IL or missing references)
				//IL_0175: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: 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_01e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0282: 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__2 = new GameObject("TeleportBeamLight");
					<lightObj>5__2.transform.position = spawnPos + Vector3.up * 1.5f;
					<beamLight>5__3 = <lightObj>5__2.AddComponent<Light>();
					<beamLight>5__3.type = (LightType)2;
					<beamLight>5__3.range = 8f;
					<beamLight>5__3.intensity = 0f;
					<beamLight>5__3.color = Color.cyan;
					<beamLight>5__3.shadows = (LightShadows)2;
					<particleObj>5__4 = new GameObject("TeleportParticles");
					<particleObj>5__4.transform.position = spawnPos;
					ParticleSystem obj = <particleObj>5__4.AddComponent<ParticleSystem>();
					MainModule main = obj.main;
					((MainModule)(ref main)).duration = 2f;
					((MainModule)(ref main)).startLifetime = MinMaxCurve.op_Implicit(1f);
					((MainModule)(ref main)).startSpeed = MinMaxCurve.op_Implicit(2f);
					((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(0.3f);
					((MainModule)(ref main)).loop = false;
					((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)1;
					ShapeModule shape = obj.shape;
					((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)8;
					((ShapeModule)(ref shape)).angle = 0f;
					((ShapeModule)(ref shape)).radius = 0.5f;
					((ShapeModule)(ref shape)).length = 3f;
					EmissionModule emission = obj.emission;
					((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(40f);
					obj.Play();
					alien.transform.localScale = Vector3.zero;
					<duration>5__5 = 2f;
					<t>5__6 = 0f;
					goto IL_0246;
				}
				case 1:
					<>1__state = -1;
					goto IL_0246;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_0246:
					if (<t>5__6 < <duration>5__5)
					{
						<t>5__6 += Time.deltaTime;
						float num = <t>5__6 / <duration>5__5;
						alien.transform.localScale = Vector3.one * Mathf.SmoothStep(0f, 1f, num);
						<beamLight>5__3.intensity = Mathf.Lerp(0f, 6f, Mathf.Sin(num * (float)Math.PI));
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					Object.Destroy((Object)(object)<particleObj>5__4, 2f);
					Object.Destroy((Object)(object)<lightObj>5__2, 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)
			{
				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_0007: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TeleportInAlien>d__7(0)
			{
				spawnPos = spawnPos,
				alien = alien
			};
		}

		private Vector3 FindSafeTeleportLocation(Vector3 origin, float distance)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_0013: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Invalid comparison between Unknown and I4
			//IL_0073: 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;
					if ((int)WorldGenerator.instance.GetBiome(val2) != 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_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002a: 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)
			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_0077: 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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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("player_tombstone");
			if ((Object)(object)prefab == (Object)null)
			{
				AliensInValheimMod.Logger.LogError((object)"❌ No se encontró el prefab 'player_tombstone'.");
			}
			else
			{
				Container component = Object.Instantiate<GameObject>(prefab, lootPos, Quaternion.identity).GetComponent<Container>();
				if ((Object)(object)component == (Object)null)
				{
					AliensInValheimMod.Logger.LogError((object)"❌ El prefab 'player_tombstone' 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)
			{
				targetPlayer = targetPlayer,
				ovni = ovni,
				suspenseDuration = suspenseDuration
			};
		}

		private void KillNearbyEnemies(Player player)
		{
			//IL_0051: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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)
			//IL_007a: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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__2;

			private float <startVolume>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 <FadeOutAndStopAudio>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

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

			private int <>7__wrap2;

			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()
			{
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					AudioSource[] componentsInChildren = ovni.GetComponentsInChildren<AudioSource>(true);
					<>7__wrap1 = componentsInChildren;
					<>7__wrap2 = 0;
					break;
				}
				case 1:
					<>1__state = -1;
					<>7__wrap2++;
					break;
				}
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					AudioSource source = <>7__wrap1[<>7__wrap2];
					<>2__current = source.FadeOutAudio(fadeDuration);
					<>1__state = 1;
					return true;
				}
				<>7__wrap1 = 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__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 <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__2 = source.volume;
					<t>5__3 = 0f;
					break;
				case 1:
					<>1__state = -1;
					<t>5__3 += Time.deltaTime;
					break;
				}
				if (<t>5__3 < fadeDuration)
				{
					source.volume = Mathf.Lerp(<startVolume>5__2, 0f, <t>5__3 / 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;

			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()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					AudioSource audioSource = ovni.GetAudioSource(channel);
					if ((Object)(object)audioSource == (Object)null)
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] audio source no está asignado.");
						return false;
					}
					if (audioSource.isPlaying)
					{
						audioSource.Stop();
					}
					if ((Object)(object)audioSource.clip != (Object)null)
					{
						audioSource.volume = 1f;
						audioSource.loop = false;
						audioSource.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)
			{
				AudioMixerGroup[] array = AudioMan.instance.m_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>();
			foreach (AudioSource val in components)
			{
				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_005d: 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)
			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 obj in componentsInChildren)
			{
				((Behaviour)obj).enabled = false;
				((Component)obj).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_0096: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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 obj in componentsInChildren)
			{
				((Behaviour)obj).enabled = false;
				((Component)obj).gameObject.SetActive(false);
			}
			AliensInValheimMod.OvniList.Add(val3);
			return val3;
		}

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

		public static GameObject CreateBeam(this Transform ufo, Transform player)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_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)
			//IL_0051: 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_0063: 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)
			//IL_0084: Expected O, but got Unknown
			GameObject val = new GameObject("UFOBeam");
			Light obj = val.AddComponent<Light>();
			obj.type = (LightType)0;
			obj.spotAngle = 45f;
			obj.range = 60f;
			obj.intensity = 7f;
			obj.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__2;

			private Vector3 <originalScale>5__3;

			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()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: 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_00ad: 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_00bc: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					AliensInValheimMod.Logger.LogInfo((object)("\ud83d\udef8 OVNI se aleja. " + ((Object)ovni).name));
					<t>5__2 = 0f;
					<originalScale>5__3 = ovni.transform.localScale;
					ovni.GetComponentsInChildren<Renderer>();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<t>5__2 < duration)
				{
					<t>5__2 += Time.deltaTime;
					float num = 1f - <t>5__2 / duration;
					Transform transform = ovni.transform;
					transform.position += Vector3.up * <t>5__2 * 10f;
					ovni.transform.localScale = <originalScale>5__3 * num;
					<>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 <MoveTowards>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject ovni;

			public Vector3 dest;

			public float speed;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0072: 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_002f: 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_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (Vector3.Distance(ovni.transform.position, dest) > 5f)
				{
					ovni.transform.position = Vector3.MoveTowards(ovni.transform.position, dest, speed * Time.deltaTime);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				ovni.transform.position = dest;
				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 <MoveTowardsFixedTime>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject ovni;

			public float duration;

			public Vector3 dest;

			private Vector3 <start>5__2;

			private float <elapsed>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: 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_008c: 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_00d0: 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__2 = ovni.transform.position;
					<elapsed>5__3 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__3 < duration)
				{
					<elapsed>5__3 += Time.deltaTime;
					float num = Mathf.Clamp01(<elapsed>5__3 / duration);
					float num2 = 1f - Mathf.Pow(1f - num, 3f);
					ovni.transform.position = Vector3.Lerp(<start>5__2, dest, num2);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				ovni.transform.position = dest;
				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();
			}
		}

		[IteratorStateMachine(typeof(<FadeAndWarAwayAndDestroy>d__0))]
		internal static IEnumerator FadeAndWarAwayAndDestroy(this GameObject ufo, float duration = 2f)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeAndWarAwayAndDestroy>d__0(0)
			{
				ufo = ufo,
				duration = duration
			};
		}

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

		[IteratorStateMachine(typeof(<MoveTowards>d__2))]
		internal static IEnumerator MoveTowards(this GameObject ovni, Vector3 dest, float speed = 8f)
		{
			//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 <MoveTowards>d__2(0)
			{
				ovni = ovni,
				dest = dest,
				speed = speed
			};
		}

		[IteratorStateMachine(typeof(<MoveTowardsFixedTime>d__3))]
		internal static IEnumerator MoveTowardsFixedTime(this GameObject ovni, Vector3 dest, float duration = 10f)
		{
			//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 <MoveTowardsFixedTime>d__3(0)
			{
				ovni = ovni,
				dest = dest,
				duration = duration
			};
		}
	}
	internal static class ProceduresExtension
	{
		[CompilerGenerated]
		private sealed class <AddCustomPin>d__0 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string prefabName;

			public string label;

			public Minimap map;

			public Vector3 position;

			public bool save;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005d: 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_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					Sprite val = EnsureUfoSprite(prefabName);
					if ((Object)(object)val == (Object)null)
					{
						return false;
					}
					string text = "[UFO]" + (string.IsNullOrWhiteSpace(label) ? "Abduccion" : label);
					PinData val2 = map.AddPin(position, (PinType)3, text, save, false, 0L, default(PlatformUserID));
					if (val2 != null)
					{
						val2.m_icon = val;
						if ((Object)(object)val2.m_uiElement != (Object)null)
						{
							Transform obj = ((Component)val2.m_uiElement).transform.Find("icon");
							Image val3 = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
							if ((Object)(object)val3 != (Object)null)
							{
								val3.sprite = val;
								val3.type = (Type)0;
								val3.preserveAspect = true;
								((Graphic)val3).color = Color.white;
							}
						}
					}
					<>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 <ApplyIconWhenReady>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PinData pin;

			public Sprite sprite;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <ApplyIconWhenReady>d__2(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;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 15)
				{
					if ((Object)(object)pin?.m_uiElement != (Object)null)
					{
						Transform obj = ((Component)pin.m_uiElement).transform.Find("icon");
						Image val = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
						if ((Object)(object)val != (Object)null)
						{
							val.sprite = sprite;
							((Graphic)val).SetNativeSize();
							return false;
						}
					}
					<>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();
			}
		}

		[IteratorStateMachine(typeof(<AddCustomPin>d__0))]
		internal static IEnumerator AddCustomPin(this Minimap map, Vector3 position, string prefabName, string label = "Abduccion", bool save = true)
		{
			//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 <AddCustomPin>d__0(0)
			{
				map = map,
				position = position,
				prefabName = prefabName,
				label = label,
				save = save
			}