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

		internal static Sprite EnsureUfoSprite(string prefabName)
		{
			//IL_002a: 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)
			try
			{
				Texture2D val = AliensInValheimMod.Instance.Library.LoadSprite(prefabName);
				Sprite result = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 64f);
				AliensInValheimMod.Logger.LogInfo((object)"[UfoPinsClient] Sprite OVNI cargado desde AssetBundle.");
				return result;
			}
			catch (Exception ex)
			{
				AliensInValheimMod.Logger.LogError((object)("[UfoPinsClient] Error al cargar AssetBundle OVNI: " + ex.Message));
			}
			return null;
		}

		[IteratorStateMachine(typeof(<ApplyIconWhenReady>d__2))]
		internal static IEnumerator ApplyIconWhenReady(this PinData pin, Sprite sprite)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyIconWhenReady>d__2(0)
			{
				pin = pin,
				sprite = sprite
			};
		}

		internal static Player FindPlayerByUserID(long userId)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if (!((Object)(object)allPlayer == (Object)null))
				{
					ZDOID zDOID = ((Character)allPlayer).GetZDOID();
					if (((ZDOID)(ref zDOID)).UserID == userId)
					{
						return allPlayer;
					}
				}
			}
			return null;
		}

		internal static Player FindPlayerByName(string name)
		{
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if (!((Object)(object)allPlayer == (Object)null) && string.Equals(allPlayer.GetPlayerName(), name, StringComparison.OrdinalIgnoreCase))
				{
					return allPlayer;
				}
			}
			return null;
		}
	}
	public class AlienParalysis : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DoParalysis>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public AlienParalysis <>4__this;

			public float duration;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				AlienParalysis alienParalysis = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)player == (Object)null)
					{
						return false;
					}
					alienParalysis.originalWalkSpeed = ((Character)player).m_walkSpeed;
					alienParalysis.originalRunSpeed = ((Character)player).m_runSpeed;
					alienParalysis.originalJumpForce = ((Character)player).m_jumpForce;
					((Character)player).m_walkSpeed = 0f;
					((Character)player).m_runSpeed = 0f;
					((Character)player).m_jumpForce = 0f;
					((Character)player).Message((MessageType)1, "<color=cyan>Una fuerza misteriosa te inmoviliza...</color>", 0, (Sprite)null);
					alienParalysis.TryPlayCheerEmote(player);
					<>2__current = ((MonoBehaviour)alienParalysis).StartCoroutine(alienParalysis.LevitateRoutine(player, duration));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((Character)player).m_walkSpeed = alienParalysis.originalWalkSpeed;
					((Character)player).m_runSpeed = alienParalysis.originalRunSpeed;
					((Character)player).m_jumpForce = alienParalysis.originalJumpForce;
					((Character)player).Message((MessageType)1, "<color=yellow>La fuerza alienígena desaparece...</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 <LevitateRoutine>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public float totalDuration;

			private Transform <t>5__2;

			private Vector3 <basePos>5__3;

			private float <tUp>5__4;

			private float <hoverTime>5__5;

			private float <tHover>5__6;

			private float <tDown>5__7;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_024f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0287: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)player == (Object)null)
					{
						return false;
					}
					<t>5__2 = ((Component)player).transform;
					<basePos>5__3 = <t>5__2.position;
					<tUp>5__4 = 0f;
					goto IL_00ee;
				case 1:
					<>1__state = -1;
					goto IL_00ee;
				case 2:
					<>1__state = -1;
					goto IL_01b0;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_01b0:
					if (<tHover>5__6 < <hoverTime>5__5)
					{
						<tHover>5__6 += Time.deltaTime;
						float num = Mathf.Sin(<tHover>5__6 * (float)Math.PI * 2f * 1.2f) * 0.08f;
						<t>5__2.position = new Vector3(<basePos>5__3.x, <basePos>5__3.y + 1.2f + num, <basePos>5__3.z);
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<tDown>5__7 = 0f;
					break;
					IL_00ee:
					if (<tUp>5__4 < 0.6f)
					{
						<tUp>5__4 += Time.deltaTime;
						float num2 = Mathf.Clamp01(<tUp>5__4 / 0.6f);
						float num3 = num2 * num2 * (3f - 2f * num2);
						<t>5__2.position = new Vector3(<basePos>5__3.x, <basePos>5__3.y + num3 * 1.2f, <basePos>5__3.z);
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<hoverTime>5__5 = Mathf.Max(0f, totalDuration - 1.2f);
					<tHover>5__6 = 0f;
					goto IL_01b0;
				}
				if (<tDown>5__7 < 0.6f)
				{
					<tDown>5__7 += Time.deltaTime;
					float num4 = Mathf.Clamp01(<tDown>5__7 / 0.6f);
					float num5 = num4 * num4 * (3f - 2f * num4);
					float num6 = Mathf.Lerp(<basePos>5__3.y + 1.2f, <basePos>5__3.y, num5);
					<t>5__2.position = new Vector3(<basePos>5__3.x, num6, <basePos>5__3.z);
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				<t>5__2.position = <basePos>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 float originalWalkSpeed;

		private float originalRunSpeed;

		private float originalJumpForce;

		private const float LiftHeight = 1.2f;

		private const float LiftUpTime = 0.6f;

		private const float HoverBobAmp = 0.08f;

		private const float HoverBobHz = 1.2f;

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

		[IteratorStateMachine(typeof(<LevitateRoutine>d__8))]
		private IEnumerator LevitateRoutine(Player player, float totalDuration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LevitateRoutine>d__8(0)
			{
				player = player,
				totalDuration = totalDuration
			};
		}

		private void TryPlayCheerEmote(Player player)
		{
			try
			{
				Animator componentInChildren = ((Component)player).GetComponentInChildren<Animator>();
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					componentInChildren.CrossFade("emote_cheer", 0.1f, 0, 0f);
				}
			}
			catch
			{
			}
		}
	}
	public class AlienProgressBar : MonoBehaviour
	{
		private GameObject panel;

		private Slider slider;

		private Text sliderText;

		private Image fillImage;

		private void Awake()
		{
			AliensInValheimMod.Logger.LogDebug((object)"[AlienProgressBar] Registrando callback para GUI.");
			GUIManager.OnCustomGUIAvailable += CreateBar;
		}

		private void OnDestroy()
		{
			AliensInValheimMod.Logger.LogDebug((object)"[AlienProgressBar] Eliminando callback de GUI.");
			GUIManager.OnCustomGUIAvailable -= CreateBar;
		}

		private void CreateBar()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)panel != (Object)null)
			{
				AliensInValheimMod.Logger.LogDebug((object)"[AlienProgressBar] Ya existe un panel de barra, no se crea otro.");
				return;
			}
			AliensInValheimMod.Logger.LogDebug((object)"[AlienProgressBar] Creando barra de progreso...");
			panel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 80f), 300f, 50f, false);
			GameObject val = new GameObject("AlienSlider");
			val.transform.SetParent(panel.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 0f);
			obj.anchorMax = new Vector2(1f, 1f);
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			slider = val.AddComponent<Slider>();
			slider.direction = (Direction)0;
			slider.minValue = 0f;
			slider.maxValue = 1f;
			slider.value = 0f;
			GameObject val2 = new GameObject("Background");
			val2.transform.SetParent(val.transform, false);
			Image val3 = val2.AddComponent<Image>();
			((Graphic)val3).color = new Color(0f, 0f, 0f, 0.4f);
			RectTransform component = ((Component)val3).GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			((Selectable)slider).targetGraphic = (Graphic)(object)val3;
			GameObject val4 = new GameObject("Fill");
			val4.transform.SetParent(val.transform, false);
			fillImage = val4.AddComponent<Image>();
			((Graphic)fillImage).color = Color.yellow;
			RectTransform component2 = ((Component)fillImage).GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			slider.fillRect = component2;
			GameObject val5 = GUIManager.Instance.CreateText("0%", val.transform, new Vector2(0f, 0f), new Vector2(1f, 1f), Vector2.zero, GUIManager.Instance.AveriaSerifBold, 20, Color.white, true, Color.black, 40f, 100f, false);
			sliderText = val5.GetComponent<Text>();
			sliderText.alignment = (TextAnchor)4;
			panel.SetActive(false);
			AliensInValheimMod.Logger.LogDebug((object)"[AlienProgressBar] Barra de progreso creada correctamente y oculta.");
		}

		public void SetValue(float value)
		{
			//IL_0081: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)slider == (Object)null || (Object)(object)sliderText == (Object)null || (Object)(object)fillImage == (Object)null)
			{
				AliensInValheimMod.Logger.LogWarning((object)"[AlienProgressBar] No se puede actualizar valor. Componentes no inicializados.");
				return;
			}
			slider.value = Mathf.Clamp01(value);
			int num = Mathf.FloorToInt(value * 100f);
			sliderText.text = $"{num}%";
			if (value < 0.3f)
			{
				((Graphic)fillImage).color = Color.red;
			}
			else if (value < 0.75f)
			{
				((Graphic)fillImage).color = Color.yellow;
			}
			else
			{
				((Graphic)fillImage).color = Color.green;
			}
			AliensInValheimMod.Logger.LogDebug((object)$"[AlienProgressBar] Valor actualizado: {num}%");
		}

		public void Show()
		{
			if ((Object)(object)panel != (Object)null)
			{
				panel.SetActive(true);
				AliensInValheimMod.Logger.LogDebug((object)"[AlienProgressBar] Barra visible.");
			}
		}

		public void Hide()
		{
			if ((Object)(object)panel != (Object)null)
			{
				panel.SetActive(false);
				AliensInValheimMod.Logger.LogDebug((object)"[AlienProgressBar] Barra oculta.");
			}
		}
	}
	public class RewardDropAnimation : MonoBehaviour
	{
		private Vector3 targetPosition;

		private float speed = 6f;

		private bool landed;

		public void Init(Vector3 target)
		{
			//IL_0001: 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)
			targetPosition = target;
		}

		private void Update()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!landed && ((Component)this).transform.position.y > targetPosition.y)
			{
				((Component)this).transform.position = Vector3.MoveTowards(((Component)this).transform.position, targetPosition, speed * Time.deltaTime);
			}
			else
			{
				if (landed)
				{
					return;
				}
				landed = true;
				((Component)this).transform.position = targetPosition;
				GameObject prefab = ZNetScene.instance.GetPrefab("vfx_guardstone_activate");
				if ((Object)(object)prefab != (Object)null)
				{
					AudioSource component = prefab.GetComponent<AudioSource>();
					if ((Object)(object)component != (Object)null && (Object)(object)component.clip != (Object)null)
					{
						AudioSource obj = ((Component)this).gameObject.AddComponent<AudioSource>();
						obj.clip = component.clip;
						obj.playOnAwake = false;
						obj.spatialBlend = 1f;
						obj.Play();
					}
				}
				Object.Destroy((Object)(object)this);
			}
		}
	}
	internal static class LibraryLoaderExtension
	{
		private static AssetBundle _bundle;

		public static AssetBundle LoadLibraryFileBundle(string modPath)
		{
			if ((Object)(object)_bundle != (Object)null)
			{
				return _bundle;
			}
			try
			{
				string text = Path.Combine(modPath, "valheiminalienslibrary");
				if (!File.Exists(text))
				{
					AliensInValheimMod.Logger.LogError((object)("❌ El archivo '" + text + "' no existe."));
					return null;
				}
				_bundle = AssetBundle.LoadFromFile(text);
				if ((Object)(object)_bundle == (Object)null)
				{
					AliensInValheimMod.Logger.LogError((object)"❌ Falló la carga del AssetBundle desde el archivo.");
				}
				return _bundle;
			}
			catch (Exception ex)
			{
				AliensInValheimMod.Logger.LogError((object)("❌ Error al cargar el AssetBundle desde el disco: " + ex.Message));
				return null;
			}
		}
	}
	public static class PlayerScanner
	{
		internal static float GetAveragePlayerDistance()
		{
			//IL_005e: 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)
			List<Player> list = (from p in Player.GetAllPlayers()
				where !((Character)p).IsDead()
				select p).ToList();
			if (list.Count < 2)
			{
				return float.MaxValue;
			}
			float num = 0f;
			int num2 = 0;
			for (int i = 0; i < list.Count; i++)
			{
				for (int j = i + 1; j < list.Count; j++)
				{
					num += Vector3.Distance(((Component)list[i]).transform.position, ((Component)list[j]).transform.position);
					num2++;
				}
			}
			if (num2 <= 0)
			{
				return float.MaxValue;
			}
			return num / (float)num2;
		}

		internal static bool PlayerIsAlone(this Player player)
		{
			int num = player.CountNearbyPlayers(60f);
			AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] Jugadores cerca de {player.GetPlayerName()}: {num}");
			return num == 0;
		}

		internal static bool IsLocalPlayer(this Player player)
		{
			return ((Object)Player.m_localPlayer).name == player.GetPlayerName();
		}

		private static int CountNearbyPlayers(this Player localPlayer, float radius)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Vector3 position = ((Component)localPlayer).transform.position;
			foreach (Player item in from x in Player.GetAllPlayers()
				where x.GetPlayerName() != localPlayer.GetPlayerName()
				select x)
			{
				float num2 = Math.Abs(Vector3.Distance(((Component)item).transform.position, position));
				AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] Evaluando distancia a {item.GetPlayerName()} de {num2}");
				if (num2 <= radius)
				{
					num++;
				}
			}
			return num;
		}
	}
	public static class AlienUI
	{
		private static GameObject panel;

		private static Slider slider;

		private static Image fillImage;

		public static void ShowProgressBar(string title = "")
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_00ed: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: 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_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: 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_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: 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_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			if ((Object)(object)panel != (Object)null)
			{
				Object.Destroy((Object)(object)panel);
			}
			if ((Object)(object)GameObject.Find("AlienCanvas") == (Object)null)
			{
				GameObject val = new GameObject("AlienCanvas");
				val.AddComponent<Canvas>().renderMode = (RenderMode)0;
				val.AddComponent<CanvasScaler>().uiScaleMode = (ScaleMode)1;
				val.AddComponent<GraphicRaycaster>();
				Object.DontDestroyOnLoad((Object)val);
			}
			Transform transform = GameObject.Find("AlienCanvas").transform;
			panel = new GameObject("AlienProgressPanel");
			panel.transform.SetParent(transform, false);
			RectTransform obj = panel.AddComponent<RectTransform>();
			obj.sizeDelta = new Vector2(400f, 80f);
			obj.anchoredPosition = new Vector2(0f, -200f);
			((Graphic)panel.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0f);
			GameObject val2 = new GameObject("TextBackground");
			val2.transform.SetParent(panel.transform, false);
			Image obj2 = val2.AddComponent<Image>();
			((Graphic)obj2).color = new Color(0f, 0f, 0f, 0.2f);
			RectTransform component = ((Component)obj2).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.sizeDelta = new Vector2(0f, 30f);
			component.anchoredPosition = new Vector2(0f, -5f);
			GameObject val3 = new GameObject("AlienLabel");
			val3.transform.SetParent(val2.transform, false);
			Text obj3 = val3.AddComponent<Text>();
			obj3.text = title;
			obj3.alignment = (TextAnchor)4;
			obj3.font = GUIManager.Instance.AveriaSerif;
			obj3.fontSize = 8;
			((Graphic)obj3).color = new Color(1f, 1f, 1f);
			RectTransform component2 = ((Component)obj3).GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			Outline obj4 = val3.AddComponent<Outline>();
			((Shadow)obj4).effectColor = Color.black;
			((Shadow)obj4).effectDistance = new Vector2(0.5f, -0.5f);
			GameObject val4 = new GameObject("AlienSlider");
			val4.transform.SetParent(panel.transform, false);
			slider = val4.AddComponent<Slider>();
			RectTransform component3 = ((Component)slider).GetComponent<RectTransform>();
			component3.sizeDelta = new Vector2(300f, 20f);
			component3.anchoredPosition = new Vector2(0f, -40f);
			Image obj5 = new GameObject("Background").AddComponent<Image>();
			((Graphic)obj5).color = Color.black;
			((Component)obj5).transform.SetParent(((Component)slider).transform, false);
			RectTransform component4 = ((Component)obj5).GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 0f);
			component4.anchorMax = new Vector2(1f, 1f);
			component4.offsetMin = Vector2.zero;
			component4.offsetMax = Vector2.zero;
			Image val5 = new GameObject("Fill").AddComponent<Image>();
			((Graphic)val5).color = Color.yellow;
			((Component)val5).transform.SetParent(((Component)slider).transform, false);
			fillImage = val5;
			slider.fillRect = ((Graphic)val5).rectTransform;
			((Selectable)slider).targetGraphic = (Graphic)(object)val5;
			RectTransform component5 = ((Component)val5).GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(0f, 0f);
			component5.anchorMax = new Vector2(1f, 1f);
			component5.offsetMin = Vector2.zero;
			component5.offsetMax = Vector2.zero;
			slider.minValue = 0f;
			slider.maxValue = 1f;
			slider.value = 0f;
		}

		public static void SetValue(float normalized)
		{
			if ((Object)(object)slider != (Object)null)
			{
				slider.value = Mathf.Clamp01(normalized);
			}
		}

		public static void SetColor(Color color)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)fillImage != (Object)null)
			{
				((Graphic)fillImage).color = color;
			}
		}

		public static void Hide()
		{
			if ((Object)(object)panel != (Object)null)
			{
				Object.Destroy((Object)(object)panel);
				panel = null;
				slider = null;
				fillImage = null;
			}
		}
	}
	internal static class PlayerExtensions
	{
		internal static float CalculateFireDamage(this Player player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			if ((Object)(object)player == (Object)null)
			{
				return 0f;
			}
			float num = 50f;
			try
			{
				float maxHealth = ((Character)player).GetMaxHealth();
				float bodyArmor = ((Character)player).GetBodyArmor();
				float num2 = (((int)((Character)player).GetDamageModifiers((WeakSpot)null).m_fire == 5) ? 20f : 0f);
				num = (maxHealth + bodyArmor + num2) * 0.1f;
			}
			catch
			{
				return 50f;
			}
			return Mathf.Max(1f, num);
		}

		internal static Player FindPlayer(this List<Player> players, string name, long guid)
		{
			return ((IEnumerable<Player>)players).FirstOrDefault((Func<Player, bool>)delegate(Player p)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				if (!p.GetPlayerName().Equals(name, StringComparison.OrdinalIgnoreCase))
				{
					ZDOID zDOID = ((Character)p).GetZDOID();
					return ((ZDOID)(ref zDOID)).UserID == guid;
				}
				return true;
			});
		}

		internal static Player GetRandomNearbyPlayer(this Player player, float radiusMeters = 50f)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			List<Player> list = (from p in Player.GetAllPlayers()
				where (Object)(object)p != (Object)null && !((Character)p).IsDead() && (Object)(object)p != (Object)(object)player
				select p).ToList();
			if (list.Count == 0)
			{
				return player;
			}
			List<Player> list2 = list.Where((Player p) => Vector3.Distance(((Component)p).transform.position, ((Component)player).transform.position) <= radiusMeters).ToList();
			if (list2.Count == 0)
			{
				return player;
			}
			return list2[Random.Range(0, list2.Count)];
		}

		internal static bool TryGetRandomPlayer(out Player player)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			player = null;
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (ZNet.instance.IsServer())
			{
				List<ZNetPeer> list = (ZNet.instance.GetConnectedPeers() ?? ZNet.instance.GetPeers()).Where((ZNetPeer p) => p != null && p.IsReady() && !((ZDOID)(ref p.m_characterID)).IsNone()).ToList();
				if (list.Count == 0)
				{
					return false;
				}
				ZNetPeer val = list[Random.Range(0, list.Count)];
				long userId = ((ZDOID)(ref val.m_characterID)).UserID;
				player = ((IEnumerable<Player>)Player.GetAllPlayers()).FirstOrDefault((Func<Player, bool>)delegate(Player p)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					ZDOID zDOID2 = ((Character)p).GetZDOID();
					return ((ZDOID)(ref zDOID2)).UserID == userId;
				});
				if ((Object)(object)player == (Object)null)
				{
					AliensInValheimMod.Logger.LogWarning((object)$"[ServerPlayerPicker] No se encontró instancia Player para {val.m_playerName} ({userId})");
					return false;
				}
				AliensInValheimMod.Logger.LogInfo((object)$"[ServerPlayerPicker] Jugador elegido en servidor: {player.GetPlayerName()} ({userId})");
				return true;
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			player = Player.m_localPlayer;
			ManualLogSource logger = AliensInValheimMod.Logger;
			string playerName = player.GetPlayerName();
			ZDOID zDOID = ((Character)player).GetZDOID();
			logger.LogInfo((object)$"[ServerPlayerPicker] Cliente devolvió su propio Player: {playerName} ({((ZDOID)(ref zDOID)).UserID})");
			return true;
		}

		internal static void SolvePlayerAndConfiguration(string[] args, out Player target, out OvniConfiguration config)
		{
			target = Player.m_localPlayer;
			int? num = null;
			try
			{
				if (args != null && args.Length != 0)
				{
					if (args.Length == 1)
					{
						Player val = ResolvePlayer(args[0]);
						int zeroBased;
						if ((Object)(object)val != (Object)null)
						{
							target = val;
						}
						else if (TryResolveIndex(args[0], Configurations.List.Count, out zeroBased))
						{
							num = zeroBased;
						}
						else
						{
							AliensInValheimMod.Logger.LogInfo((object)$"⚠\ufe0f '{args[0]}' no es un nombre de jugador, UserID ni índice válido (1..{Configurations.List.Count}).");
						}
					}
					else
					{
						if (TryResolveIndex(args[0], Configurations.List.Count, out var zeroBased2))
						{
							num = zeroBased2;
						}
						else
						{
							AliensInValheimMod.Logger.LogInfo((object)$"⚠\ufe0f Índice de OVNI inválido en el primer argumento (1..{Configurations.List.Count}).");
						}
						Player val2 = ResolvePlayer(args[1]);
						if ((Object)(object)val2 != (Object)null)
						{
							target = val2;
						}
						else
						{
							AliensInValheimMod.Logger.LogInfo((object)("⚠\ufe0f Jugador '" + args[1] + "' no encontrado por nombre ni UserID."));
						}
					}
				}
				if ((Object)(object)target == (Object)null)
				{
					AliensInValheimMod.Logger.LogInfo((object)"⚠\ufe0f No hay jugador objetivo (target == null).");
				}
				else if (((Character)target).IsDead())
				{
					AliensInValheimMod.Logger.LogInfo((object)"⚠\ufe0f El jugador objetivo está muerto.");
				}
				if (num.HasValue && Configurations.List.Count > 0)
				{
					config = Configurations.List[num.Value];
				}
				else
				{
					config = Configurations.GetRandom();
				}
			}
			catch (Exception arg)
			{
				AliensInValheimMod.Logger.LogError((object)$"❌ Error en SolvePlayerAndConfiguration: {arg}");
				config = Configurations.GetRandom();
			}
		}

		private static Player ResolvePlayer(string token)
		{
			List<Player> allPlayers = Player.GetAllPlayers();
			Player val = ((IEnumerable<Player>)allPlayers).FirstOrDefault((Func<Player, bool>)((Player p) => p.GetPlayerName().Equals(token, StringComparison.OrdinalIgnoreCase)));
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if (long.TryParse(token, out var uid))
			{
				Player val2 = ((IEnumerable<Player>)allPlayers).FirstOrDefault((Func<Player, bool>)delegate(Player p)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					ZDOID zDOID = ((Character)p).GetZDOID();
					return ((ZDOID)(ref zDOID)).UserID == uid;
				});
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			return null;
		}

		private static bool TryResolveIndex(string token, int count, out int zeroBased)
		{
			zeroBased = -1;
			if (!int.TryParse(token, out var result))
			{
				return false;
			}
			if (count <= 0)
			{
				return false;
			}
			if (result < 1 || result > count)
			{
				return false;
			}
			zeroBased = result - 1;
			return true;
		}
	}
	public enum SoundChannel
	{
		BACKGROUND,
		ENGINE,
		LASER
	}
	public static class StableHash
	{
		public static int GetStableHashCode(string str)
		{
			int num = 352654597;
			int num2 = num;
			for (int i = 0; i < str.Length; i += 2)
			{
				num = ((num << 5) + num) ^ str[i];
				if (i == str.Length - 1)
				{
					break;
				}
				num2 = ((num2 << 5) + num2) ^ str[i + 1];
			}
			return num + num2 * 1566083941;
		}
	}
	public static class TimeHelper
	{
		public static bool IsNight()
		{
			if ((Object)(object)EnvMan.instance == (Object)null)
			{
				return false;
			}
			float dayFraction = EnvMan.instance.GetDayFraction();
			if (!(dayFraction > 0.75f))
			{
				return dayFraction < 0.25f;
			}
			return true;
		}

		public static bool IsBadWeather()
		{
			if ((Object)(object)EnvMan.instance == (Object)null)
			{
				return false;
			}
			EnvSetup currentEnvironment = EnvMan.instance.GetCurrentEnvironment();
			if (currentEnvironment == null || string.IsNullOrEmpty(currentEnvironment.m_name))
			{
				return false;
			}
			string name = currentEnvironment.m_name;
			if (!name.Contains("Rain") && !name.Contains("Thunder") && !name.Contains("Storm"))
			{
				return name.Contains("Mist");
			}
			return true;
		}

		public static bool HasIntervalPassed(float lastTime, float interval)
		{
			return Time.time - lastTime >= interval;
		}
	}
	[Serializable]
	public class Vec3
	{
		public float x;

		public float y;

		public float z;

		public Vec3()
		{
		}

		public Vec3(float x, float y, float z)
		{
			this.x = x;
			this.y = y;
			this.z = z;
		}
	}
	public static class VectorExtension
	{
		public static Vec3 FromUnity(this Vector3 v)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return new Vec3(v.x, v.y, v.z);
		}

		public static Vector3 ToUnity(this Vec3 v)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(v.x, v.y, v.z);
		}
	}
}
namespace AliensInValheim.I18n
{
	public static class Loc
	{
		private static CustomLocalization localization;

		private static string language = "English";

		public static void InitFromFolder(string modPath, string subfolder = "Translations")
		{
			try
			{
				language = PlayerPrefs.GetString("language", "English");
			}
			catch
			{
			}
			string text = Path.Combine(modPath, subfolder);
			localization = LocalizationManager.Instance.GetLocalization();
			if (!Directory.Exists(text))
			{
				Debug.LogWarning((object)("[Loc] No existe carpeta de traducciones: " + text));
				return;
			}
			string[] files = Directory.GetFiles(text, "*.json");
			foreach (string path in files)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(path);
				string text2 = File.ReadAllText(path);
				localization.AddJsonFile(fileNameWithoutExtension, text2);
				Debug.Log((object)("[Loc] " + fileNameWithoutExtension + ".json cargado correctamente"));
			}
			IEnumerable<string> languages = localization.GetLanguages();
			Debug.Log((object)("[Loc] Idiomas disponibles: " + string.Join(", ", languages)));
			Debug.Log((object)("[Loc] Traducciones inicializadas desde " + text));
		}

		public static string T(string token)
		{
			if (localization == null || string.IsNullOrWhiteSpace(token))
			{
				return token;
			}
			string text = (token.StartsWith("$") ? token : ("$" + token));
			return localization.TryTranslate(text);
		}

		public static string T(string token, params object[] args)
		{
			string text = T(token);
			if (args == null || args.Length == 0)
			{
				return text;
			}
			try
			{
				return string.Format(text, args);
			}
			catch
			{
				return text;
			}
		}
	}
}
namespace AliensInValheim.Commands
{
	internal class ClearOvnisCommand : ConsoleCommand
	{
		public override string Name => "clearovnis";

		public override string Help => "remueve los ovnis que estan en el cielo";

		public override void Run(string[] args)
		{
			AliensInValheimMod.ClearOvnis();
			AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] ✅ Se han borrado los ovnis cargados.");
		}
	}
}
namespace AliensInValheim.AlienAtack
{
	internal class OvniAtackCommand : ConsoleCommand
	{
		public override string Name => "ataquealien";

		public override string Help => "Inicia un ataque alienígena contra los jugadores cercanos.";

		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 _);
			OvniAttackRPC instance = OvniAttackRPC.Instance;
			AlienAtackData alienAtackData = new AlienAtackData();
			ZDOID zDOID = ((Character)target).GetZDOID();
			alienAtackData.UserID = ((ZDOID)(ref zDOID)).UserID;
			alienAtackData.Config = Configurations.GetByIndex(0);
			instance.SendCommandToAll(OvniAttackRPC.CommandName.START_ATACK, alienAtackData);
			AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] \ud83d\udef8 Se ha iniciado un ataque");
		}
	}
	internal class OvniAttackEvent : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <AttackRoutine>d__27 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public OvniAttackEvent <>4__this;

			public Player player;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0048: 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_0057: 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_00f1: 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_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_019f: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				OvniAttackEvent ovniAttackEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					ovniAttackEvent.ovni.PlaySounds();
					<>2__current = ((MonoBehaviour)ovniAttackEvent).StartCoroutine(ovniAttackEvent.ovni.MoveTowardsFixedTime(((Component)player).transform.position + Vector3.up * 10f));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					AliensInValheimMod.Logger.LogInfo((object)"[AlienAttack] OVNI en posición, iniciando ataque...");
					ovniAttackEvent.timer = 0f;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (ovniAttackEvent.timer < ovniAttackEvent.attackDuration)
				{
					ovniAttackEvent.timer += Time.deltaTime;
					if (!((Object)(object)player == (Object)null) && !((Character)player).IsDead())
					{
						ovniAttackEvent.actualDistance = Vector3.Distance(ovniAttackEvent.ovni.transform.position, ((Component)player).transform.position);
						Vector3 val = ((Component)player).transform.position + Vector3.up * 10f;
						ovniAttackEvent.currentTarget = Vector3.Lerp(ovniAttackEvent.currentTarget, val, Time.deltaTime * 2f);
						if ((Object)(object)ovniAttackEvent.ovni != (Object)null && (Object)(object)ovniAttackEvent.ovni.transform != (Object)null)
						{
							ovniAttackEvent.ovni.transform.position = Vector3.MoveTowards(ovniAttackEvent.ovni.transform.position, ovniAttackEvent.currentTarget, 25f * Time.deltaTime);
						}
						if (ovniAttackEvent.actualDistance < 20f && !ovniAttackEvent.isFiring && Time.time - ovniAttackEvent.lastFireTime >= 1.5f)
						{
							((MonoBehaviour)ovniAttackEvent).StartCoroutine(ovniAttackEvent.FireLaser(player));
							ovniAttackEvent.lastFireTime = Time.time;
						}
						ovniAttackEvent.UpdateCountdownUI();
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					AliensInValheimMod.Logger.LogInfo((object)"[AlienAttack] Jugador muerto, terminando ataque.");
				}
				AliensInValheimMod.Logger.LogInfo((object)"[AlienAttack] Tiempo de ataque completado.");
				((Renderer)ovniAttackEvent.laserBeam).enabled = false;
				OvniAttackRPC.Instance.SendCommandToAll(OvniAttackRPC.CommandName.END_ATACK, ovniAttackEvent.data);
				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 <FireLaser>d__28 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public OvniAttackEvent <>4__this;

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

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

			[DebuggerHidden]
			public <FireLaser>d__28(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();
					}
				}
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_0231: Unknown result type (might be due to invalid IL or missing references)
				//IL_023b: Expected O, but got Unknown
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_019a: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_019d: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: Expected O, but got Unknown
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					int num = <>1__state;
					OvniAttackEvent ovniAttackEvent = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						if ((Object)(object)player == (Object)null || (Object)(object)ovniAttackEvent.ovni == (Object)null || (Object)(object)ovniAttackEvent.laserBeam == (Object)null)
						{
							AliensInValheimMod.Logger.LogWarning((object)"[AlienAttack] FireLaser: Referencia nula detectada.");
							return false;
						}
						if (ovniAttackEvent.isFiring)
						{
							return false;
						}
						ovniAttackEvent.isFiring = true;
						<>1__state = -3;
						Vector3 position = ovniAttackEvent.ovni.transform.position;
						Vector3 val = ((Component)player).transform.position + Vector3.up * 1f;
						ovniAttackEvent.laserBeam.positionCount = 2;
						ovniAttackEvent.laserBeam.SetPosition(0, position);
						ovniAttackEvent.laserBeam.SetPosition(1, val);
						((Renderer)ovniAttackEvent.laserBeam).enabled = true;
						AliensInValheimMod.Logger.LogDebug((object)$"[AlienAttack] Disparando láser! Distancia: {ovniAttackEvent.actualDistance:F1}m");
						float num2 = player.CalculateFireDamage();
						ZDOID uid = default(ZDOID);
						((ZDOID)(ref uid))..ctor(0L, 0u);
						ZNetView component = ovniAttackEvent.ovni.GetComponent<ZNetView>();
						if ((Object)(object)component != (Object)null && component.IsValid() && component.GetZDO() != null)
						{
							uid = component.GetZDO().m_uid;
						}
						if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
						{
							HitData val2 = new HitData
							{
								m_damage = new DamageTypes
								{
									m_fire = num2
								},
								m_point = val
							};
							Vector3 val3 = val - position;
							val2.m_dir = ((Vector3)(ref val3)).normalized;
							val2.m_attacker = uid;
							HitData val4 = val2;
							((Character)player).Damage(val4);
							AliensInValheimMod.Logger.LogDebug((object)$"[AlienAttack] Daño aplicado: {num2:F1}");
						}
						float num3 = 0.15f;
						if ((Object)(object)ovniAttackEvent.FireClip != (Object)null && (Object)(object)ovniAttackEvent.lassserChannel != (Object)null)
						{
							ovniAttackEvent.lassserChannel.PlayOneShot(ovniAttackEvent.FireClip);
							num3 = ovniAttackEvent.FireClip.length;
						}
						<>2__current = (object)new WaitForSeconds(Mathf.Max(0.1f, num3));
						<>1__state = 1;
						return true;
					}
					case 1:
						<>1__state = -3;
						((Renderer)ovniAttackEvent.laserBeam).enabled = false;
						ovniAttackEvent.laserBeam.positionCount = 0;
						<>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()
			{
				<>1__state = -1;
				<>4__this.isFiring = false;
			}

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

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

			private object <>2__current;

			public OvniAttackEvent <>4__this;

			public AlienAtackData atackdata;

			public Player player;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				OvniAttackEvent ovniAttackEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					AliensInValheimMod.Logger.LogInfo((object)"[AlienAttack] Iniciando ataque alienígena.");
					ovniAttackEvent.CreateCountdownUI();
					ovniAttackEvent.attackDuration = Random.Range(10f, 20f);
					ovniAttackEvent.timer = 0f;
					ovniAttackEvent.lastFireTime = -1.5f;
					ovniAttackEvent.data = atackdata;
					ovniAttackEvent.ovni = AliensInValheimMod.Instance.Library.CreateOvni(((Component)player).transform.position + Vector3.up * 100f, ovniAttackEvent.data.Config, "UFO_Attack");
					ovniAttackEvent.currentTarget = ((Component)player).transform.position + Vector3.up * 10f;
					ovniAttackEvent.lassserChannel = ovniAttackEvent.ovni.GetAudioSource(SoundChannel.LASER);
					<>2__current = ((MonoBehaviour)ovniAttackEvent).StartCoroutine(ovniAttackEvent.AttackRoutine(player));
					<>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 <Stop>d__29 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public OvniAttackEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				OvniAttackEvent ovniAttackEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					AliensInValheimMod.Logger.LogInfo((object)"[AlienAttack] Ataque alienígena finalizado.");
					((MonoBehaviour)ovniAttackEvent).StartCoroutine(ovniAttackEvent.ovni.FadeOutAudio(8f));
					<>2__current = ((MonoBehaviour)ovniAttackEvent).StartCoroutine(ovniAttackEvent.ovni.FadeAndWarpAway(18f));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)ovniAttackEvent.panelGO != (Object)null)
					{
						Object.Destroy((Object)(object)ovniAttackEvent.panelGO);
					}
					if ((Object)(object)ovniAttackEvent.countdownPanel != (Object)null)
					{
						Object.Destroy((Object)(object)ovniAttackEvent.countdownPanel);
					}
					if ((Object)(object)ovniAttackEvent.ovni != (Object)null)
					{
						Object.Destroy((Object)(object)ovniAttackEvent.ovni);
					}
					if ((Object)(object)ovniAttackEvent.FireClip != (Object)null)
					{
						Object.Destroy((Object)(object)ovniAttackEvent.FireClip);
					}
					if ((Object)(object)ovniAttackEvent.laserBeam != (Object)null)
					{
						Object.Destroy((Object)(object)ovniAttackEvent.laserBeam);
					}
					if ((Object)(object)ovniAttackEvent.lassserChannel != (Object)null)
					{
						Object.Destroy((Object)(object)ovniAttackEvent.lassserChannel);
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>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();
			}
		}

		private GameObject ovni;

		private float attackDuration = 10f;

		private float timer;

		private const float ovniApproachSpeed = 25f;

		private const float maxFireDistance = 20f;

		private const float fireCooldown = 1.5f;

		private AlienAtackData data;

		private RectTransform countdownPanel;

		private Text countdownText;

		private GameObject panelGO;

		private static Material _laserAdditiveMat;

		private static readonly int SurfaceMask = LayerMask.GetMask(new string[4] { "Default", "static_solid", "terrain", "Water" });

		private float actualDistance;

		private float lastFireTime;

		private bool isFiring;

		private AudioClip FireClip;

		private AudioSource lassserChannel;

		private LineRenderer laserBeam;

		private Vector3 currentTarget;

		private void Awake()
		{
			FireClip = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>("assets/sounds/laser.mp3");
			laserBeam = CreateLasserBeam();
		}

		private void CreateCountdownUI()
		{
			//IL_003c: 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_005a: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			GameObject customGUIFront = GUIManager.CustomGUIFront;
			Transform val = ((customGUIFront != null) ? customGUIFront.transform : null);
			if ((Object)(object)val == (Object)null)
			{
				AliensInValheimMod.Logger.LogWarning((object)"[AlienAttack/UI] GUIManager.CustomGUIFront no disponible.");
				return;
			}
			panelGO = GUIManager.Instance.CreateWoodpanel(val, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -80f), 360f, 44f, false);
			((Object)panelGO).name = "Aliens_CountdownPanel";
			countdownPanel = panelGO.GetComponent<RectTransform>();
			countdownPanel.pivot = new Vector2(0.5f, 1f);
			Font averiaSerif = GUIManager.Instance.AveriaSerif;
			GameObject val2 = GUIManager.Instance.CreateText("Ataque OVNI: …", panelGO.transform, new Vector2(0f, 0f), new Vector2(1f, 1f), Vector2.zero, averiaSerif, 18, Color.cyan, true, new Color(0f, 0f, 0f, 0.9f), 0.25f, 0f, false);
			((Object)val2).name = "Aliens_CountdownText";
			countdownText = val2.GetComponent<Text>();
			RectTransform rectTransform = ((Graphic)countdownText).rectTransform;
			rectTransform.offsetMin = new Vector2(8f, 4f);
			rectTransform.offsetMax = new Vector2(-8f, -4f);
		}

		private GameObject TraverseHUDRoot()
		{
			try
			{
				FieldInfo field = typeof(Hud).GetField("m_rootObject", BindingFlags.Instance | BindingFlags.NonPublic);
				GameObject val = (GameObject)((field != null) ? /*isinst with value type is only supported in some contexts*/: null);
				object result;
				if (!((Object)(object)val != (Object)null))
				{
					Hud instance = Hud.instance;
					result = ((instance != null) ? ((Component)instance).gameObject : null);
				}
				else
				{
					result = val;
				}
				return (GameObject)result;
			}
			catch
			{
				Hud instance2 = Hud.instance;
				return (instance2 != null) ? ((Component)instance2).gameObject : null;
			}
		}

		private void UpdateCountdownUI()
		{
			float num = Mathf.Max(0f, attackDuration - timer);
			if ((Object)(object)countdownText != (Object)null)
			{
				countdownText.text = $"<color=#00FFFF>Ataque OVNI:</color> {num:F1} s | Distancia: {actualDistance:F1}m";
			}
		}

		private static bool TryGetSurfaceY(Vector3 worldXZ, out float y)
		{
			//IL_0000: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(new Vector3(worldXZ.x, 2000f, worldXZ.z), Vector3.down, ref val, 4000f, SurfaceMask, (QueryTriggerInteraction)1))
			{
				y = ((RaycastHit)(ref val)).point.y;
				return true;
			}
			y = 0f;
			return false;
		}

		public static Vector3 GetPlayerGroupCenterNearSurface(Player player, float radiusMeters = 50f, float hover = 15f, float absoluteCeil = 90f)
		{
			//IL_0066: 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_006e: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			List<Player> list = (from p in Player.GetAllPlayers()
				where (Object)(object)p != (Object)null && Vector3.Distance(((Component)player).transform.position, ((Component)p).transform.position) <= radiusMeters
				select p).ToList();
			if (list.Count == 0)
			{
				list.Add(player);
			}
			float num = 0f;
			float num2 = 0f;
			foreach (Player item in list)
			{
				Vector3 position = ((Component)item).transform.position;
				num += position.x;
				num2 += position.z;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(num / (float)list.Count, 0f, num2 / (float)list.Count);
			if (TryGetSurfaceY(val, out var y))
			{
				val.y = Mathf.Min(y + hover, absoluteCeil);
			}
			else
			{
				val.y = Mathf.Min(((Component)player).transform.position.y + hover, absoluteCeil);
			}
			return val;
		}

		private LineRenderer CreateLasserBeam()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			LineRenderer obj = ((Component)this).gameObject.AddComponent<LineRenderer>();
			obj.positionCount = 2;
			((Renderer)obj).enabled = true;
			obj.startColor = Color.red;
			obj.endColor = Color.red;
			((Renderer)obj).enabled = true;
			obj.useWorldSpace = true;
			((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)obj).receiveShadows = false;
			obj.textureMode = (LineTextureMode)0;
			obj.widthMultiplier = 0.25f;
			((Renderer)obj).material = (Material)(Object.op_Implicit((Object)(object)_laserAdditiveMat) ? ((object)_laserAdditiveMat) : ((object)new Material(Shader.Find("Sprites/Default"))));
			obj.startColor = Color.red;
			obj.endColor = Color.red;
			return obj;
		}

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

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

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

		[IteratorStateMachine(typeof(<Stop>d__29))]
		internal IEnumerator Stop()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Stop>d__29(0)
			{
				<>4__this = this
			};
		}
	}
	internal class AlienAtackData
	{
		public Vec3 OvniPosition;

		public long UserID { get; set; }

		public OvniConfiguration Config { get; set; }

		public AlienAtackData()
		{
			Config = new OvniConfiguration();
		}
	}
	internal class OvniAttackRPC : CommandRPCBase<OvniAttackRPC.CommandName, AlienAtackData>
	{
		public enum CommandName
		{
			START_ATACK,
			END_ATACK,
			OVNI_MOVEMENT
		}

		private const string RPC_ID = "AliensInValheim_AlienAttack";

		private static OvniAttackRPC _singleton = null;

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

		protected override string RPCName => "AliensInValheim_RPC_OvniAtack";

		public static event Action<Player> ExcecuteAttactEvent;
	}
}
namespace AliensInValheim.FlyOvni
{
	public class FlyOvniCommand : ConsoleCommand
	{
		public override string Name => "verovni";

		public override string Help => "Hace pasar un ovni por la pantalla";

		public override void Run(string[] args)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Player target = Player.m_localPlayer;
			AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] flyovni Command argumentos {args.Length}.");
			PlayerExtensions.SolvePlayerAndConfiguration(args, out target, out var config);
			FlyOvniRPC instance = FlyOvniRPC.Instance;
			FlyOvniData flyOvniData = new FlyOvniData();
			ZDOID zDOID = ((Character)target).GetZDOID();
			flyOvniData.UserID = ((ZDOID)(ref zDOID)).UserID;
			flyOvniData.PlayerName = target.GetPlayerName();
			flyOvniData.Config = config;
			instance.SendCommandToAll(FlyOvniRPC.CommandName.FLY_OVNI, flyOvniData);
			AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] \ud83d\udef8 Ver ovni para " + target.GetPlayerName() + " con OVNI " + config.PrefabName));
		}
	}
	internal class FlyOvniEvent : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <StartEvent>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public OvniConfiguration config;

			public FlyOvniEvent <>4__this;

			private Vector3 <startPosition>5__2;

			private Vector3 <to>5__3;

			private GameObject <ufo>5__4;

			private float <duration>5__5;

			private Vector3 <lastPos>5__6;

			private float <t>5__7;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006a: 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_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: 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_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_0218: Unknown result type (might be due to invalid IL or missing references)
				//IL_021e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_0228: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0231: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_029a: 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_024c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0251: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				FlyOvniEvent flyOvniEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if ((Object)(object)player == (Object)null)
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] FlyOvniEvent.Start No se encontro jugador");
						return false;
					}
					AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] Ovni pasa Volando sobre " + player.GetPlayerName()));
					Vector3 val = ((Component)player).transform.position + Vector3.up * 30f;
					<startPosition>5__2 = val + ((Component)player).transform.right * 80f;
					<to>5__3 = val + ((Component)player).transform.right * -80f;
					<ufo>5__4 = AliensInValheimMod.Instance.Library.CreateOvni(<startPosition>5__2, config);
					if ((Object)(object)<ufo>5__4 == (Object)null)
					{
						return false;
					}
					<ufo>5__4.PlaySounds();
					<duration>5__5 = 8f;
					<lastPos>5__6 = <startPosition>5__2;
					<t>5__7 = 0f;
					break;
				}
				case 1:
					<>1__state = -1;
					<t>5__7 += Time.deltaTime;
					break;
				}
				Vector3 val3;
				if (<t>5__7 < <duration>5__5)
				{
					float num2 = <t>5__7 / <duration>5__5;
					Vector3 val2 = Vector3.Lerp(<startPosition>5__2, <to>5__3, num2);
					val3 = val2 - <lastPos>5__6;
					Vector3 normalized = ((Vector3)(ref val3)).normalized;
					if (((Vector3)(ref normalized)).sqrMagnitude > 0.0001f)
					{
						Quaternion val4 = Quaternion.LookRotation(normalized, Vector3.up);
						<ufo>5__4.transform.rotation = Quaternion.Slerp(<ufo>5__4.transform.rotation, val4, Time.deltaTime * 1f);
					}
					<ufo>5__4.transform.position = val2;
					<lastPos>5__6 = val2;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				val3 = <to>5__3 - <startPosition>5__2;
				Vector3 normalized2 = ((Vector3)(ref val3)).normalized;
				if (((Vector3)(ref normalized2)).sqrMagnitude > 0.0001f)
				{
					<ufo>5__4.transform.rotation = Quaternion.LookRotation(normalized2, Vector3.up);
				}
				((MonoBehaviour)flyOvniEvent).StartCoroutine(<ufo>5__4.FadeOutAudio(5f));
				((MonoBehaviour)flyOvniEvent).StartCoroutine(<ufo>5__4.FadeAndWarAwayAndDestroy());
				((MonoBehaviour)flyOvniEvent).StartCoroutine(Minimap.instance.AddCustomPin(((Component)player).transform.position, "assets/sprites/ovni.png", "OVNI"));
				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 void Awake()
		{
		}

		[IteratorStateMachine(typeof(<StartEvent>d__1))]
		internal IEnumerator StartEvent(Player player, OvniConfiguration config)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartEvent>d__1(0)
			{
				<>4__this = this,
				player = player,
				config = config
			};
		}
	}
	internal class FlyOvniData
	{
		public string PlayerName { get; set; }

		public long UserID { get; set; }

		public OvniConfiguration Config { get; set; }
	}
	internal class FlyOvniRPC : CommandRPCBase<FlyOvniRPC.CommandName, FlyOvniData>
	{
		public enum CommandName
		{
			FLY_OVNI,
			FLY_FAST
		}

		private static FlyOvniRPC _singleton = null;

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

		protected override string RPCName => "AliensInValheim_RPC_FlyWithoutAbduction";

		private FlyOvniRPC()
		{
		}
	}
}
namespace AliensInValheim.AlienSpeak
{
	internal class SpeakAlienCommand : ConsoleCommand
	{
		public override string Name => "alienmurmura";

		public override string Help => "hace que los aliens hablen";

		public override void Run(string[] args)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			SpeakAlienRPC instance = SpeakAlienRPC.Instance;
			SpeakAlienData speakAlienData = new SpeakAlienData();
			ZDOID zDOID = ((Character)Player.m_localPlayer).GetZDOID();
			speakAlienData.UserID = ((ZDOID)(ref zDOID)).UserID;
			instance.SendCommandToAll(SpeakAlienRPC.CommandName.SPEAK_ALIEN, speakAlienData);
		}
	}
	internal class SpeakAlienEvent : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <PlayAlienVoice>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public SpeakAlienEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				SpeakAlienEvent speakAlienEvent = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				int num2 = Random.Range(1, 6);
				AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] Alinigena se comunica con {player.GetPlayerName()} index {num2}");
				if ((Object)(object)speakAlienEvent.alienVoiceSource == (Object)null)
				{
					AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] alienSoundSource no está asignado.");
					return false;
				}
				AudioClip clip = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>($"assets/sounds/alien_voice{num2}.mp3");
				speakAlienEvent.alienVoiceSource.volume = 1f;
				speakAlienEvent.alienVoiceSource.clip = clip;
				speakAlienEvent.alienVoiceSource.loop = false;
				speakAlienEvent.alienVoiceSource.Play();
				AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] Sonido de voz alien reproducido: {num2}");
				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 alienVoiceSource;

		public void Awake()
		{
			alienVoiceSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			alienVoiceSource.volume = 1f;
			alienVoiceSource.spatialBlend = 0f;
			alienVoiceSource.playOnAwake = false;
			alienVoiceSource.loop = false;
		}

		[IteratorStateMachine(typeof(<PlayAlienVoice>d__2))]
		internal IEnumerator PlayAlienVoice(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayAlienVoice>d__2(0)
			{
				<>4__this = this,
				player = player
			};
		}
	}
	internal class SpeakAlienData
	{
		public long UserID { get; set; }

		public string PlayerName { get; set; }
	}
	internal class SpeakAlienRPC : CommandRPCBase<SpeakAlienRPC.CommandName, SpeakAlienData>
	{
		public enum CommandName
		{
			SPEAK_ALIEN
		}

		private static SpeakAlienRPC _singleton = null;

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

		protected override string RPCName => "AliensInValheim_RPC_SpeakAlien";

		private SpeakAlienRPC()
		{
		}
	}
}
namespace AliensInValheim.Pins
{
	internal enum UfoIconKind
	{
		Ovni,
		Alien
	}
	internal static class UfoSprites
	{
		private static readonly Dictionary<UfoIconKind, Sprite> Cache = new Dictionary<UfoIconKind, Sprite>();

		private const string OvniSpriteName = "assets/sprites/ovni.png";

		private const string AlienSpriteName = "assets/sprites/alien.png";

		private static AssetBundle _bundle;

		public static void SetBundle(AssetBundle bundle)
		{
			_bundle = bundle;
		}

		public static Sprite Ensure(UfoIconKind kind)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (Cache.TryGetValue(kind, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if ((Object)(object)_bundle == (Object)null)
			{
				AliensInValheimMod.Logger.LogError((object)"[UfoSprites] AssetBundle no establecido.");
				return null;
			}
			string text = ((kind == UfoIconKind.Ovni) ? "assets/sprites/ovni.png" : "assets/sprites/alien.png");
			Texture2D val = _bundle.LoadAsset<Texture2D>(text);
			if ((Object)(object)val == (Object)null)
			{
				AliensInValheimMod.Logger.LogError((object)("[UfoSprites] No se encontró Texture2D '" + text + "' en el bundle."));
				return null;
			}
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			Sprite val4 = Sprite.Create(val, val2, val3, 100f);
			Cache[kind] = val4;
			return val4;
		}

		public static Sprite Ensure(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				key = "ovni";
			}
			key = key.ToLowerInvariant();
			if (!key.Contains("alien"))
			{
				return Ensure(UfoIconKind.Ovni);
			}
			return Ensure(UfoIconKind.Alien);
		}
	}
}
namespace AliensInValheim.Patches
{
	[HarmonyPatch]
	internal static class Patch_Minimap_AddPin
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return from m in AccessTools.GetDeclaredMethods(typeof(Minimap))
				where m.Name == "AddPin" && m.GetParameters().Length >= 5 && m.GetParameters()[0].ParameterType == typeof(Vector3)
				select m;
		}

		private static void Postfix(Minimap __instance, ref PinData __result)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (__result == null || string.IsNullOrEmpty(__result.m_name))
			{
				return;
			}
			Sprite val = (__result.m_name.ToLowerInvariant().Contains("alien") ? UfoSprites.Ensure(UfoIconKind.Alien) : UfoSprites.Ensure(UfoIconKind.Ovni));
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			__result.m_icon = val;
			if ((Object)(object)__result.m_uiElement != (Object)null)
			{
				Transform obj = ((Component)__result.m_uiElement).transform.Find("icon");
				Image val2 = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.sprite = val;
					val2.type = (Type)0;
					val2.preserveAspect = true;
					((Graphic)val2).color = Color.white;
				}
			}
		}
	}
}
namespace AliensInValheim.AlienSighting
{
	internal class AlienSightingCommand : ConsoleCommand
	{
		public override string Name => "alienaparece";

		public override string Help => "Hace aparecer un alien a un jugador.\nUso: alienaparece [NombreJugador]\nEjemplos:\n - alienaparece        → hace aparecer un alien sobre ti\n - alienaparece fulano → hace aparecer un alien sobre Fulano\n";

		public override void Run(string[] args)
		{
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			Player val = null;
			if (args == null || args.Length == 0)
			{
				val = Player.m_localPlayer;
				if ((Object)(object)val == (Object)null)
				{
					AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] ⚠\ufe0f No se pudo determinar el jugador local.");
					return;
				}
				AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] Sin nombre: usando jugador local '" + val.GetPlayerName() + "'."));
			}
			else
			{
				if (args.Length != 1)
				{
					AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] Uso incorrecto. Formato: alienaparece [NombreJugador]");
					return;
				}
				string playerArg = args[0];
				List<Player> allPlayers = Player.GetAllPlayers();
				val = ((IEnumerable<Player>)allPlayers).FirstOrDefault((Func<Player, bool>)((Player p) => p.GetPlayerName().Equals(playerArg, StringComparison.OrdinalIgnoreCase)));
				if ((Object)(object)val == (Object)null)
				{
					List<Player> list = allPlayers.Where((Player p) => p.GetPlayerName().IndexOf(playerArg, StringComparison.OrdinalIgnoreCase) >= 0).ToList();
					if (list.Count != 1)
					{
						if (list.Count > 1)
						{
							string text = string.Join(", ", list.Select((Player p) => p.GetPlayerName()));
							AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] ⚠\ufe0f Coincidencias múltiples: " + text + ". Especifica el nombre completo."));
						}
						else
						{
							AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] ⚠\ufe0f Jugador '" + playerArg + "' no encontrado."));
						}
						return;
					}
					val = list[0];
				}
			}
			if ((Object)(object)val == (Object)null || ((Character)val).IsDead())
			{
				AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] ⚠\ufe0f El jugador no es válido o está muerto.");
				return;
			}
			AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] ✅ Iniciando aparición de alien sobre '" + val.GetPlayerName() + "'."));
			AlienSightingRPC instance = AlienSightingRPC.Instance;
			AlienSightingData alienSightingData = new AlienSightingData();
			ZDOID zDOID = ((Character)val).GetZDOID();
			alienSightingData.UserID = ((ZDOID)(ref zDOID)).UserID;
			alienSightingData.PlayerName = val.GetPlayerName();
			instance.SendCommandToAll(AlienSightingRPC.CommandName.ALIEN_SIGHTING_START, alienSightingData);
		}
	}
	public class AlienSightingEvent : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <MaxLifetimeTimer>d__17 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AlienSightingEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				//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)
				int num = <>1__state;
				AlienSightingEvent alienSightingEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (alienSightingEvent.maxLifetimeSeconds > 0f)
					{
						<>2__current = (object)new WaitForSeconds(alienSightingEvent.maxLifetimeSeconds);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					if ((Object)(object)alienSightingEvent.alien != (Object)null)
					{
						AliensInValheimMod.Logger.LogInfo((object)$"[AlienSightingEvent] Tiempo máximo ({alienSightingEvent.maxLifetimeSeconds}s) alcanzado. Retirando alien.");
						AlienSightingRPC instance = AlienSightingRPC.Instance;
						AlienSightingData alienSightingData = new AlienSightingData();
						ZDOID zDOID = ((Character)alienSightingEvent.targetPlayer).GetZDOID();
						alienSightingData.UserID = ((ZDOID)(ref zDOID)).UserID;
						alienSightingData.PlayerName = alienSightingEvent.targetPlayer.GetPlayerName();
						instance.SendCommandToAll(AlienSightingRPC.CommandName.ALIEN_SIGHTING_STOP, alienSightingData);
					}
					break;
				}
				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 <MonitorProximity>d__16 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AlienSightingEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				AlienSightingEvent alienSightingEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if ((Object)(object)alienSightingEvent.alien == (Object)null)
				{
					return false;
				}
				ZDOID zDOID;
				if ((Object)(object)alienSightingEvent.targetPlayer == (Object)null || ((Character)alienSightingEvent.targetPlayer).IsDead())
				{
					AliensInValheimMod.Logger.LogInfo((object)"[AlienSightingEvent] Jugador objetivo nulo o muerto. Retirando alien.");
					AlienSightingRPC instance = AlienSightingRPC.Instance;
					AlienSightingData alienSightingData = new AlienSightingData();
					zDOID = ((Character)alienSightingEvent.targetPlayer).GetZDOID();
					alienSightingData.UserID = ((ZDOID)(ref zDOID)).UserID;
					alienSightingData.PlayerName = alienSightingEvent.targetPlayer.GetPlayerName();
					instance.SendCommandToAll(AlienSightingRPC.CommandName.ALIEN_SIGHTING_STOP, alienSightingData);
					return false;
				}
				float num2 = Vector3.Distance(alienSightingEvent.alien.transform.position, ((Component)alienSightingEvent.targetPlayer).transform.position);
				if (num2 <= alienSightingEvent.despawnDistance)
				{
					AliensInValheimMod.Logger.LogInfo((object)$"[AlienSightingEvent] Jugador '{alienSightingEvent.targetPlayer.GetPlayerName()}' se acercó ({num2:0.0}m ≤ {alienSightingEvent.despawnDistance}m). Retirando alien.");
					AlienSightingRPC instance2 = AlienSightingRPC.Instance;
					AlienSightingData alienSightingData2 = new AlienSightingData();
					zDOID = ((Character)alienSightingEvent.targetPlayer).GetZDOID();
					alienSightingData2.UserID = ((ZDOID)(ref zDOID)).UserID;
					alienSightingData2.PlayerName = alienSightingEvent.targetPlayer.GetPlayerName();
					instance2.SendCommandToAll(AlienSightingRPC.CommandName.ALIEN_SIGHTING_STOP, alienSightingData2);
					return false;
				}
				<>2__current = null;
				<>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();
			}
		}

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

			private object <>2__current;

			public Player player;

			public AlienSightingEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				AlienSightingEvent alienSightingEvent = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				int num2 = Random.Range(1, 6);
				AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] Alienígena se comunica con {player.GetPlayerName()} (index {num2})");
				if ((Object)(object)alienSightingEvent.alienVoiceSource == (Object)null)
				{
					AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] alienVoiceSource no está asignado.");
					return false;
				}
				AudioClip val = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>($"assets/sounds/alien_voice{num2}.mp3");
				if ((Object)(object)val == (Object)null)
				{
					AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] No se encontró audio alien_voice{num2}.mp3");
					return false;
				}
				alienSightingEvent.alienVoiceSource.volume = 1f;
				alienSightingEvent.alienVoiceSource.clip = val;
				alienSightingEvent.alienVoiceSource.loop = false;
				alienSightingEvent.alienVoiceSource.Play();
				AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] Sonido de voz alien reproducido: {num2}");
				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 <PlayLoopingMusic>d__13 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AlienSightingEvent <>4__this;

			public float volume;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				AlienSightingEvent alienSightingEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					AudioClip val = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>("assets/sounds/ufo_terror4.mp3");
					if ((Object)(object)val == (Object)null)
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] MusicClip no encontrado.");
						return false;
					}
					if ((Object)(object)alienSightingEvent.musicSource == (Object)null)
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] musicSource no está inicializado.");
						return false;
					}
					if (alienSightingEvent.musicSource.isPlaying)
					{
						alienSightingEvent.musicSource.Stop();
					}
					alienSightingEvent.musicSource.volume = volume;
					alienSightingEvent.musicSource.clip = val;
					alienSightingEvent.musicSource.loop = true;
					alienSightingEvent.musicSource.Play();
					AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] Música reproducida: " + ((Object)val).name));
					<>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 <StartEvent>d__14 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AlienSightingData data;

			public AlienSightingEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Expected O, but got Unknown
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Expected O, but got Unknown
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: 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)
				int num = <>1__state;
				AlienSightingEvent alienSightingEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					AliensInValheimMod.Logger.LogInfo((object)("[AlienSightingEvent] Start para " + data.PlayerName));
					if ((Object)(object)alienSightingEvent.targetPlayer == (Object)null || ((Character)alienSightingEvent.targetPlayer).IsDead())
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AlienSightingEvent] Jugador objetivo inválido o muerto.");
						return false;
					}
					Vector3 farSpawnPosition = alienSightingEvent.GetFarSpawnPosition(((Component)alienSightingEvent.targetPlayer).transform.position, alienSightingEvent.spawnMinDistance, alienSightingEvent.spawnMaxDistance);
					alienSightingEvent.alien = AliensInValheimMod.Instance.Library.CreateAlien(farSpawnPosition, "assets/alien1/prefab/alien1.prefab");
					if ((Object)(object)alienSightingEvent.alien == (Object)null)
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AlienSightingEvent] No se pudo instanciar el alien.");
						return false;
					}
					<>2__current = alienSightingEvent.TeleportInAlien(farSpawnPosition, alienSightingEvent.alien);
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					Light obj = alienSightingEvent.alien.AddComponent<Light>();
					obj.type = (LightType)2;
					obj.range = 10f;
					obj.intensity = 4f;
					obj.color = Color.red;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 2;
					return true;
				}
				case 2:
					<>1__state = -1;
					((MonoBehaviour)alienSightingEvent).StartCoroutine(alienSightingEvent.PlayLoopingMusic(0.7f));
					<>2__current = (object)new WaitForSeconds(1.5f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					((MonoBehaviour)alienSightingEvent).StartCoroutine(alienSightingEvent.PlayAlienVoice(alienSightingEvent.targetPlayer));
					alienSightingEvent.proximityRoutine = ((MonoBehaviour)alienSightingEvent).StartCoroutine(alienSightingEvent.MonitorProximity());
					alienSightingEvent.lifetimeRoutine = ((MonoBehaviour)alienSightingEvent).StartCoroutine(alienSightingEvent.MaxLifetimeTimer());
					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 <Stop>d__19 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AlienSightingEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				AlienSightingEvent alienSightingEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (alienSightingEvent.proximityRoutine != null)
					{
						((MonoBehaviour)alienSightingEvent).StopCoroutine(alienSightingEvent.proximityRoutine);
						alienSightingEvent.proximityRoutine = null;
					}
					if (alienSightingEvent.lifetimeRoutine != null)
					{
						((MonoBehaviour)alienSightingEvent).StopCoroutine(alienSightingEvent.lifetimeRoutine);
						alienSightingEvent.lifetimeRoutine = null;
					}
					AliensInValheimMod.Logger.LogInfo((object)"AliensInValheim \ud83d\udef8 El alien se retira.");
					if ((Object)(object)alienSightingEvent.alien != (Object)null)
					{
						Object.Destroy((Object)(object)alienSightingEvent.alien);
						alienSightingEvent.alien = null;
					}
					if ((Object)(object)alienSightingEvent.musicSource != (Object)null && alienSightingEvent.musicSource.isPlaying)
					{
						((MonoBehaviour)alienSightingEvent).StartCoroutine(alienSightingEvent.musicSource.FadeOutAudio(3f));
					}
					if ((Object)(object)alienSightingEvent.alienVoiceSource != (Object)null && alienSightingEvent.alienVoiceSource.isPlaying)
					{
						alienSightingEvent.alienVoiceSource.Stop();
					}
					<>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 <TeleportInAlien>d__18 : 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__18(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 = null;
					<>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();
			}
		}

		private GameObject alien;

		private AudioSource musicSource;

		private AudioSource alienVoiceSource;

		private Player targetPlayer;

		private Coroutine proximityRoutine;

		private Coroutine lifetimeRoutine;

		[SerializeField]
		private float despawnDistance = 50f;

		[SerializeField]
		private float maxLifetimeSeconds = 60f;

		[SerializeField]
		private float spawnMinDistance = 60f;

		[SerializeField]
		private float spawnMaxDistance = 120f;

		private int groundMask;

		public void Awake()
		{
			alienVoiceSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			alienVoiceSource.volume = 1f;
			alienVoiceSource.spatialBlend = 0f;
			alienVoiceSource.playOnAwake = false;
			alienVoiceSource.loop = false;
			musicSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			musicSource.volume = 0.4f;
			musicSource.spatialBlend = 0f;
			musicSource.playOnAwake = false;
			musicSource.loop = true;
			groundMask = LayerMask.GetMask(new string[6] { "Default", "terrain", "piece", "static_solid", "Default_small", "Water" });
			if (groundMask == 0)
			{
				groundMask = -5;
			}
		}

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

		[IteratorStateMachine(typeof(<PlayLoopingMusic>d__13))]
		public IEnumerator PlayLoopingMusic(float volume = 1f)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayLoopingMusic>d__13(0)
			{
				<>4__this = this,
				volume = volume
			};
		}

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

		private Vector3 GetFarSpawnPosition(Vector3 center, float minDist, float maxDist, int maxTries = 12)
		{
			//IL_003b: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_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_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_0078: Unknown result type (might be due to invalid IL or missing references)
			if (maxDist < minDist)
			{
				maxDist = minDist;
			}
			Vector3 val = default(Vector3);
			RaycastHit val2 = default(RaycastHit);
			for (int i = 0; i < maxTries; i++)
			{
				float num = Random.Range(0f, (float)Math.PI * 2f);
				float num2 = Random.Range(minDist, maxDist);
				((Vector3)(ref val))..ctor(Mathf.Cos(num), 0f, Mathf.Sin(num));
				if (Physics.Raycast(center + val * num2 + Vector3.up * 200f, Vector3.down, ref val2, 500f, groundMask, (QueryTriggerInteraction)1))
				{
					return ((RaycastHit)(ref val2)).point;
				}
			}
			AliensInValheimMod.Logger.LogInfo((object)"[AlienSightingEvent] No se pudo raycastear suelo. Usando offset plano.");
			return center + Vector3.forward * minDist;
		}

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

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

		[IteratorStateMachine(typeof(<TeleportInAlien>d__18))]
		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__18(0)
			{
				spawnPos = spawnPos,
				alien = alien
			};
		}

		[IteratorStateMachine(typeof(<Stop>d__19))]
		internal IEnumerator Stop()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Stop>d__19(0)
			{
				<>4__this = this
			};
		}
	}
	internal class AlienSightingData
	{
		public long UserID { get; set; }

		public string PlayerName { get; set; }
	}
	internal class AlienSightingRPC : CommandRPCBase<AlienSightingRPC.CommandName, AlienSightingData>
	{
		public enum CommandName
		{
			ALIEN_SIGHTING_START,
			ALIEN_SIGHTING_STOP
		}

		private static AlienSightingRPC _singleton = null;

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

		protected override string RPCName => "AliensInValheim_RPC_AlienSighting";

		private AlienSightingRPC()
		{
		}
	}
}
namespace AliensInValheim.OvniScan
{
	public class OvniScanCommand : ConsoleCommand
	{
		public override string Name => "scanovni";

		public override string Help => "Hace que un OVNI realice un escaneo (rayo de luz) sobre uno o varios jugadores.";

		public override void Run(string[] args)
		{
			Player localPlayer = Player.m_localPlayer;
			List<Player> list = new List<Player>();
			int? num = null;
			AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] scanovni Command argumentos {args.Length}.");
			if (args.Length == 0)
			{
				list = Player.GetAllPlayers().ToList();
				AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] Escaneo OVNI sobre {list.Count} jugadores (todos).");
			}
			else if (args.Length == 1)
			{
				string arg = args[0];
				Player val = ((IEnumerable<Player>)Player.GetAllPlayers()).FirstOrDefault((Func<Player, bool>)((Player p) => p.GetPlayerName().Equals(arg, StringComparison.OrdinalIgnoreCase)));
				if ((Object)(object)val != (Object)null)
				{
					list.Add(val);
				}
				else
				{
					if (!int.TryParse(arg, out var result))
					{
						AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] ⚠\ufe0f '" + arg + "' no es un nombre de jugador ni un índice válido."));
						return;
					}
					if (result < 1 || result > Configurations.List.Count)
					{
						AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] ⚠\ufe0f Índice de OVNI fuera de rango. Debe estar entre 1 y {Configurations.List.Count}.");
						return;
					}
					num = result - 1;
					list = Player.GetAllPlayers().ToList();
					AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] Escaneo sobre todos los jugadores con OVNI #{num.Value + 1}.");
				}
			}
			else if (args.Length == 2)
			{
				Player val2 = ((IEnumerable<Player>)Player.GetAllPlayers()).FirstOrDefault((Func<Player, bool>)((Player p) => p.GetPlayerName().Equals(args[0], StringComparison.OrdinalIgnoreCase)));
				if ((Object)(object)val2 == (Object)null)
				{
					AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] ⚠\ufe0f Jugador '" + args[0] + "' no encontrado."));
					return;
				}
				list.Add(val2);
				if (!int.TryParse(args[1], out var result2))
				{
					AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] ⚠\ufe0f El segundo argumento '" + args[1] + "' no es un número válido."));
					return;
				}
				if (result2 < 1 || result2 > Configurations.List.Count)
				{
					AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] ⚠\ufe0f Índice de OVNI fuera de rango. Debe estar entre 1 y {Configurations.List.Count}.");
					return;
				}
				num = result2 - 1;
			}
			if (list == null || list.Count == 0)
			{
				AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] ⚠\ufe0f No hay jugadores válidos para escanear.");
				return;
			}
			if (list.Any((Player p) => (Object)(object)p == (Object)null || ((Character)p).IsDead()))
			{
				AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] ⚠\ufe0f Uno o más jugadores no son válidos o están muertos.");
				list = list.Where((Player p) => (Object)(object)p != (Object)null && !((Character)p).IsDead()).ToList();
				if (list.Count == 0)
				{
					return;
				}
			}
			if (!num.HasValue)
			{
				Configurations.GetRandom();
			}
			else
			{
				_ = Configurations.List[num.Value];
			}
			OvniScanRPC.Instance.SendCommandToAll(OvniScanRPC.CommandName.START_SCAN, new OvniScanRPC.ScanOvniData
			{
				PlayerName = localPlayer.GetPlayerName(),
				UserID = localPlayer.GetPlayerID(),
				Config = Configurations.GetRandom()
			});
			AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] \ud83d\udef8 Escaneo OVNI iniciado sobre " + localPlayer.GetPlayerName() + " con configuración " + (num.HasValue ? $"#{num.Value + 1}" : "aleatoria") + "."));
		}
	}
	public class OvniScanEvent : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass9_0
		{
			public Vector3 center;

			public float sqrRadius;

			internal bool <StartEvent>b__1(Player p)
			{
				//IL_0006: 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_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = ((Component)p).transform.position - center;
				return ((Vector3)(ref val)).sqrMagnitude <= sqrRadius;
			}

			internal float <StartEvent>b__2(Player p)
			{
				//IL_0006: 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_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = ((Component)p).transform.position - center;
				return ((Vector3)(ref val)).sqrMagnitude;
			}
		}

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

			private object <>2__current;

			public OvniScanEvent <>4__this;

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

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

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

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

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

			private object <>2__current;

			public OvniScanEvent <>4__this;

			public GameObject ovni;

			public Player p;

			public float seconds;

			private float <wobbleAmp>5__2;

			private float <wobbleFreq>5__3;

			private float <elapsed>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a0: 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_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: 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_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_0163: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_016d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				OvniScanEvent ovniScanEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)ovniScanEvent._beam != (Object)null)
					{
						<>2__current = ovniScanEvent.SetBeamIntensity(1.5f, 0.5f);
						<>1__state = 1;
						return true;
					}
					goto IL_005d;
				case 1:
					<>1__state = -1;
					goto IL_005d;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_005d:
					<wobbleAmp>5__2 = 1f;
					<wobbleFreq>5__3 = 1.2f;
					<elapsed>5__4 = 0f;
					break;
				}
				if (<elapsed>5__4 < seconds)
				{
					<elapsed>5__4 += Time.deltaTime;
					Vector3 position = ovni.transform.position;
					position.y += Mathf.Sin(Time.time * <wobbleFreq>5__3) * (<wobbleAmp>5__2 * Time.deltaTime);
					ovni.transform.position = position;
					ovni.transform.rotation = Quaternion.Slerp(ovni.transform.rotation, Quaternion.LookRotation(Vector3.down), Time.deltaTime * 0.6f);
					if ((Object)(object)ovniScanEvent._beamPivot != (Object)null && (Object)(object)p != (Object)null)
					{
						Vector3 val = ((Component)p).transform.position + Vector3.up * 1.6f - ovniScanEvent._beamPivot.position;
						Vector3 normalized = ((Vector3)(ref val)).normalized;
						if (((Vector3)(ref normalized)).sqrMagnitude > 0.0001f)
						{
							Quaternion val2 = Quaternion.LookRotation(normalized);
							ovniScanEvent._beamPivot.rotation = Quaternion.Slerp(ovniScanEvent._beamPivot.rotation, val2, Time.deltaTime * 6f);
						}
					}
					if ((Object)(object)ovniScanEvent._beam != (Object)null)
					{
						ovniScanEvent._beam.intensity = 1.5f + Mathf.PingPong(Time.time * 0.9f, 0.6f);
					}
					<>2__current = null;
					<>1__state = 2;
					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 <NavigateTo>d__13 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public OvniScanEvent <>4__this;

			public OvniScanRPC.ScanOvniData data;

			private Player <player>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				OvniScanEvent ovniScanEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)ovniScanEvent.ovni == (Object)null)
					{
						AliensInValheimMod.Logger.LogWarning((object)"[OvniScanClient] No se pudo crear OVNI local.");
						return false;
					}
					<player>5__2 = Player.GetAllPlayers().FindPlayer(data.PlayerName, data.UserID);
					if ((Object)(object)<player>5__2 == (Object)null)
					{
						return false;
					}
					<>2__current = ((MonoBehaviour)ovniScanEvent).StartCoroutine(ovniScanEvent.ovni.MoveTowardsFixedTime(((Component)<player>5__2).transform.position));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((MonoBehaviour)ovniScanEvent).StartCoroutine(ovniScanEvent.ScanPlayer(<player>5__2, data.HoverSeconds));
					<>1__state = 2;
					return true;
				case 2:
					<>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 <PlayLoopingMusic>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public OvniScanEvent <>4__this;

			public float volume;

			private AudioClip <MusicClip>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				OvniScanEvent ovniScanEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<MusicClip>5__2 = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>("assets/sounds/ufo_music1.mp3");
					if ((Object)(object)<MusicClip>5__2 == (Object)null)
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] MusicClip no está asignado.");
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					goto IL_007b;
				case 1:
					<>1__state = -1;
					goto IL_007b;
				case 2:
					<>1__state = -1;
					goto IL_00af;
				case 3:
					{
						<>1__state = -1;
						return false;
					}
					IL_00af:
					if (ovniScanEvent.musicSource.isPlaying)
					{
						ovniScanEvent.musicSource.Stop();
					}
					if (!ovniScanEvent.musicSource.isPlaying)
					{
						ovniScanEvent.musicSource.volume = volume;
						ovniScanEvent.musicSource.clip = <MusicClip>5__2;
						ovniScanEvent.musicSource.loop = true;
						ovniScanEvent.musicSource.Play();
						AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] Música reproducida: " + ((Object)<MusicClip>5__2).name));
					}
					else
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] La música ya está sonando, se omite reproducción duplicada.");
					}
					<>2__current = null;
					<>1__state = 3;
					return true;
					IL_007b:
					if ((Object)(object)ovniScanEvent.musicSource == (Object)null)
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] musicSource no está inicializado.");
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					goto IL_00af;
				}
			}

			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 <ScanPlayer>d__14 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player target;

			public OvniScanEvent <>4__this;

			public float hoverSeconds;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				OvniScanEvent ovniScanEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)target == (Object)null)
					{
						ManualLogSource logger = AliensInValheimMod.Logger;
						string playerName = target.GetPlayerName();
						ZDOID zDOID = ((Character)target).GetZDOID();
						logger.LogDebug((object)$"[OvniScanClient] Target no encontrado. {playerName} ({((ZDOID)(ref zDOID)).UserID})");
						return false;
					}
					<>2__current = ((MonoBehaviour)ovniScanEvent).StartCoroutine(ovniScanEvent.EnsureBeam(ovniScanEvent.ovni));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((MonoBehaviour)ovniScanEvent).StartCoroutine(ovniScanEvent.HoverAndScan(ovniScanEvent.ovni, target, hoverSeconds));
					<>1__state = 2;
					return true;
				case 2:
					<>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 <SetBeamIntensity>d__16 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public OvniScanEvent <>4__this;

			public float target;

			public float seconds;

			private float <startI>5__2;

			private bool <turnOn>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 <SetBeamIntensity>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				int num = <>1__state;
				OvniScanEvent ovniScanEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)ovniScanEvent._beam == (Object)null && (Object)(object)ovniScanEvent._beamFx == (Object)null)
					{
						return false;
					}
					<startI>5__2 = (((Object)(object)ovniScanEvent._beam != (Object)null) ? ovniScanEvent._beam.intensity : 0f);
					<turnOn>5__3 = target > <startI>5__2;
					if ((((Object)(object)ovniScanEvent._beamFx != (Object)null) & <turnOn>5__3) && !ovniScanEvent._beamFx.isPlaying)
					{
						ovniScanEvent._beamFx.Play();
					}
					<t>5__4 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<t>5__4 < seconds)
				{
					<t>5__4 += Time.deltaTime;
					float num2 = Mathf.Clamp01(<t>5__4 / seconds);
					float intensity = Mathf.Lerp(<startI>5__2, target, num2);
					if ((Object)(object)ovniScanEvent._beam != (Object)null)
					{
						ovniScanEvent._beam.intensity = intensity;
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if ((Object)(object)ovniScanEvent._beam != (Object)null)
				{
					ovniScanEvent._beam.intensity = target;
				}
				if ((Object)(object)ovniScanEvent._beamFx != (Object)null && !<turnOn>5__3 && ovniScanEvent._beamFx.isPlaying)
				{
					ovniScanEvent._beamFx.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 <StartEvent>d__9 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public OvniScanRPC.ScanOvniData data;

			public OvniScanEvent <>4__this;

			private Player <player>5__2;

			private List<Player> <list>5__3;

			private int <i>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0252: Unknown result type (might be due to invalid IL or missing references)
				//IL_025c: Expected O, but got Unknown
				//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_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0301: Unknown result type (might be due to invalid IL or missing references)
				//IL_030b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0310: Unknown result type (might be due to invalid IL or missing references)
				//IL_0350: Unknown result type (might be due to invalid IL or missing references)
				//IL_035a: Expected O, but got Unknown
				int num = <>1__state;
				OvniScanEvent ovniScanEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>c__DisplayClass9_0 CS$<>8__locals0 = new <>c__DisplayClass9_0();
					AliensInValheimMod.Logger.LogInfo((object)("[OvniScanEvent] Start " + data.PlayerName));
					<player>5__2 = Player.GetAllPlayers().FindPlayer(data.PlayerName, data.UserID);
					if ((Object)(object)<player>5__2 == (Object)null || ((Character)<player>5__2).IsDead())
					{
						AliensInValheimMod.Logger.LogInfo((object)"[OvniScanEvent] Jugador seleccionado inválido o muerto.");
						return false;
					}
					Vector3 position = ((Component)<player>5__2).transform.position + Vector3.up * 30f + ((Component)<player>5__2).transform.right * 80f;
					ovniScanEvent.ovni = AliensInValheimMod.Instance.Library.CreateOvni(position, data.Config);
					CS$<>8__locals0.center = ((Component)<player>5__2).transform.position;
					float num2 = 100f;
					CS$<>8__locals0.sqrRadius = num2 * num2;
					List<Player> allPlayers = Player.GetAllPlayers();
					<list>5__3 = allPlayers.Where((Player p) => (Object)(object)p != (Object)null && !((Character)p).IsDead()).Where(delegate(Player p)
					{
						//IL_0006: 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_0011: Unknown result type (might be due to invalid IL or missing references)
						//IL_0016: Unknown result type (might be due to invalid IL or missing references)
						Vector3 val3 = ((Component)p).transform.position - CS$<>8__locals0.center;
						return ((Vector3)(ref val3)).sqrMagnitude <= CS$<>8__locals0.sqrRadius;
					}).OrderBy(delegate(Player p)
					{
						//IL_0006: 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_0011: Unknown result type (might be due to invalid IL or missing references)
						//IL_0016: Unknown result type (might be due to invalid IL or missing references)
						Vector3 val2 = ((Component)p).transform.position - CS$<>8__locals0.center;
						return ((Vector3)(ref val2)).sqrMagnitude;
					})
						.ToList();
					if (!<list>5__3.Contains(<player>5__2))
					{
						<list>5__3.Insert(0, <player>5__2);
					}
					if (<list>5__3.Count == 0)
					{
						AliensInValheimMod.Logger.LogInfo((object)"[OvniScanEvent] Sin objetivos cercanos.");
						return false;
					}
					<>2__current = ovniScanEvent.HorizontalMovement(<player>5__2, ovniScanEvent.ovni);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					((MonoBehaviour)ovniScanEvent).StartCoroutine(ovniScanEvent.PlayLoopingMusic(0.7f));
					((MonoBehaviour)ovniScanEvent).StartCoroutine(ovniScanEvent.ovni.PlaySound(SoundChannel.ENGINE));
					<>2__current = ovniScanEvent.VerticalDescend(<player>5__2, ovniScanEvent.ovni);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3.05f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<i>5__4 = 0;
					goto IL_037c;
				case 4:
					{
						<>1__state = -1;
						goto IL_036a;
					}
					IL_037c:
					if (<i>5__4 < <list>5__3.Count)
					{
						Player val = <list>5__3[<i>5__4];
						if (!((Object)(object)val == (Object)null) && !((Character)val).IsDead())
						{
							OvniScanRPC instance = OvniScanRPC.Instance;
							OvniScanRPC.ScanOvniData scanOvniData = new OvniScanRPC.ScanOvniData();
							ZDOID zDOID = ((Character)val).GetZDOID();
							scanOvniData.UserID = ((ZDOID)(ref zDOID)).UserID;
							scanOvniData.PlayerName = val.GetPlayerName();
							scanOvniData.HoverSeconds = data.HoverSeconds;
							scanOvniData.Config = data.Config;
							scanOvniData.HoverPos = (((Component)val).transform.position + Vector3.up * 10f).FromUnity();
							scanOvniData.EngineSoundIndex = data.Config.EngineSoundIndex;
							instance.SendCommandToAll(OvniScanRPC.CommandName.SCAN_TARGET, scanOvniData);
							<>2__current = (object)new WaitForSeconds(Mathf.Max(data.HoverSeconds, 0.5f));
							<>1__state = 4;
							return true;
						}
						goto IL_036a;
					}
					OvniScanRPC.Instance.SendCommandToAll(OvniScanRPC.CommandName.END_SCAN, new OvniScanRPC.ScanOvniData
					{
						UserID = data.UserID,
						PlayerName = data.PlayerName
					});
					return false;
					IL_036a:
					<i>5__4++;
					goto IL_037c;
				}
			}

			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 <VerticalDescend>d__7 : 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__7(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 GameObject ovni;

		private AudioSource musicSource;

		private Light _beam;

		private Transform _beamPivot;

		private ParticleSystem _beamFx;

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

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

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

		[IteratorStateMachine(typeof(<PlayLoopingMusic>d__8))]
		public IEnumerator PlayLoopingMusic(float volume = 1f)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayLoopingMusic>d__8(0)
			{
				<>4__this = this,
				volume = volume
			};
		}

		[IteratorStateMachine(typeof(<StartEvent>d__9))]
		internal IEnumerator StartEvent(OvniScanRPC.ScanOvniData data)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartEvent>d__9(0)
			{
				<>4__this = this,
				data = data
			};
		}

		private IEnumerator EnsureBeam(GameObject ufo)
		{
			//IL_004a: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ufo.transform.Find("Beam") ?? ufo.transform.Find("beam") ?? ufo.transform.Find("FX/Beam");
			if ((Object)(object)val == (Object)null)
			{
				Transform transform = new GameObject("BeamPivot").transform;
				transform.SetParent(ufo.transform, false);
				transform.localPosition = Vector3.zero;
				GameObject val2 = new GameObject("BeamLight");
				val2.transform.SetParent(transform, false);
				val2.transform.localPosition = new Vector3(0f, -1.2f, 0f);
				_beam = val2.AddComponent<Light>();
				_beam.type = (LightType)0;
				_beam.range = 80f;
				_beam.spotAngle = 40f;
				_beam.intensity = 0f;
				_beamPivot = transform;
			}
			else
			{
				_beamPivot = val;
				_beam = ((Component)val).GetComponentInChildren<Light>();
				_beamFx = ((Component)val).GetComponentInChildren<ParticleSystem>();
				if ((Object)(object)_beam != (Object)null)
				{
					_beam.type = (LightType)0;
					_beam.range = 80f;
					_beam.spotAngle = 40f;
					_beam.intensity = 0f;
				}
			}
			return null;
		}

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

		[IteratorStateMachine(typeof(<EndScan>d__12))]
		internal IEnumerator EndScan(OvniScanRPC.ScanOvniData data)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EndScan>d__12(0)
			{
				<>4__this = this
			};
		}

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

		[IteratorStateMachine(typeof(<ScanPlayer>d__14))]
		private IEnumerator ScanPlayer(Player target, float hoverSeconds)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ScanPlayer>d__14(0)
			{
				<>4__this = this,
				target = target,
				hoverSeconds = hoverSeconds
			};
		}

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

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

		private Player FindPlayerByUserID(long userId)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if (!((Object)(object)allPlayer == (Object)null))
				{
					ZDOID zDOID = ((Character)allPlayer).GetZDOID();
					if (((ZDOID)(ref zDOID)).UserID == userId)
					{
						return allPlayer;
					}
				}
			}
			return null;
		}

		private Player FindPlayerByName(string name)
		{
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if (!((Object)(object)allPlayer == (Object)null) && string.Equals(allPlayer.GetPlayerName(), name, StringComparison.OrdinalIgnoreCase))
				{
					return allPlayer;
				}
			}
			return null;
		}
	}
	public sealed class OvniScanRPC : CommandRPCBase<OvniScanRPC.CommandName, OvniScanRPC.ScanOvniData>
	{
		public enum CommandName
		{
			START_SCAN,
			SCAN_TARGET,
			END_SCAN
		}

		[Serializable]
		public class ScanOvniData
		{
			public long UserID;

			public string PlayerName;

			public OvniConfiguration Config = new OvniConfiguration();

			public float HoverSeconds = 5f;

			public Vec3 StartPos = new Vec3();

			public Vec3 HoverPos = new Vec3();

			public int EngineSoundIndex;
		}

		private static OvniScanRPC _singleton = null;

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

		protected override string RPCName => "AliensInValheim_RPC_ScanOvni";
	}
}
namespace AliensInValheim.Intro
{
	internal class IntroductionSceneCommand : ConsoleCommand
	{
		public override string Name => "showalienintro";

		public override string Help => "Invoca la escena de introducción para todos los jugadores.";

		public override void Run(string[] args)
		{
			try
			{
				IntroductionSceneRPC.Instance.SendCommandToAll(IntroductionSceneRPC.CommandName.START, new IntroductionData());
				AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] \ud83c\udfac Escena de introducción iniciada.");
			}
			catch (Exception ex)
			{
				AliensInValheimMod.Logger.LogError((object)("[AliensInValheim] ❌ Error ejecutando showintro: " + ex.Message + "\n" + ex.StackTrace));
			}
		}
	}
	internal class IntroductionData
	{
	}
	internal class IntroductionSceneRPC : CommandRPCBase<IntroductionSceneRPC.CommandName, IntroductionData>
	{
		public enum CommandName
		{
			START,
			END
		}

		private static IntroductionSceneRPC _singleton = null;

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

		protected override string RPCName => "AliensInValheim_RPC_TriggerIntroScene";
	}
	internal class IntroductionSceneEvent : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <FadeIn>d__13 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public IntroductionSceneEvent <>4__this;

			private float <duration>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 <FadeIn>d__13(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				int num = <>1__state;
				IntroductionSceneEvent introductionSceneEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<duration>5__2 = 1.5f;
					<t>5__3 = 0f;
					break;
				case 2:
					<>1__state = -1;
					<t>5__3 += Time.deltaTime;
					break;
				}
				if (<t>5__3 < <duration>5__2)
				{
					introductionSceneEvent.SetAlpha(Mathf.Lerp(0f, 1f, <t>5__3 / <duration>5__2));
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				introductionSceneEvent.SetAlpha(1f);
				return false;
			}

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

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

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

			private object <>2__current;

			public IntroductionSceneEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Expected O, but got Unknown
				int num = <>1__state;
				IntroductionSceneEvent introductionSceneEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] Iniciando Introduccion...");
					if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)Hud.instance == (Object)null || GUIManager.Instance == null)
					{
						<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)Hud.instance != (Object)null && GUIManager.Instance != null));
						<>1__state = 1;
						return true;
					}
					goto IL_0093;
				case 1:
					<>1__state = -1;
					goto IL_0093;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_0093:
					introductionSceneEvent.TryLoadAssets();
					introductionSceneEvent.Inicialize();
					introductionSceneEvent.ConfigureText();
					introductionSceneEvent.ConfigureAudio();
					if (!introductionSceneEvent.duckStarted)
					{
						introductionSceneEvent.duckStarted = true;
						((MonoBehaviour)introductionSceneEvent).StartCoroutine(MusicDucker.Duck(introductionSceneEvent.audioSource));
					}
					if ((Object)(object)introductionSceneEvent.introText != (Object)null)
					{
						introductionSceneEvent.SetAlpha(0f);
						((MonoBehaviour)introductionSceneEvent).StartCoroutine(introductionSceneEvent.FadeIn());
					}
					<>2__current = null;
					<>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();
			}
		}

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

			private object <>2__current;

			public IntroductionSceneEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				IntroductionSceneEvent introductionSceneEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((MonoBehaviour)introductionSceneEvent).StartCoroutine(MusicDucker.Unduck());
					if ((Object)(object)introductionSceneEvent.audioSource != (Object)null)
					{
						introductionSceneEvent.audioSource.Stop();
					}
					if ((Object)(object)introductionSceneEvent.canvasRoot != (Object)null)
					{
						Object.Destroy((Object)(object)introductionSceneEvent.canvasRoot);
						introductionSceneEvent.canvasRoot = null;
					}
					introductionSceneEvent.panelRoot = null;
					introductionSceneEvent.scrollRect = null;
					introductionSceneEvent.closeButton = null;
					introductionSceneEvent.introText = null;
					<>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();
			}
		}

		private GameObject canvasRoot;

		private GameObject panelRoot;

		private ScrollRect scrollRect;

		private Button closeButton;

		private Text introText;

		private AudioClip introMusic;

		private AudioSource audioSource;

		private bool duckStarted;

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

		private void TryLoadAssets()
		{
			introMusic = AliensInValheimMod.Instance.Library.LoadAsset<AudioClip>("assets/sounds/ufo_music1.mp3");
		}

		private void Inicialize()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_009c: 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_00e1: 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_0114: 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_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Expected O, but got Unknown
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Expected O, but got Unknown
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Expected O, but got Unknown
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Expected O, but got Unknown
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0521: Expected O, but got Unknown
			//IL_054a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0603: Unknown result type (might be due to invalid IL or missing references)
			//IL_0612: Unknown result type (might be due to invalid IL or missing references)
			//IL_0621: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_0638: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)canvasRoot != (Object)null)
			{
				return;
			}
			if (GUIManager.Instance == null)
			{
				AliensInValheimMod.Logger.LogWarning((object)"[Intro] GUIManager.Instance es null. Abortando intro.");
				return;
			}
			canvasRoot = new GameObject("AliensInValheim_IntroCanvas", new Type[3]
			{
				typeof(Canvas),
				typeof(CanvasScaler),
				typeof(GraphicRaycaster)
			});
			Canvas component = canvasRoot.GetComponent<Canvas>();
			component.renderMode = (RenderMode)0;
			component.sortingOrder = 9000;
			CanvasScaler component2 = canvasRoot.GetComponent<CanvasScaler>();
			component2.uiScaleMode = (ScaleMode)1;
			component2.referenceResolution = new Vector2(1920f, 1080f);
			component2.screenMatchMode = (ScreenMatchMode)0;
			component2.matchWidthOrHeight = 1f;
			panelRoot = GUIManager.Instance.CreateWoodpanel(canvasRoot.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, 900f, 600f);
			panelRoot.GetComponent<RectTransform>().pivot = new Vector2(0.5f, 0.5f);
			GameObject val = GUIManager.Instance.CreateButton(Loc.T("aliens_close"), panelRoot.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 20f), 140f, 36f);
			closeButton = val.GetComponent<Button>();
			((UnityEvent)closeButton.onClick).AddListener((UnityAction)delegate
			{
				((MonoBehaviour)this).StartCoroutine(StopEvent());
			});
			GameObject val2 = new GameObject("IntroScroll", new Type[2]
			{
				typeof(RectTransform),
				typeof(ScrollRect)
			});
			val2.transform.SetParent(panelRoot.transform, false);
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0.5f, 0.5f);
			component3.anchorMax = new Vector2(0.5f, 0.5f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.sizeDelta = new Vector2(820f, 480f);
			component3.anchoredPosition = new Vector2(0f, 40f);
			GameObject val3 = new GameObject("Viewport", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Mask)
			});
			val3.transform.SetParent(val2.transform, false);
			RectTransform component4 = val3.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 0f);
			component4.anchorMax = new Vector2(1f, 1f);
			component4.offsetMin = Vector2.zero;
			component4.offsetMax = Vector2.zero;
			((Graphic)val3.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.2f);
			val3.GetComponent<Mask>().showMaskGraphic = false;
			GameObject val4 = new GameObject("Content", new Type[2]
			{
				typeof(RectTransform),
				typeof(ContentSizeFitter)
			});
			val4.transform.SetParent(val3.transform, false);
			RectTransform component5 = val4.GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(0f, 1f);
			component5.anchorMax = new Vector2(1f, 1f);
			component5.pivot = new Vector2(0.5f, 1f);
			component5.anchoredPosition = Vector2.zero;
			component5.sizeDelta = new Vector2(0f, 0f);
			val4.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			scrollRect = val2.GetComponent<ScrollRect>();
			scrollRect.viewport = component4;
			scrollRect.content = component5;
			scrollRect.horizontal = false;
			scrollRect.vertical = true;
			scrollRect.movementType = (MovementType)2;
			GameObject val5 = new GameObject("Scrollbar", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Scrollbar)
			});
			val5.transform.SetParent(panelRoot.transform, false);
			RectTransform component6 = val5.GetComponent<RectTransform>();
			component6.anchorMin = new Vector2(1f, 0.5f);
			component6.anchorMax = new Vector2(1f, 0.5f);
			component6.pivot = new Vector2(1f, 0.5f);
			component6.sizeDelta = new Vector2(18f, 480f);
			component6.anchoredPosition = new Vector2(-30f, 40f);
			((Graphic)val5.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.35f);
			GameObject val6 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val6.transform.SetParent(val5.transform, false);
			RectTransform component7 = val6.GetComponent<RectTransform>();
			component7.anchorMin = new Vector2(0f, 0f);
			component7.anchorMax = new Vector2(1f, 1f);
			component7.offsetMin = Vector2.zero;
			component7.offsetMax = Vector2.zero;
			((Graphic)val6.GetComponent<Image>()).color = new Color(1f, 1f, 1f, 0.8f);
			Scrollbar component8 = val5.GetComponent<Scrollbar>();
			component8.direction = (Direction)2;
			component8.handleRect = component7;
			((Selectable)component8).targetGraphic = (Graphic)(object)val6.GetComponent<Image>();
			scrollRect.verticalScrollbar = component8;
			scrollRect.verticalScrollbarVisibility = (ScrollbarVisibility)2;
			GameObject val7 = GUIManager.Instance.CreateText(string.Empty, val4.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, 0f), GUIManager.Instance.AveriaSerif, 18, Color.yellow, true, Color.black, 780f, 10f, false);
			introText = val7.GetComponent<Text>();
			introText.alignment = (TextAnchor)1;
			introText.horizontalOverflow = (HorizontalWrapMode)0;
			introText.verticalOverflow = (VerticalWrapMode)1;
			((Graphic)introText).raycastTarget = false;
		}

		private void ConfigureText()
		{
			if (!((Object)(object)introText == (Object)null))
			{
				introText.text = Loc.T("aliens_intro");
			}
		}

		private void ConfigureAudio()
		{
			if ((Object)(object)introMusic == (Object)null)
			{
				AliensInValheimMod.Logger.LogWarning((object)"[Intro] No se pudo cargar la música de intro.");
				return;
			}
			audioSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			audioSource.AttachToGameMixer(SoundGroup.Music);
			audioSource.clip = introMusic;
			audioSource.playOnAwake = false;
			audioSource.loop = false;
			audioSource.ignoreListenerVolume = true;
			audioSource.volume = 1f;
			audioSource.Play();
		}

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

		private void SetAlpha(float a)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)introText == (Object)null))
			{
				Color color = ((Graphic)introText).color;
				color.a = a;
				((Graphic)introText).color = color;
			}
		}

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

		[IteratorStateMachine(typeof(<StartEvent>d__16))]
		internal IEnumerator StartEvent()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartEvent>d__16(0)
			{
				<>4__this = this
			};
		}
	}
}
namespace AliensInValheim.CreatureAbduction
{
	public class CreatureAbductionCommand : ConsoleCommand
	{
		public override string Name => "abducircriatura";

		public override string Help => "Hace que un OVNI intente abducir una criatura cercana al jugador indicado (o al jugador local).";

		public override void Run(string[] args)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Player val = Player.m_localPlayer;
				if (args.Length == 1)
				{
					Player val2 = ((IEnumerable<Player>)Player.GetAllPlayers()).FirstOrDefault((Func<Player, bool>)((Player p) => p.GetPlayerName().Equals(args[0], StringComparison.OrdinalIgnoreCase)));
					if ((Object)(object)val2 != (Object)null)
					{
						val = val2;
					}
					else
					{
						AliensInValheimMod.Logger.LogWarning((object)("[AliensInValheim] Jugador '" + args[0] + "' no encontrado. Se usará el jugador local."));
					}
				}
				if ((Object)(object)val == (Object)null || ((Character)val).IsDead())
				{
					AliensInValheimMod.Logger.LogWarning((object)"[AliensInValheim] ⚠\ufe0f El jugador no es válido o está muerto.");
					return;
				}
				CreatureAbductionRPC instance = CreatureAbductionRPC.Instance;
				AbductionCreatureData abductionCreatureData = new AbductionCreatureData();
				ZDOID zDOID = ((Character)val).GetZDOID();
				abductionCreatureData.UserID = ((ZDOID)(ref zDOID)).UserID;
				instance.SendCommandToAll(CreatureAbductionRPC.CommandName.START_CREATURE_ABDUCTION, abductionCreatureData);
				AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] \ud83d\udef8 Evento de abducción iniciado para el jugador '" + val.GetPlayerName() + "'."));
			}
			catch (Exception ex)
			{
				AliensInValheimMod.Logger.LogError((object)("[AliensInValheim] ❌ Error ejecutando abducircriatura: " + ex.Message + "\n" + ex.StackTrace));
			}
		}
	}
	public class CreatureAbductionEvent : MonoBehaviour
	{
		private sealed class TemporaryParalysis : IDisposable
		{
			[CompilerGenerated]
			private sealed class <Shake>d__7 : IEnumerator<object>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private object <>2__current;

				public Transform t;

				public float amp;

				private float <timer>5__2;

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

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

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

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

				private bool MoveNext()
				{
					//IL_002b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0030: Unknown result type (might be due to invalid IL or missing references)
					//IL_003b: 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)
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<timer>5__2 = 0f;
						break;
					case 1:
						<>1__state = -1;
						break;
					}
					if (<timer>5__2 < 2f && (Object)(object)t != (Object)null)
					{
						Transform obj = t;
						obj.position += Random.insideUnitSphere * amp * Time.deltaTime;
						<timer>5__2 += Time.deltaTime;
						<>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();
				}
			}

			private readonly Character _c;

			private readonly BaseAI _ai;

			private readonly Rigidbody _rb;

			private readonly float _originalDrag;

			private readonly float _shakeAmp;

			public TemporaryParalysis(Character c, float shakeAmplitude)
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				_c = c;
				_ai = (Object.op_Implicit((Object)(object)c) ? ((Component)c).GetComponent<BaseAI>() : null);
				_rb = (Object.op_Implicit((Object)(object)c) ? ((Component)c).GetComponent<Rigidbody>() : null);
				_shakeAmp = shakeAmplitude;
				if (Object.op_Implicit((Object)(object)_ai))
				{
					((Behaviour)_ai).enabled = false;
				}
				if (Object.op_Implicit((Object)(object)_rb))
				{
					_originalDrag = _rb.drag;
					_rb.useGravity = false;
					_rb.drag = 10f;
					_rb.velocity = Vector3.zero;
				}
				if (Object.op_Implicit((Object)(object)c))
				{
					((MonoBehaviour)c).StartCoroutine(Shake(((Component)c).transform, _shakeAmp));
				}
			}

			public void Dispose()
			{
				if (Object.op_Implicit((Object)(object)_ai))
				{
					((Behaviour)_ai).enabled = true;
				}
				if (Object.op_Implicit((Object)(object)_rb))
				{
					_rb.useGravity = true;
					_rb.drag = _originalDrag;
				}
			}

			[IteratorStateMachine(typeof(<Shake>d__7))]
			private static IEnumerator Shake(Transform t, float amp)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Shake>d__7(0)
				{
					t = t,
					amp = amp
				};
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <>c__DisplayClass26_0
		{
			public Transform ufoTf;

			public CreatureAbductionEvent <>4__this;
		}

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

			private object <>2__current;

			public Player player;

			public CreatureAbductionEvent <>4__this;

			private Character <target>5__2;

			private Vector3 <targetPos>5__3;

			private TemporaryParalysis <>7__wrap3;

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

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

			[DebuggerHidden]
			public <StartForPlayer>d__22(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();
					}
				}
				<target>5__2 = null;
				<>7__wrap3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0213: Unknown result type (might be due to invalid IL or missing references)
				//IL_023a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0287: Unknown result type (might be due to invalid IL or missing references)
				//IL_0297: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b2: Expected O, but got Unknown
				//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_034f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0354: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_016d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0175: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					int num = <>1__state;
					CreatureAbductionEvent creatureAbductionEvent = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						if ((Object)(object)player == (Object)null || ((Character)player).IsDead())
						{
							AliensInValheimMod.Logger.LogDebug((object)"[CreatureAbduction] Anchor inválido.");
							return false;
						}
						AliensInValheimMod.Logger.LogDebug((object)("[CreatureAbduction] StartForPlayer " + player.GetPlayerName()));
						<target>5__2 = creatureAbductionEvent.FindClosestCreatureNear(player, creatureAbductionEvent.searchRadiusFromPlayer);
						if ((Object)(object)<target>5__2 == (Object)null)
						{
							AliensInValheimMod.Logger.LogDebug((object)"[CreatureAbduction] Sin criaturas cerca para abducir.");
							return false;
						}
						OvniConfiguration random = Configurations.GetRandom();
						creatureAbductionEvent.ufo = AliensInValheimMod.Instance.Library.CreateOvni(((Component)player).transform.position + Vector3.up * 30f, random);
						if ((Object)(object)creatureAbductionEvent.ufo == (Object)null)
						{
							AliensInValheimMod.Logger.LogError((object)"[CreatureAbduction] No se pudo crear OVNI.");
							return false;
						}
						creatureAbductionEvent.ufo.PlaySounds();
						<targetPos>5__3 = ((Component)<target>5__2).transform.position;
						Vector3 insideUnitSphere = Random.insideUnitSphere;
						insideUnitSphere.y = 0f;
						((Vector3)(ref insideUnitSphere)).Normalize();
						Vector3 position = <targetPos>5__3 + insideUnitSphere * creatureAbductionEvent.farSpawnDistance + Vector3.up * creatureAbductionEvent.farSpawnHeight;
						creatureAbductionEvent.ufo.transform.position = position;
						<>2__current = creatureAbductionEvent.ufo.MoveTowards(new Vector3(<targetPos>5__3.x, creatureAbductionEvent.ufo.transform.position.y, <targetPos>5__3.z), creatureAbductionEvent.approachSpeed);
						<>1__state = 1;
						return true;
					}
					case 1:
					{
						<>1__state = -1;
						Vector3 dest = default(Vector3);
						((Vector3)(ref dest))..ctor(<targetPos>5__3.x, creatureAbductionEvent.GetSafeHoverHeight(<targetPos>5__3, creatureAbductionEvent.descendHeightAboveTarget), <targetPos>5__3.z);
						<>2__current = creatureAbductionEvent.ufo.MoveTowards(dest, creatureAbductionEvent.descendSpeed);
						<>1__state = 2;
						return true;
					}
					case 2:
						<>1__state = -1;
						<>7__wrap3 = new TemporaryParalysis(<target>5__2, creatureAbductionEvent.stunShakeAmplitude);
						<>1__state = -3;
						creatureAbductionEvent.PlayParalyzer(<target>5__2.GetZDOID(), creatureAbductionEvent.ufo.transform.position);
						<>2__current = (object)new WaitForSeconds(creatureAbductionEvent.paralysisSeconds);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -3;
						<>m__Finally1();
						<>7__wrap3 = null;
						creatureAbductionEvent.BeginTractor(creatureAbductionEvent.ufo.transform.position, <target>5__2.GetZDOID());
						<>2__current = creatureAbductionEvent.TractorPull(<target>5__2, creatureAbductionEvent.ufo.transform, creatureAbductionEvent.tractorDuration);
						<>1__state = 4;
						return true;
					case 4:
					{
						<>1__state = -1;
						creatureAbductionEvent.FinishTarget(<target>5__2);
						creatureAbductionEvent.EndTractor();
						CreatureAbductionRPC instance = CreatureAbductionRPC.Instance;
						AbductionCreatureData abductionCreatureData = new AbductionCreatureData();
						ZDOID zDOID = <target>5__2.GetZDOID();
						abductionCreatureData.UserID = ((ZDOID)(ref zDOID)).UserID;
						instance.SendCommandToAll(CreatureAbductionRPC.CommandName.FINISH_CREATURE_ABDUCTION, abductionCreatureData);
						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;
				if (<>7__wrap3 != null)
				{
					((IDisposable)<>7__wrap3).Dispose();
				}
			}

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

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

			private object <>2__current;

			public CreatureAbductionEvent <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				CreatureAbductionEvent creatureAbductionEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((MonoBehaviour)creatureAbductionEvent).StartCoroutine(creatureAbductionEvent.ufo.FadeOutAudio(5f));
					<>2__current = creatureAbductionEvent.ufo.FadeAndWarpAway(7f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)creatureAbductionEvent.ufo != (Object)null)
					{
						Object.Destroy((Object)(object)creatureAbductionEvent.ufo);
						creatureAbductionEvent.ufo = null;
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>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 <TractorPull>d__26 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Transform ufoTf;

			public CreatureAbductionEvent <>4__this;

			public Character target;

			public float duration;

			private <>c__DisplayClass26_0 <>8__1;

			private float <t>5__2;

			private Rigidbody <rb>5__3;

			private Vector3 <startPos>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = default(<>c__DisplayClass26_0);
				<rb>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0269: Unknown result type (might be due to invalid IL or missing references)
				//IL_0273: Expected O, but got Unknown
				//IL_023b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: 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_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0259: Unknown result type (might be due to invalid IL or missing references)
				//IL_019f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				CreatureAbductionEvent creatureAbductionEvent = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1.ufoTf = ufoTf;
					<>8__1.<>4__this = <>4__this;
					if (!((Object)(object)target == (Object)null) && !target.IsDead())
					{
						ZNetView component = ((Component)target).GetComponent<ZNetView>();
						if (component == null || component.IsValid())
						{
							<t>5__2 = 0f;
							<rb>5__3 = ((Component)target).GetComponent<Rigidbody>();
							<startPos>5__4 = ((Component)target).transform.position;
							if ((Object)(object)<rb>5__3 != (Object)null)
							{
								<rb>5__3.useGravity = false;
								<rb>5__3.velocity = Vector3.zero;
								<rb>5__3.angularVelocity = Vector3.zero;
							}
							goto IL_01e2;
						}
					}
					return false;
				case 1:
					<>1__state = -1;
					goto IL_01e2;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_01e2:
					if (<t>5__2 < duration && (Object)(object)target != (Object)null && !target.IsDead())
					{
						float num2 = <t>5__2 / duration;
						float num3 = Mathf.Clamp01(creatureAbductionEvent.tractorPullCurve.Evaluate(num2));
						Vector3 val = Vector3.ClampMagnitude(Vector3.Lerp(<startPos>5__4, creatureAbductionEvent.<TractorPull>g__tractorMouth|26_0(ref <>8__1), num3) - ((Component)target).transform.position, creatureAbductionEvent.maxPullSpeed * Time.deltaTime);
						Transform transform = ((Component)target).transform;
						transform.position += val;
						if ((Object)(object)<rb>5__3 != (Object)null)
						{
							<rb>5__3.velocity = Vector3.zero;
						}
						creatureAbductionEvent.UpdateTractorLine(<>8__1.ufoTf.position, ((Component)target).transform.position);
						<t>5__2 += Time.deltaTime;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)target != (Object)null && !target.IsDead())
					{
						((Component)target).transform.position = creatureAbductionEvent.<TractorPull>g__tractorMouth|26_0(ref <>8__1);
						if ((Object)(object)<rb>5__3 != (Object)null)
						{
							<rb>5__3.velocity = Vector3.zero;
						}
					}
					<>2__current = (object)new WaitForSeconds(0.15f);
					<>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();
			}
		}

		private float searchRadiusFromPlayer = 100f;

		private float farSpawnDistance = 80f;

		private float farSpawnHeight = 60f;

		private float descendHeightAboveTarget = 16f;

		private float approachSpeed = 25f;

		private float descendSpeed = 8f;

		private float paralysisSeconds = 2.25f;

		private float stunShakeAmplitude = 0.25f;

		private float tractorDuration = 4f;

		private AnimationCurve tractorPullCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);

		private float tractorVerticalOffset = 2f;

		private float maxPullSpeed = 15f;

		private bool killTarget;

		private bool dropLootOnKill = true;

		private GameObject paralyzerVfxPrefab;

		private Material tractorLineMaterial;

		private float tractorLineWidth = 0.25f;

		private AudioClip sfxParalyzer;

		private AudioClip sfxTractor;

		private AudioSource sfxSource;

		private GameObject ufo;

		private LineRenderer tractorLine;

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

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

		private Character FindClosestCreatureNear(Player p, float radius)
		{
			//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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)p).transform.position;
			Character result = null;
			float num = float.MaxValue;
			foreach (Character allCharacter in Character.GetAllCharacters())
			{
				if ((Object)(object)allCharacter == (Object)null || allCharacter.IsPlayer())
				{
					continue;
				}
				ZNetView component = ((Component)allCharacter).GetComponent<ZNetView>();
				if (Object.op_Implicit((Object)(object)component) && component.IsValid() && !allCharacter.IsTamed() && !allCharacter.IsDead())
				{
					Vector3 val = ((Component)allCharacter).transform.position - position;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (sqrMagnitude < num && sqrMagnitude <= radius * radius)
					{
						result = allCharacter;
						num = sqrMagnitude;
					}
				}
			}
			return result;
		}

		private float GetSafeHoverHeight(Vector3 groundPos, float offset)
		{
			//IL_0019: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			return Mathf.Max((Object.op_Implicit((Object)(object)ZoneSystem.instance) ? ZoneSystem.instance.GetGroundHeight(groundPos) : groundPos.y) + offset, groundPos.y + offset);
		}

		[IteratorStateMachine(typeof(<TractorPull>d__26))]
		private IEnumerator TractorPull(Character target, Transform ufoTf, float duration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TractorPull>d__26(0)
			{
				<>4__this = this,
				target = target,
				ufoTf = ufoTf,
				duration = duration
			};
		}

		private void FinishTarget(Character target)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null || !Object.op_Implicit((Object)(object)((Component)target).GetComponent<ZNetView>()) || !((Component)target).GetComponent<ZNetView>().IsValid())
			{
				return;
			}
			if (killTarget && !target.IsDead())
			{
				HitData val = new HitData();
				val.m_damage.m_damage = 99999f;
				val.m_point = ((Component)target).transform.position + Vector3.up * 0.5f;
				target.Damage(val);
				if (!dropLootOnKill)
				{
					CharacterDrop component = ((Component)target).GetComponent<CharacterDrop>();
					if ((Object)(object)component != (Object)null && component.m_drops != null)
					{
						component.m_drops.Clear();
					}
				}
			}
			else
			{
				ZNetScene.instance.Destroy(((Component)target).gameObject);
			}
		}

		private void PlayParalyzer(ZDOID targetId, Vector3 ufoPos)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)sfxSource) && Object.op_Implicit((Object)(object)sfxParalyzer))
			{
				sfxSource.PlayOneShot(sfxParalyzer);
			}
			if (Object.op_Implicit((Object)(object)paralyzerVfxPrefab))
			{
				GameObject val = ZNetScene.instance.FindInstance(targetId);
				if (Object.op_Implicit((Object)(object)val))
				{
					Object.Destroy((Object)(object)Object.Instantiate<GameObject>(paralyzerVfxPrefab, val.transform.position + Vector3.up * 1f, Quaternion.identity), 2.5f);
				}
			}
		}

		private void BeginTractor(Vector3 ufoPos, ZDOID targetId)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)sfxSource) && Object.op_Implicit((Object)(object)sfxTractor))
			{
				sfxSource.PlayOneShot(sfxTractor);
			}
			EnsureTractorLine();
			GameObject val = ZNetScene.instance.FindInstance(targetId);
			if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)tractorLine))
			{
				((Renderer)tractorLine).enabled = true;
				tractorLine.positionCount = 2;
				tractorLine.SetPosition(0, ufoPos);
				tractorLine.SetPosition(1, val.transform.position);
			}
		}

		private void UpdateTractorLine(Vector3 ufoPos, Vector3 targetPos)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)tractorLine) && ((Renderer)tractorLine).enabled)
			{
				tractorLine.SetPosition(0, ufoPos);
				tractorLine.SetPosition(1, targetPos);
			}
		}

		private void EndTractor()
		{
			if (Object.op_Implicit((Object)(object)tractorLine))
			{
				((Renderer)tractorLine).enabled = false;
			}
		}

		private void EnsureTractorLine()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)tractorLine))
			{
				GameObject val = new GameObject("UFO_TractorLine");
				val.transform.SetParent(((Component)this).transform, false);
				tractorLine = val.AddComponent<LineRenderer>();
				tractorLine.useWorldSpace = true;
				((Renderer)tractorLine).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)tractorLine).receiveShadows = false;
				tractorLine.textureMode = (LineTextureMode)0;
				tractorLine.widthMultiplier = tractorLineWidth;
				((Renderer)tractorLine).material = (Material)(Object.op_Implicit((Object)(object)tractorLineMaterial) ? ((object)tractorLineMaterial) : ((object)new Material(Shader.Find("Sprites/Default"))));
			}
		}

		[CompilerGenerated]
		private Vector3 <TractorPull>g__tractorMouth|26_0(ref <>c__DisplayClass26_0 P_0)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			return P_0.ufoTf.position + -P_0.ufoTf.up * tractorVerticalOffset;
		}
	}
	internal class AbductionCreatureData
	{
		public long UserID { get; set; }
	}
	internal class CreatureAbductionRPC : CommandRPCBase<CreatureAbductionRPC.CommandName, AbductionCreatureData>
	{
		public enum CommandName
		{
			START_CREATURE_ABDUCTION,
			FINISH_CREATURE_ABDUCTION
		}

		private static CreatureAbductionRPC _singleton = null;

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

		protected override string RPCName => "AliensInValheim_RPC_TriggerCreatureAbduction";
	}
}
namespace AliensInValheim.Audio
{
	internal static class MusicDucker
	{
		[CompilerGenerated]
		private sealed class <Duck>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AudioSource excludeSource;

			public float fadeTime;

			public float targetVol;

			private float <t>5__2;

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

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

			[DebuggerHidden]
			public <Duck>d__5(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 (_isDucked)
					{
						return false;
					}
					_isDucked = true;
					_excludedSource = excludeSource;
					_origVols.Clear();
					foreach (AudioSource item in (from a in Object.FindObjectsOfType<AudioSource>()
						where (Object)(object)a != (Object)null && ((Component)a).gameObject.activeInHierarchy
						where (Object)(object)_excludedSource == (Object)null || (Object)(object)a != (Object)(object)_excludedSource
						select a).ToList())
					{
						if (!_origVols.ContainsKey(item))
						{
							_origVols[item] = item.volume;
						}
					}
					<t>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<t>5__2 < fadeTime)
				{
					<t>5__2 += Time.unscaledDeltaTime;
					float num = Mathf.Clamp01(<t>5__2 / fadeTime);
					foreach (KeyValuePair<AudioSource, float> origVol in _origVols)
					{
						if (Object.op_Implicit((Object)(object)origVol.Key))
						{
							origVol.Key.volume = Mathf.Lerp(origVol.Value, targetVol, 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 <Unduck>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public float fadeTime;

			private List<KeyValuePair<AudioSource, float>> <targets>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 <Unduck>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!_isDucked)
					{
						return false;
					}
					_isDucked = false;
					<targets>5__2 = _origVols.Where((KeyValuePair<AudioSource, float> kv) => (Object)(object)kv.Key != (Object)null).ToList();
					<t>5__3 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<t>5__3 < fadeTime)
				{
					<t>5__3 += Time.unscaledDeltaTime;
					float num = Mathf.Clamp01(<t>5__3 / fadeTime);
					foreach (KeyValuePair<AudioSource, float> item in <targets>5__2)
					{
						if (Object.op_Implicit((Object)(object)item.Key))
						{
							item.Key.volume = Mathf.Lerp(item.Key.volume, item.Value, num);
						}
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				_origVols.Clear();
				_excludedSource = 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();
			}
		}

		private static bool _isDucked;

		private static readonly Dictionary<AudioSource, float> _origVols = new Dictionary<AudioSource, float>();

		private static AudioSource _excludedSource;

		public static void Init()
		{
			_isDucked = false;
			_origVols.Clear();
			_excludedSource = null;
		}

		public static IEnumerator Duck(float targetVol = 0f, float fadeTime = 0.5f)
		{
			return Duck(null, targetVol, fadeTime);
		}

		[IteratorStateMachine(typeof(<Duck>d__5))]
		public static IEnumerator Duck(AudioSource excludeSource, float targetVol = 0f, float fadeTime = 0.5f)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Duck>d__5(0)
			{
				excludeSource = excludeSource,
				targetVol = targetVol,
				fadeTime = fadeTime
			};
		}

		[IteratorStateMachine(typeof(<Unduck>d__6))]
		public static IEnumerator Unduck(float fadeTime = 0.5f)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Unduck>d__6(0)
			{
				fadeTime = fadeTime
			};
		}
	}
}
namespace AliensInValheim.AlienUIModal
{
	public class AlienHudUI : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <WaitAndBuild>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AlienHudUI <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				AlienHudUI alienHudUI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0042;
				case 1:
					<>1__state = -1;
					goto IL_0042;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0042:
					if (GUIManager.Instance == null)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					break;
				}
				if ((Object)(object)Hud.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				AssetBundle library = AliensInValheimMod.Instance.Library;
				if ((Object)(object)library != (Object)null)
				{
					alienHudUI._alienIcon = library.LoadAsset<Sprite>("assets/sprites/alien.png") ?? alienHudUI.TexToSprite(library.LoadAsset<Texture2D>("assets/sprites/alien.png"));
				}
				alienHudUI.BuildUI();
				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 AlienIconSpriteName = "assets/sprites/alien.png";

		private GameObject _canvasRoot;

		private GameObject _panel;

		private Button _closeBtn;

		private Text _title;

		private Sprite _alienIcon;

		private void Awake()
		{
			((MonoBehaviour)this).StartCoroutine(WaitAndBuild());
		}

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

		private void BuildUI()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_canvasRoot != (Object)null))
			{
				_canvasRoot = new GameObject("AliensInValheim_Canvas", new Type[3]
				{
					typeof(Canvas),
					typeof(CanvasScaler),
					typeof(GraphicRaycaster)
				});
				Canvas component = _canvasRoot.GetComponent<Canvas>();
				component.renderMode = (RenderMode)0;
				component.sortingOrder = 9000;
				CanvasScaler component2 = _canvasRoot.GetComponent<CanvasScaler>();
				component2.uiScaleMode = (ScaleMode)1;
				component2.referenceResolution = new Vector2(1920f, 1080f);
				component2.screenMatchMode = (ScreenMatchMode)0;
				component2.matchWidthOrHeight = 1f;
				_panel = CreateWoodPanel(_canvasRoot.transform);
				_panel.SetActive(true);
			}
		}

		private Sprite TexToSprite(Texture2D tex)
		{
			//IL_002b: 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)
			if ((Object)(object)tex == (Object)null)
			{
				return null;
			}
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(0f, 0f, (float)((Texture)tex).width, (float)((Texture)tex).height);
			return Sprite.Create(tex, val, new Vector2(0.5f, 0.5f), 100f);
		}

		private GameObject CreateWoodPanel(Transform parent)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Expected O, but got Unknown
			GameObject panel = GUIManager.Instance.CreateWoodpanel(parent, new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(-20f, 20f), 400f, 250f);
			((Object)panel).name = "Aliens_WoodPanel";
			panel.GetComponent<RectTransform>().pivot = new Vector2(1f, 0f);
			GameObject val = GUIManager.Instance.CreateButton("", panel.transform, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(16f, -16f), 32f, 32f);
			Button component = val.GetComponent<Button>();
			Image component2 = val.GetComponent<Image>();
			if ((Object)(object)_alienIcon != (Object)null)
			{
				component2.sprite = _alienIcon;
				component2.type = (Type)0;
			}
			else
			{
				Text componentInChildren = val.GetComponentInChildren<Text>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.text = "\ud83d\udc7d";
				}
			}
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				panel.SetActive(false);
			});
			GameObject val2 = GUIManager.Instance.CreateText("AliensInValheim", panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -40f), GUIManager.Instance.AveriaSerif, 28, Color.white, true, Color.black, 300f, 40f, false);
			_title = val2.GetComponent<Text>();
			_title.alignment = (TextAnchor)4;
			Text component3 = GUIManager.Instance.CreateText(Loc.T("aliens_message"), panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, -10f), GUIManager.Instance.AveriaSerif, 22, Color.white, true, Color.black, 340f, 80f, false).GetComponent<Text>();
			component3.alignment = (TextAnchor)4;
			component3.horizontalOverflow = (HorizontalWrapMode)0;
			component3.verticalOverflow = (VerticalWrapMode)1;
			((Graphic)component3).raycastTarget = false;
			GameObject val3 = GUIManager.Instance.CreateButton("Cerrar", panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 20f), 140f, 36f);
			_closeBtn = val3.GetComponent<Button>();
			((UnityEvent)_closeBtn.onClick).AddListener((UnityAction)delegate
			{
				panel.SetActive(false);
			});
			return panel;
		}

		private void Update()
		{
			if (!((Object)(object)_panel == (Object)null) && ZInput.instance != null && ZInput.GetKeyDown((KeyCode)288, true))
			{
				_panel.SetActive(!_panel.activeSelf);
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_canvasRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasRoot);
			}
		}
	}
}
namespace AliensInValheim.Core
{
	internal class EventManager : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass14_0
		{
			public IntroductionSceneRPC.CommandName command;

			public EventManager <>4__this;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass19_0
		{
			public OvniScanRPC.CommandName command;

			public EventManager <>4__this;

			public OvniScanRPC.ScanOvniData data;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass40_0
		{
			public OvniAttackRPC.CommandName command;

			public AlienAtackData data;

			public EventManager <>4__this;

			internal bool <HandleAlienAttackRPC>b__1(Player p)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				ZDOID zDOID = ((Character)p).GetZDOID();
				return ((ZDOID)(ref zDOID)).UserID == data.UserID;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass45_0
		{
			public AbductionRPC.CommandName command;

			public AbductionData data;

			public EventManager <>4__this;

			internal bool <HandleRunAbductionSequence>b__1(Player p)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				ZDOID zDOID = ((Character)p).GetZDOID();
				return ((ZDOID)(ref zDOID)).UserID == data.UserID;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass4_0
		{
			public AlienSightingRPC.CommandName command;

			public AlienSightingData data;

			public EventManager <>4__this;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass9_0
		{
			public CreatureAbductionRPC.CommandName command;

			public AbductionCreatureData data;

			public EventManager <>4__this;

			internal bool <HandleAbductionCreatureRPC>b__1(Player p)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				ZDOID zDOID = ((Character)p).GetZDOID();
				return ((ZDOID)(ref zDOID)).UserID == data.UserID;
			}
		}

		[CompilerGenerated]
		private sealed class <ExecuteAction>d__35 : 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 <ExecuteAction>d__35(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] ExecuteAction");
					if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
					{
						int count = ZNet.instance.GetConnectedPeers().Count;
						bool flag = (Object)(object)ZNet.instance != (Object)null;
						AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] ExecuteAction es un server jugadores: {count} zintance: {flag}");
						goto IL_00d1;
					}
					AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] ExecuteAction es un cliente");
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)Player.m_localPlayer != (Object)null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					goto IL_00d1;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_00d1:
					if (EnvMan.IsNight())
					{
						int num = Random.Range(0, 7);
						AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] ExecuteAction actionID: {num}");
						if (PlayerExtensions.TryGetRandomPlayer(out var player))
						{
							switch (num)
							{
							case 0:
								AlienSightingRPC.Instance.SendCommandToAll(AlienSightingRPC.CommandName.ALIEN_SIGHTING_START, new AlienSightingData
								{
									PlayerName = player.GetPlayerName(),
									UserID = player.GetPlayerID()
								});
								break;
							case 1:
								CreatureAbductionRPC.Instance.SendCommandToAll(CreatureAbductionRPC.CommandName.START_CREATURE_ABDUCTION, new AbductionCreatureData
								{
									UserID = player.GetPlayerID()
								});
								break;
							case 2:
								FlyOvniRPC.Instance.SendCommandToAll(FlyOvniRPC.CommandName.FLY_OVNI, new FlyOvniData
								{
									PlayerName = player.GetPlayerName(),
									UserID = player.GetPlayerID(),
									Config = Configurations.GetRandom()
								});
								break;
							case 3:
								SpeakAlienRPC.Instance.SendCommandToAll(SpeakAlienRPC.CommandName.SPEAK_ALIEN, new SpeakAlienData
								{
									PlayerName = player.GetPlayerName(),
									UserID = player.GetPlayerID()
								});
								break;
							case 4:
								OvniScanRPC.Instance.SendCommandToAll(OvniScanRPC.CommandName.START_SCAN, new OvniScanRPC.ScanOvniData
								{
									PlayerName = player.GetPlayerName(),
									UserID = player.GetPlayerID(),
									Config = Configurations.GetByIndex(0)
								});
								break;
							case 5:
								AbductionRPC.Instance.SendCommandToAll(AbductionRPC.CommandName.START_ABDUCTION, new AbductionData
								{
									UserID = player.GetPlayerID(),
									Config = Configurations.GetByIndex(0)
								});
								break;
							case 6:
								OvniAttackRPC.Instance.SendCommandToAll(OvniAttackRPC.CommandName.START_ATACK, new AlienAtackData
								{
									UserID = player.GetPlayerID(),
									Config = Configurations.GetByIndex(0)
								});
								break;
							}
						}
						else
						{
							AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] No se encontro jugador para {num}");
						}
					}
					else
					{
						AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] todavia no es de noche");
					}
					<>2__current = null;
					<>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();
			}
		}

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

			private object <>2__current;

			public EventManager <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Expected O, but got Unknown
				int num = <>1__state;
				EventManager eventManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => ZRoutedRpc.instance != null && (Object)(object)ZNetScene.instance != (Object)null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					eventManager.RegisterRPC_Abduction();
					eventManager.RegisterRPC_FlyOvni();
					eventManager.RegisterRPC_SpeakAlien();
					eventManager.RegisterRPC_OvniAtack();
					eventManager.RegisterRPC_OvniScan();
					eventManager.RegisterRPC_AlienSighting();
					eventManager.RegisterRPC_CreatureAbduction();
					eventManager.RegisterRPC_Intro();
					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 float timer = 10f;

		private float intervalSeconds = AliensConfig.EventFrequencyMinutes.Value * 60f;

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

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

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

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

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

		private SpeakAlienEvent AlienSpeakNearPlayerEvent => ((Component)this).gameObject.GetComponent<SpeakAlienEvent>();

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

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

		private void RegisterRPC_AlienSighting()
		{
			AlienSightingRPC.Instance.Register();
			AlienSightingRPC.Instance.OnCommandReceived += HandleAlienSightingRPC;
		}

		private void Register_AlienSighting()
		{
			((Component)this).gameObject.AddComponent<AlienSightingEvent>();
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AlienSightingCommand());
		}

		private void HandleAlienSightingRPC(AlienSightingRPC.CommandName command, AlienSightingData data)
		{
			<>c__DisplayClass4_0 CS$<>8__locals0 = new <>c__DisplayClass4_0();
			CS$<>8__locals0.command = command;
			CS$<>8__locals0.data = data;
			CS$<>8__locals0.<>4__this = this;
			AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] HandleScanOvniRPC {CS$<>8__locals0.command}");
			((MonoBehaviour)this).StartCoroutine(Run());
			[IteratorStateMachine(typeof(<>c__DisplayClass4_0.<<HandleAlienSightingRPC>g__Run|0>d))]
			IEnumerator Run()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass4_0.<<HandleAlienSightingRPC>g__Run|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		private void Register_CreatureAbduction()
		{
			((Component)this).gameObject.AddComponent<CreatureAbductionEvent>();
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new CreatureAbductionCommand());
		}

		private void RegisterRPC_CreatureAbduction()
		{
			CreatureAbductionRPC.Instance.Register();
			CreatureAbductionRPC.Instance.OnCommandReceived += HandleAbductionCreatureRPC;
		}

		private void HandleAbductionCreatureRPC(CreatureAbductionRPC.CommandName command, AbductionCreatureData data)
		{
			<>c__DisplayClass9_0 CS$<>8__locals0 = new <>c__DisplayClass9_0();
			CS$<>8__locals0.command = command;
			CS$<>8__locals0.data = data;
			CS$<>8__locals0.<>4__this = this;
			AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] HandleAbductionCreatureRPC.");
			((MonoBehaviour)this).StartCoroutine(Run());
			[IteratorStateMachine(typeof(<>c__DisplayClass9_0.<<HandleAbductionCreatureRPC>g__Run|0>d))]
			IEnumerator Run()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass9_0.<<HandleAbductionCreatureRPC>g__Run|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		private void Register_Intro()
		{
			((Component)this).gameObject.AddComponent<IntroductionSceneEvent>();
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new IntroductionSceneCommand());
		}

		private void RegisterRPC_Intro()
		{
			IntroductionSceneRPC.Instance.Register();
			IntroductionSceneRPC.Instance.OnCommandReceived += HandleShowIntroScene;
		}

		private void HandleShowIntroScene(IntroductionSceneRPC.CommandName command, IntroductionData data)
		{
			<>c__DisplayClass14_0 CS$<>8__locals0 = new <>c__DisplayClass14_0();
			CS$<>8__locals0.command = command;
			CS$<>8__locals0.<>4__this = this;
			AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] HandleShowIntroScene.");
			((MonoBehaviour)this).StartCoroutine(Run());
			[IteratorStateMachine(typeof(<>c__DisplayClass14_0.<<HandleShowIntroScene>g__Run|0>d))]
			IEnumerator Run()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass14_0.<<HandleShowIntroScene>g__Run|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		internal void RegisterRPC_OvniScan()
		{
			OvniScanRPC.Instance.Register();
			OvniScanRPC.Instance.OnCommandReceived += HandleScanOvniRPC;
		}

		internal void Register_OvniScan()
		{
			((Component)this).gameObject.AddComponent<OvniScanEvent>();
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new OvniScanCommand());
		}

		private void HandleScanOvniRPC(OvniScanRPC.CommandName command, OvniScanRPC.ScanOvniData data)
		{
			<>c__DisplayClass19_0 CS$<>8__locals0 = new <>c__DisplayClass19_0();
			CS$<>8__locals0.command = command;
			CS$<>8__locals0.<>4__this = this;
			CS$<>8__locals0.data = data;
			AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] HandleScanOvniRPC {CS$<>8__locals0.command}");
			((MonoBehaviour)this).StartCoroutine(Run());
			[IteratorStateMachine(typeof(<>c__DisplayClass19_0.<<HandleScanOvniRPC>g__Run|0>d))]
			IEnumerator Run()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass19_0.<<HandleScanOvniRPC>g__Run|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		internal void Register_FlyOvni()
		{
			((Component)this).gameObject.AddComponent<FlyOvniEvent>();
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new FlyOvniCommand());
		}

		internal void RegisterRPC_FlyOvni()
		{
			FlyOvniRPC.Instance.Register();
			FlyOvniRPC.Instance.OnCommandReceived += HandleFlyOvniRPC;
		}

		private void HandleFlyOvniRPC(FlyOvniRPC.CommandName command, FlyOvniData data)
		{
			AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] Comando recibido: {command}");
			if (data == null)
			{
				AliensInValheimMod.Logger.LogError((object)"[FlyOvni] El parámetro 'data' es null.");
				return;
			}
			AliensInValheimMod.Logger.LogInfo((object)$"[FlyOvni] UserID: {data.UserID}, Config: {data.Config}");
			Player val = Player.GetAllPlayers().Find(delegate(Player p)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				ZDOID zDOID = ((Character)p).GetZDOID();
				return ((ZDOID)(ref zDOID)).UserID == data.UserID;
			});
			if ((Object)(object)val == (Object)null)
			{
				AliensInValheimMod.Logger.LogWarning((object)$"[FlyOvni] No se encontró un jugador con UserID {data.UserID}. El jugador puede haberse desconectado.");
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(FlyOvniEvent.StartEvent(val, data.Config));
			}
		}

		protected void Register_SpeakAlien()
		{
			((Component)this).gameObject.AddComponent<SpeakAlienEvent>();
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new SpeakAlienCommand());
		}

		protected void RegisterRPC_SpeakAlien()
		{
			SpeakAlienRPC.Instance.Register();
			SpeakAlienRPC.Instance.OnCommandReceived += HandleAlienSpeakNearPlayerRPC;
		}

		private void HandleAlienSpeakNearPlayerRPC(SpeakAlienRPC.CommandName command, SpeakAlienData data)
		{
			AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] SpeakAlienRPC Comando recibido: {command}");
			Player val = Player.GetAllPlayers().Find(delegate(Player p)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				ZDOID zDOID = ((Character)p).GetZDOID();
				return ((ZDOID)(ref zDOID)).UserID == data.UserID;
			});
			if ((Object)(object)val == (Object)null)
			{
				AliensInValheimMod.Logger.LogWarning((object)$"[SpeakAlien] No se encontró un jugador con UserID {data.UserID}. El jugador puede haberse desconectado.");
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(AlienSpeakNearPlayerEvent.PlayAlienVoice(val));
			}
		}

		private void Awake()
		{
			AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] Inicializando Event Manager...");
			Register_Abduction();
			Register_AlienSighting();
			Register_CreatureAbduction();
			Register_FlyOvni();
			Register_OvniAtack();
			Register_OvniScan();
			Register_SpeakAlien();
			Register_Intro();
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ClearOvnisCommand());
			((MonoBehaviour)this).StartCoroutine(RegisterRPCEvents());
			((MonoBehaviour)this).InvokeRepeating("RunProcess", timer, intervalSeconds);
		}

		private void RunProcess()
		{
			((MonoBehaviour)this).StartCoroutine(ExecuteAction());
		}

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

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

		internal void Register_OvniAtack()
		{
			((Component)this).gameObject.AddComponent<OvniAttackEvent>();
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new OvniAtackCommand());
		}

		internal void RegisterRPC_OvniAtack()
		{
			OvniAttackRPC.Instance.Register();
			OvniAttackRPC.Instance.OnCommandReceived += HandleAlienAttackRPC;
		}

		private void HandleAlienAttackRPC(OvniAttackRPC.CommandName command, AlienAtackData data)
		{
			<>c__DisplayClass40_0 CS$<>8__locals0 = new <>c__DisplayClass40_0();
			CS$<>8__locals0.command = command;
			CS$<>8__locals0.data = data;
			CS$<>8__locals0.<>4__this = this;
			AliensInValheimMod.Logger.LogInfo((object)"[AliensInValheim] Ataque de ovnis");
			((MonoBehaviour)this).StartCoroutine(Run());
			[IteratorStateMachine(typeof(<>c__DisplayClass40_0.<<HandleAlienAttackRPC>g__Run|0>d))]
			IEnumerator Run()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass40_0.<<HandleAlienAttackRPC>g__Run|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		private void Register_Abduction()
		{
			((Component)this).gameObject.AddComponent<AbductionEvent>();
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AbductionCommand());
		}

		private void RegisterRPC_Abduction()
		{
			AbductionRPC.Instance.Register();
			AbductionRPC.Instance.OnCommandReceived += HandleRunAbductionSequence;
		}

		private void HandleRunAbductionSequence(AbductionRPC.CommandName command, AbductionData data)
		{
			<>c__DisplayClass45_0 CS$<>8__locals0 = new <>c__DisplayClass45_0();
			CS$<>8__locals0.command = command;
			CS$<>8__locals0.data = data;
			CS$<>8__locals0.<>4__this = this;
			((MonoBehaviour)this).StartCoroutine(Run());
			[IteratorStateMachine(typeof(<>c__DisplayClass45_0.<<HandleRunAbductionSequence>g__Run|0>d))]
			IEnumerator Run()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass45_0.<<HandleRunAbductionSequence>g__Run|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}
	}
	internal static class PrefabNames
	{
		internal const string SPRITE_OVNI = "assets/sprites/ovni.png";

		internal const string SPRITE_ALIEN = "assets/sprites/alien.png";

		internal const string MUSIC_XFILES = "assets/sounds/ufo_music1.mp3";

		internal const string MUSIC_BACKGROUND_OVNI = "assets/sounds/ufo_music2.mp3";

		internal const string ALIEN = "assets/alien1/prefab/alien1.prefab";

		internal const string LASSER = "assets/sounds/laser.mp3";
	}
	public static class AliensConfig
	{
		public static ConfigEntry<float> EventFrequencyMinutes;

		public static ConfigEntry<bool> IntroShown;

		public static ConfigEntry<KeyboardShortcut> IntroKey;

		public static void BuildConfig(ConfigFile config)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			EventFrequencyMinutes = config.Bind<float>("General", "FrequencyMinutes", 15f, new ConfigDescription("Frecuencia con la que el OVNI puede aparecer (minutos).", (AcceptableValueBase)null, Array.Empty<object>()));
			IntroShown = config.Bind<bool>("Intro", "HasSeenIntro", false, "Indica si el jugador ya vio la introducción. Se reproduce solo una vez.");
			IntroKey = config.Bind<KeyboardShortcut>("Intro", "IntroActivationKey", new KeyboardShortcut((KeyCode)285, Array.Empty<KeyCode>()), "Tecla para activar la intro manualmente.");
		}
	}
	[BepInPlugin("com.valheim.aliens", "AliensInValheim", "1.1.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class AliensInValheimMod : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <SolveLicense>d__23 : 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 <SolveLicense>d__23(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_006b: 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_005b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Logger.LogInfo((object)"[AliensInValheim] SolveLicense");
					<>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;
					ulong steamID = SteamUser.GetSteamID().m_SteamID;
					Logger.LogMessage((object)string.Format("{0} STEAMID:{1}", "AliensInValheim", steamID));
					if (ZNet.instance.IsServer())
					{
						LicenseValidator.ValidateLocalLicense(steamID);
					}
					else
					{
						LicenseValidator.ValidateRemoteLicense(steamID);
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				case 2:
					<>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 <WaitForPlayerThenShowIntro>d__20 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AliensInValheimMod <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Expected O, but got Unknown
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Expected O, but got Unknown
				int num = <>1__state;
				AliensInValheimMod aliensInValheimMod = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)ZNetScene.instance != (Object)null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (AliensConfig.IntroShown.Value)
					{
						break;
					}
					AliensConfig.IntroShown.Value = true;
					((BaseUnityPlugin)aliensInValheimMod).Config.Save();
					goto IL_00c5;
				case 3:
					{
						<>1__state = -1;
						goto IL_00c5;
					}
					IL_00c5:
					if ((Object)(object)Hud.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
					{
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					if ((Object)(object)Object.FindAnyObjectByType<AlienHudUI>() == (Object)null)
					{
						Logger.LogInfo((object)"[AliensInValheim] Cargando AlienHudUI (solo en juego)...");
						((Component)aliensInValheimMod).gameObject.AddComponent<AlienHudUI>();
					}
					IntroductionSceneRPC.Instance.SendCommandToAll(IntroductionSceneRPC.CommandName.START, new IntroductionData());
					break;
				}
				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 Harmony _harmony;

		public const string PluginGUID = "com.valheim.aliens";

		public const string PluginName = "AliensInValheim";

		public const string PluginVersion = "1.1.3";

		public static ManualLogSource Logger;

		private AssetBundle bundle;

		internal static string modPath;

		internal static AliensInValheimMod Instance { get; private set; }

		internal AssetBundle Library => bundle ?? LibraryLoaderExtension.LoadLibraryFileBundle(modPath);

		public static List<GameObject> OvniList { get; internal set; } = new List<GameObject>();


		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Awake()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			modPath = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			bundle = LibraryLoaderExtension.LoadLibraryFileBundle(modPath);
			Loc.InitFromFolder(modPath);
			MusicDucker.Init();
			_harmony = new Harmony("com.valheim.aliens");
			_harmony.PatchAll();
			if ((Object)(object)bundle == (Object)null)
			{
				Logger.LogError((object)"❌ No se pudo cargar el bundle");
			}
			else
			{
				string[] allAssetNames = bundle.GetAllAssetNames();
				foreach (string text in allAssetNames)
				{
					Logger.LogInfo((object)("[AliensInValheim] bundle contiene: " + text));
				}
			}
			Logger.LogInfo((object)"[AliensInValheim] cargando configuración...");
			AliensConfig.BuildConfig(((BaseUnityPlugin)this).Config);
			((Component)this).gameObject.AddComponent<EventManager>();
			LicenseValidator.RegisterApi((MonoBehaviour)(object)this);
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0047: 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_0058: Expected O, but got Unknown
			Logger.LogInfo((object)("[AliensInValheim] Escena del menú " + ((Scene)(ref scene)).name));
			if (((Scene)(ref scene)).name.ToLower() == "start")
			{
				Logger.LogInfo((object)"[AliensInValheim] Escena del menú principal detectada. Iniciando MainMenuUFO.");
				GameObject val = new GameObject("MainMenuUFOController");
				val.AddComponent<MainMenuUFO>();
				Object.DontDestroyOnLoad((Object)val);
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(WaitForPlayerThenShowIntro());
			}
		}

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

		private void Update()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				KeyboardShortcut value = AliensConfig.IntroKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					IntroductionSceneRPC.Instance.SendCommandToAll(IntroductionSceneRPC.CommandName.END, new IntroductionData());
				}
			}
		}

		private void VerifyLicense()
		{
			((MonoBehaviour)this).StartCoroutine(SolveLicense());
		}

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

		internal static void ClearOvnis()
		{
			int num = 0;
			string.Format("[{0}] ClearOvnis {1}", "AliensInValheim", OvniList.Count);
			foreach (GameObject ovni in OvniList)
			{
				if ((Object)(object)ovni != (Object)null)
				{
					Object.Destroy((Object)(object)ovni);
					num++;
				}
			}
			OvniList.Clear();
			Logger.LogInfo((object)$"De la lista de {OvniList.Count} ovnis se han borrado {num}");
		}
	}
	public sealed class OvniConfiguration
	{
		public string PrefabName { get; set; }

		public int EngineSoundIndex { get; set; }

		public int BackGroundSoundIndex { get; set; }

		public override string ToString()
		{
			return "Prefab: " + PrefabName + ", " + $"EngineSound: {EngineSoundIndex}, " + $"BackgroundSound: {BackGroundSoundIndex}";
		}

		public OvniConfiguration()
		{
			BackGroundSoundIndex = 1;
			EngineSoundIndex = 1;
			PrefabName = "assets/ovni1/prefab/ovni1.prefab";
		}
	}
	public static class Configurations
	{
		public static readonly List<OvniConfiguration> List = new List<OvniConfiguration>
		{
			new OvniConfiguration
			{
				EngineSoundIndex = 1,
				BackGroundSoundIndex = 1,
				PrefabName = "assets/ovni1/prefab/ovni1.prefab"
			},
			new OvniConfiguration
			{
				EngineSoundIndex = 2,
				BackGroundSoundIndex = 2,
				PrefabName = "assets/ovni2/prefab/ovni2.prefab"
			},
			new OvniConfiguration
			{
				EngineSoundIndex = 3,
				BackGroundSoundIndex = 3,
				PrefabName = "assets/ovni3/prefab/ovni3.prefab"
			},
			new OvniConfiguration
			{
				EngineSoundIndex = 4,
				BackGroundSoundIndex = 4,
				PrefabName = "assets/ovni4/prefab/ovni4.prefab"
			},
			new OvniConfiguration
			{
				EngineSoundIndex = 5,
				BackGroundSoundIndex = 3,
				PrefabName = "assets/ovni5/prefab/ovni5.prefab"
			},
			new OvniConfiguration
			{
				EngineSoundIndex = 3,
				BackGroundSoundIndex = 6,
				PrefabName = "assets/ovni6/prefab/ovni6.prefab"
			},
			new OvniConfiguration
			{
				EngineSoundIndex = 2,
				BackGroundSoundIndex = 4,
				PrefabName = "assets/ovni7/prefab/ovni7.prefab"
			}
		};

		public static int GetIndex(OvniConfiguration config)
		{
			return List.IndexOf(config);
		}

		public static OvniConfiguration GetByIndex(int index)
		{
			if (index < 0 || index >= List.Count)
			{
				AliensInValheimMod.Logger.LogWarning((object)$"[Aliens] Índice inválido de configuración: {index}. Se usará la configuración por defecto.");
				return List[0];
			}
			return List[index];
		}

		public static OvniConfiguration GetRandom()
		{
			return List[Random.Range(0, List.Count)];
		}
	}
	public abstract class CommandRPCBase<TEnum, TPayload> where TEnum : struct, Enum
	{
		public class CommandWrapper<T>
		{
			public string Command { get; set; }

			public T Value { get; set; }
		}

		protected abstract string RPCName { get; }

		public event Action<TEnum, TPayload> OnCommandReceived;

		public void Register()
		{
			AliensInValheimMod.Logger.LogInfo((object)("[AliensInValheim] Registrando RPC: " + RPCName));
			ZRoutedRpc.instance.Register<ZPackage>(RPCName, (Action<long, ZPackage>)HandleEvent);
		}

		private void HandleEvent(long sender, ZPackage pkg)
		{
			try
			{
				if (pkg == null)
				{
					AliensInValheimMod.Logger.LogWarning((object)("[AliensInValheim] " + RPCName + ": paquete nulo"));
					return;
				}
				string text = pkg.ReadString();
				if (string.IsNullOrEmpty(text))
				{
					AliensInValheimMod.Logger.LogWarning((object)("[AliensInValheim] " + RPCName + ": JSON vacío"));
					return;
				}
				CommandWrapper<TPayload> commandWrapper = JsonConvert.DeserializeObject<CommandWrapper<TPayload>>(text);
				if (commandWrapper == null)
				{
					AliensInValheimMod.Logger.LogWarning((object)("[AliensInValheim] " + RPCName + ": wrapper nulo"));
					return;
				}
				if (!Enum.TryParse<TEnum>(commandWrapper.Command, ignoreCase: true, out var result))
				{
					AliensInValheimMod.Logger.LogWarning((object)("[AliensInValheim] " + RPCName + ": comando inválido '" + commandWrapper.Command + "'"));
					return;
				}
				AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] RPC recibido: {result} desde sender {sender}");
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					foreach (ZNetPeer peer in ZNet.instance.GetPeers())
					{
						if (peer.m_uid != sender)
						{
							ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, RPCName, new object[1] { pkg });
							AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] {RPCName} enviado {result} desde sender {sender} a {peer.m_uid}");
						}
					}
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, RPCName, new object[1] { pkg });
					AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] {RPCName} enviado {result} de vuelta al sender {sender}");
					InvokeLocal(result, commandWrapper.Value);
				}
				else
				{
					InvokeLocal(result, commandWrapper.Value);
				}
			}
			catch (Exception arg)
			{
				AliensInValheimMod.Logger.LogError((object)$"[AliensInValheim] Error en HandlePackage {RPCName}: {arg}");
			}
		}

		private void InvokeLocal(TEnum command, TPayload value)
		{
			try
			{
				Action<TEnum, TPayload> onCommandReceived = this.OnCommandReceived;
				if (onCommandReceived != null)
				{
					onCommandReceived(command, value);
				}
				else
				{
					AliensInValheimMod.Logger.LogDebug((object)("[AliensInValheim] " + RPCName + ": sin suscriptores locales"));
				}
			}
			catch (Exception arg)
			{
				AliensInValheimMod.Logger.LogError((object)$"[AliensInValheim] {RPCName}: error en OnCommandReceived: {arg}");
			}
		}

		private static long GetServerPeerIdSafe()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return 0L;
			}
			return ZNet.instance.GetServerPeer()?.m_uid ?? 0;
		}

		public void SendCommandToAll(TEnum command, TPayload value)
		{
			ZPackage val = BuildPackage(command, value);
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] Broadcast {command} ({typeof(TPayload).Name})");
				foreach (ZNetPeer peer in ZNet.instance.GetPeers())
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, RPCName, new object[1] { val });
					AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] SendCommandToAll {RPCName} enviado desde el server {command} a {peer.m_uid}");
				}
				InvokeLocal(command, value);
			}
			else
			{
				long serverPeerIdSafe = GetServerPeerIdSafe();
				AliensInValheimMod.Logger.LogInfo((object)$"[AliensInValheim] SendToServer {command} serverId:{serverPeerIdSafe} ({typeof(TPayload).Name})");
				if (serverPeerIdSafe != 0L)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerIdSafe, RPCName, new object[1] { val });
				}
				else
				{
					AliensInValheimMod.Logger.LogWarning((object)("[AliensInValheim] " + RPCName + ": aún no conectado al servidor (serverId=0)."));
				}
			}
		}

		private ZPackage BuildPackage(TEnum command, TPayload value)
		{
			//IL_0025: 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_0032: Expected O, but got Unknown
			string text = JsonConvert.SerializeObject((object)new CommandWrapper<TPayload>
			{
				Command = command.ToString(),
				Value = value
			});
			ZPackage val = new ZPackage();
			val.Write(text);
			return val;
		}
	}
}