using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Splatform;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("AuroraProjectButter")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0")]
[assembly: AssemblyProduct("AuroraProjectButter")]
[assembly: AssemblyTitle("AuroraProjectButter")]
[assembly: AssemblyVersion("1.3.0.0")]
namespace AuroraProjectButter;

internal static class GhostUserIDRegistry
{
	private static readonly HashSet<string> _ids = new HashSet<string>(StringComparer.Ordinal);

	public static void Register(string userId)
	{
		if (!string.IsNullOrEmpty(userId))
		{
			_ids.Add(userId);
		}
	}

	public static bool IsGhost(string userId)
	{
		if (!string.IsNullOrEmpty(userId))
		{
			return _ids.Contains(userId);
		}
		return false;
	}
}
[HarmonyPatch(typeof(RelationsManager), "CheckPermissionAsync")]
internal static class RelationsManager_CheckPermissionAsync_GhostFilter
{
	[HarmonyPrefix]
	public static bool Prefix(PlatformUserID user)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		if (GhostUserIDRegistry.IsGhost(user.m_userID))
		{
			return false;
		}
		return true;
	}
}
internal static class GhostChatBypass
{
	public static ConfigEntry<string> PermanentGhostName;

	private static readonly string[] KnownGhostNames = new string[122]
	{
		"Bjorn", "Sigrid", "Ragnar", "Freya", "Leif", "Astrid", "Ulf", "Ingrid", "Thorstein", "Gudrun",
		"Ivar", "Helga", "Sven", "Thyra", "Erik", "Hilda", "Harald", "Runa", "Olaf", "Solveig",
		"Gunnar", "Eira", "Knut", "Liv", "Torbjorn", "Sigrun", "Vidar", "Brynhild", "Arne", "Dagny",
		"Halfdan", "Ylva", "Fenrir", "Saga", "Ketil", "Alva", "Hakon", "Jorunn", "Styrbjorn", "Tove",
		"Bjarke", "Revna", "Grim", "Embla", "Thorgrim", "Nanna", "Oddvar", "Sif", "Skjold", "Idun",
		"Bragi", "Sigyn", "Baldur", "Hermod", "Magni", "Modi", "Vali", "Forseti", "Thrud", "Eir",
		"Gefjon", "Skadi", "Ran", "Aegir", "Ironside", "Stormborn", "Shieldmaiden", "Ravenclaw", "Wolfsbane", "Frostbite",
		"Shadowmere", "Nighthawk", "Stonewall", "Firebrand", "Dawnbreaker", "Thunderstrike", "Ashwalker", "Bonecrusher", "Grimjaw", "Bloodraven",
		"Warhammer", "Duskblade", "Starforger", "Voidwalker", "xNordicVibes", "TrollSlayer99", "MeadLord", "VikingChad", "SkadiMain", "OdinFan42",
		"NeckHunter", "GreydwarfGang", "LoxRider", "RuneMaster", "DraugrDave", "FulingKing", "BossHunter", "TreePuncher", "CoinHoarder", "IronPickAxe",
		"SerpentBait", "MushroomGuy", "ThistleQueen", "HoneyBear", "Magnus", "Elara", "Rorik", "Keira", "Thandor", "Lyra",
		"Draven", "Nova", "Caspian", "Ember", "Orion", "Wren", "Axel", "Ivy", "Zeke", "Mira",
		"Knox", "Sage"
	};

	public static bool IsKnownGhostName(string name)
	{
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		string value = PermanentGhostName?.Value ?? "Aurora";
		if (name.Equals(value, StringComparison.OrdinalIgnoreCase))
		{
			return true;
		}
		for (int i = 0; i < KnownGhostNames.Length; i++)
		{
			if (KnownGhostNames[i].Equals(name, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
		}
		return false;
	}
}
[HarmonyPatch(typeof(Chat), "RPC_ChatMessage")]
internal static class Chat_RPC_ChatMessage_GhostPatch
{
	[HarmonyPrefix]
	public static bool Prefix(Chat __instance, long sender, Vector3 position, int type, UserInfo userInfo, string text)
	{
		//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c6: Invalid comparison between Unknown and I4
		//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cc: 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_01d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Unknown result type (might be due to invalid IL or missing references)
		//IL_0128: Invalid comparison between Unknown and I4
		//IL_01e6: 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_01f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ff: 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_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_024d: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: 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)
		if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
		{
			return true;
		}
		string text2 = userInfo?.Name ?? "";
		if (!GhostChatBypass.IsKnownGhostName(text2))
		{
			return true;
		}
		GhostPlayerInjector.RememberGhost(text2);
		try
		{
			Type val = (Type)type;
			bool flag = false;
			try
			{
				MethodInfo method = typeof(Chat).GetMethod("AddString", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
				{
					typeof(PlatformUserID),
					typeof(string),
					typeof(Type)
				}, null);
				if (method != null)
				{
					PlatformUserID val2 = (PlatformUserID)(((??)userInfo?.UserId) ?? new PlatformUserID("Steam", "0"));
					method.Invoke(__instance, new object[3]
					{
						val2,
						text ?? "",
						val
					});
					flag = true;
				}
				else
				{
					ManualLogSource logger = ButterPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[GhostChatBypass] Chat.AddString(PlatformUserID,string,Talker.Type) not found on this Valheim version.");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = ButterPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[GhostChatBypass] AddString invoke: " + ex.Message));
				}
			}
			if (!flag)
			{
				string text3 = (((int)val == 2) ? ("<color=yellow>" + text2 + "</color>: <color=yellow><b>" + (text ?? "").ToUpper() + "</b></color>") : ("<color=yellow>" + text2 + "</color>: " + text));
				((Terminal)__instance).AddString(text3);
			}
			try
			{
				typeof(Chat).GetField("m_hideTimer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(__instance, 0f);
			}
			catch
			{
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null && (int)val != 3)
			{
				try
				{
					Vector3 val3 = position;
					if (val3 == Vector3.zero)
					{
						val3 = ((Component)Player.m_localPlayer).transform.position + Vector3.up * 2.5f;
					}
					MethodInfo method2 = typeof(Chat).GetMethod("AddInworldText", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (method2 != null && method2.GetParameters().Length == 6)
					{
						method2.Invoke(__instance, new object[6] { null, sender, val3, val, userInfo, text });
					}
				}
				catch
				{
				}
			}
		}
		catch (Exception ex2)
		{
			ManualLogSource logger3 = ButterPlugin.Logger;
			if (logger3 != null)
			{
				logger3.LogWarning((object)("[GhostChatBypass] Failed: " + ex2.Message));
			}
		}
		return false;
	}
}
internal static class GhostPlayerInjector
{
	internal class GhostInjectorMB : MonoBehaviour
	{
		private float _nextPoll;

		private int _pollCount;

		private void Update()
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			if (Time.unscaledTime < _nextPoll)
			{
				return;
			}
			_nextPoll = Time.unscaledTime + 2f;
			try
			{
				ZNet instance = ZNet.instance;
				if ((Object)(object)instance == (Object)null || instance.IsServer())
				{
					return;
				}
				FieldInfo field = typeof(ZNet).GetField("m_players", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field == null || !(field.GetValue(instance) is List<PlayerInfo> list))
				{
					return;
				}
				int count = list.Count;
				string text = GhostChatBypass.PermanentGhostName?.Value ?? "Aurora";
				string currentRotatingGhostName = GetCurrentRotatingGhostName();
				List<int> list2 = new List<int>();
				FieldInfo field2 = typeof(PlayerInfo).GetField("m_name", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field2 != null)
				{
					for (int i = 0; i < list.Count; i++)
					{
						string text2 = field2.GetValue(list[i]) as string;
						if (string.IsNullOrEmpty(text2) || string.Equals(text2, text, StringComparison.OrdinalIgnoreCase) || string.Equals(text2, currentRotatingGhostName, StringComparison.OrdinalIgnoreCase))
						{
							continue;
						}
						bool flag = false;
						for (int j = 0; j < RotatingGhostPool.Length; j++)
						{
							if (RotatingGhostPool[j].Equals(text2, StringComparison.OrdinalIgnoreCase))
							{
								flag = true;
								break;
							}
						}
						if (flag)
						{
							list2.Add(i);
						}
					}
				}
				for (int num = list2.Count - 1; num >= 0; num--)
				{
					list.RemoveAt(list2[num]);
				}
				ZNet_RPC_PlayerList_Patch_AddIfMissing(list, text);
				ZNet_RPC_PlayerList_Patch_AddIfMissing(list, currentRotatingGhostName);
				foreach (string seenGhostName in _seenGhostNames)
				{
					ZNet_RPC_PlayerList_Patch_AddIfMissing(list, seenGhostName);
				}
				_pollCount++;
				if (_pollCount == 1 || _pollCount % 30 == 0)
				{
					ManualLogSource logger = ButterPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[GhostPlayerInjector-Poll] poll #{_pollCount}: m_players {count} → {list.Count} (added {list.Count - count}). Seen: {_seenGhostNames.Count}");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = ButterPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[GhostPlayerInjector-Poll] " + ex.Message));
				}
			}
		}

		private static void ZNet_RPC_PlayerList_Patch_AddIfMissing(List<PlayerInfo> list, string name)
		{
			//IL_0031: 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 (string.IsNullOrEmpty(name))
			{
				return;
			}
			FieldInfo field = typeof(PlayerInfo).GetField("m_name", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				if (string.Equals(field.GetValue(list[i]) as string, name, StringComparison.OrdinalIgnoreCase))
				{
					return;
				}
			}
			list.Add(MakeGhostPlayerInfo(name));
		}
	}

	[HarmonyPatch(typeof(ZNet), "RPC_PlayerList")]
	internal static class ZNet_RPC_PlayerList_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(ZNet __instance)
		{
			if ((Object)(object)__instance == (Object)null || __instance.IsServer())
			{
				return;
			}
			try
			{
				FieldInfo field = typeof(ZNet).GetField("m_players", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field == null)
				{
					if (_postfixRunCount == 0)
					{
						ManualLogSource logger = ButterPlugin.Logger;
						if (logger != null)
						{
							logger.LogWarning((object)"[GhostPlayerInjector] m_players field not found on ZNet.");
						}
					}
					_postfixRunCount++;
					return;
				}
				if (!(field.GetValue(__instance) is List<PlayerInfo> list))
				{
					if (_postfixRunCount == 0)
					{
						ManualLogSource logger2 = ButterPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogWarning((object)"[GhostPlayerInjector] m_players is null or wrong type.");
						}
					}
					_postfixRunCount++;
					return;
				}
				int count = list.Count;
				string name = GhostChatBypass.PermanentGhostName?.Value ?? "Aurora";
				string currentRotatingGhostName = GetCurrentRotatingGhostName();
				AddIfMissing(list, name);
				AddIfMissing(list, currentRotatingGhostName);
				foreach (string seenGhostName in _seenGhostNames)
				{
					AddIfMissing(list, seenGhostName);
				}
				_postfixRunCount++;
				if (_postfixRunCount == 1 || _postfixRunCount % 20 == 0)
				{
					ManualLogSource logger3 = ButterPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogInfo((object)$"[GhostPlayerInjector] Postfix run #{_postfixRunCount}. m_players was {count} → {list.Count} (added {list.Count - count} ghost(s)). Seen ghost names: {_seenGhostNames.Count}.");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger4 = ButterPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)("[GhostPlayerInjector] Postfix failed: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}

		private static void AddIfMissing(List<PlayerInfo> list, string name)
		{
			//IL_005d: 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 (string.IsNullOrEmpty(name))
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				FieldInfo field = typeof(PlayerInfo).GetField("m_name", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field == null)
				{
					break;
				}
				if (string.Equals(field.GetValue(list[i]) as string, name, StringComparison.OrdinalIgnoreCase))
				{
					return;
				}
			}
			list.Add(MakeGhostPlayerInfo(name));
		}
	}

	private static readonly HashSet<string> _seenGhostNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private const int RotationMinutes = 30;

	private static readonly string[] RotatingGhostPool = new string[48]
	{
		"Bjorn", "Sigrid", "Ragnar", "Freya", "Leif", "Astrid", "Ulf", "Ingrid", "Thorstein", "Gudrun",
		"Ivar", "Helga", "Sven", "Thyra", "Erik", "Hilda", "Harald", "Runa", "Olaf", "Solveig",
		"Gunnar", "Eira", "Knut", "Liv", "Torbjorn", "Sigrun", "Vidar", "Brynhild", "Arne", "Dagny",
		"Halfdan", "Ylva", "Fenrir", "Saga", "Ketil", "Alva", "Hakon", "Jorunn", "Styrbjorn", "Tove",
		"Bjarke", "Revna", "Grim", "Embla", "Thorgrim", "Nanna", "Oddvar", "Sif"
	};

	private static bool _diagDumped = false;

	private static readonly HashSet<string> _verifiedGhosts = new HashSet<string>();

	private static int _postfixRunCount = 0;

	public static string GetCurrentRotatingGhostName()
	{
		DateTime dateTime = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc);
		int num = (int)(Math.Abs((long)((DateTime.UtcNow - dateTime).TotalMinutes / 30.0)) % RotatingGhostPool.Length);
		return RotatingGhostPool[num];
	}

	public static void RememberGhost(string name)
	{
		if (!string.IsNullOrEmpty(name))
		{
			_seenGhostNames.Add(name);
		}
	}

	private static Vector3 PositionFor(string name)
	{
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		int num = 0;
		string text = name ?? "";
		foreach (char c in text)
		{
			num = num * 31 + c;
		}
		Random random = new Random(num);
		float num2 = (float)(random.NextDouble() * Math.PI * 2.0);
		float num3 = 2000f + (float)(random.NextDouble() * 5000.0);
		float num4 = Mathf.Cos(num2) * num3;
		float num5 = Mathf.Sin(num2) * num3;
		return new Vector3(num4, 30f, num5);
	}

	private static void DumpPlayerInfoSchema()
	{
		if (_diagDumped)
		{
			return;
		}
		_diagDumped = true;
		try
		{
			Type typeFromHandle = typeof(PlayerInfo);
			ManualLogSource logger = ButterPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[Diag] ZNet.PlayerInfo fields:");
			}
			FieldInfo[] fields = typeFromHandle.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				ManualLogSource logger2 = ButterPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)("  " + fieldInfo.FieldType.FullName + " " + fieldInfo.Name));
				}
			}
			FieldInfo field = typeFromHandle.GetField("m_userInfo", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(field != null))
			{
				return;
			}
			ManualLogSource logger3 = ButterPlugin.Logger;
			if (logger3 != null)
			{
				logger3.LogInfo((object)("[Diag] " + field.FieldType.FullName + " fields:"));
			}
			fields = field.FieldType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo2 in fields)
			{
				ManualLogSource logger4 = ButterPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogInfo((object)("  " + fieldInfo2.FieldType.FullName + " " + fieldInfo2.Name));
				}
			}
			FieldInfo field2 = field.FieldType.GetField("m_id", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(field2 != null))
			{
				return;
			}
			ManualLogSource logger5 = ButterPlugin.Logger;
			if (logger5 != null)
			{
				logger5.LogInfo((object)("[Diag] " + field2.FieldType.FullName + " (PlatformUserID) fields:"));
			}
			fields = field2.FieldType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo3 in fields)
			{
				ManualLogSource logger6 = ButterPlugin.Logger;
				if (logger6 != null)
				{
					logger6.LogInfo((object)("  " + fieldInfo3.FieldType.FullName + " " + fieldInfo3.Name));
				}
			}
		}
		catch (Exception ex)
		{
			ManualLogSource logger7 = ButterPlugin.Logger;
			if (logger7 != null)
			{
				logger7.LogWarning((object)("[Diag] dump failed: " + ex.Message));
			}
		}
	}

	internal static PlayerInfo MakeGhostPlayerInfo(string name)
	{
		//IL_0007: 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_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ff: 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_037e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0383: Unknown result type (might be due to invalid IL or missing references)
		//IL_0399: 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_03c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_028f: Unknown result type (might be due to invalid IL or missing references)
		DumpPlayerInfoSchema();
		object obj = (object)default(PlayerInfo);
		Type typeFromHandle = typeof(PlayerInfo);
		typeFromHandle.GetField("m_name", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(obj, name);
		long num = 1879048192L;
		uint num2 = 1u;
		try
		{
			uint num3 = 2166136261u;
			string text = name ?? "";
			foreach (char c in text)
			{
				num3 ^= c;
				num3 *= 16777619;
			}
			num = 0x70000000L | (long)(num3 & 0x7FFFFFFF);
			num2 = num3 % 255 + 1;
		}
		catch
		{
		}
		try
		{
			ConstructorInfo constructor = typeof(ZDOID).GetConstructor(new Type[2]
			{
				typeof(long),
				typeof(uint)
			});
			object value = ((constructor != null) ? constructor.Invoke(new object[2] { num, num2 }) : ((object)ZDOID.None));
			typeFromHandle.GetField("m_characterID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(obj, value);
		}
		catch
		{
			typeFromHandle.GetField("m_characterID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(obj, ZDOID.None);
		}
		typeFromHandle.GetField("m_publicPosition", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(obj, true);
		typeFromHandle.GetField("m_position", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(obj, PositionFor(name));
		typeFromHandle.GetField("m_serverAssignedDisplayName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(obj, name);
		try
		{
			FieldInfo field = typeFromHandle.GetField("m_userInfo", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				object obj4 = Activator.CreateInstance(field.FieldType);
				field.FieldType.GetField("m_displayName")?.SetValue(obj4, name);
				FieldInfo field2 = field.FieldType.GetField("m_id");
				if (field2 != null)
				{
					ulong num4 = 14695981039346656037uL;
					string text = name ?? "";
					foreach (char c2 in text)
					{
						num4 ^= c2;
						num4 *= 1099511628211L;
					}
					string text2 = (76561197960265728L + num4 % 1000000000).ToString();
					object obj5;
					try
					{
						obj5 = (object)new PlatformUserID("Steam", text2);
					}
					catch
					{
						obj5 = Activator.CreateInstance(field2.FieldType);
						FieldInfo field3 = field2.FieldType.GetField("m_platform", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (field3 != null)
						{
							try
							{
								ConstructorInfo constructor2 = field3.FieldType.GetConstructor(new Type[1] { typeof(string) });
								if (constructor2 != null)
								{
									field3.SetValue(obj5, constructor2.Invoke(new object[1] { "Steam" }));
								}
							}
							catch
							{
							}
						}
						field2.FieldType.GetField("m_userID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(obj5, text2);
					}
					GhostUserIDRegistry.Register(text2);
					field2.SetValue(obj4, obj5);
				}
				field.SetValue(obj, obj4);
			}
		}
		catch
		{
		}
		if (!_verifiedGhosts.Contains(name))
		{
			_verifiedGhosts.Add(name);
			try
			{
				PlayerInfo val = (PlayerInfo)obj;
				string text3 = typeFromHandle.GetField("m_name", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(val) as string;
				object obj9 = typeFromHandle.GetField("m_position", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(val);
				object obj10 = typeFromHandle.GetField("m_userInfo", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(val);
				string text4 = null;
				string text5 = null;
				string text6 = null;
				if (obj10 != null)
				{
					Type type = obj10.GetType();
					text4 = type.GetField("m_displayName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj10) as string;
					object obj11 = type.GetField("m_id", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj10);
					if (obj11 != null)
					{
						Type type2 = obj11.GetType();
						text6 = (type2.GetField("m_platform", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj11))?.ToString();
						text5 = type2.GetField("m_userID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj11) as string;
					}
				}
				ManualLogSource logger = ButterPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[Diag] ghost '{name}' built → m_name='{text3}' m_position={obj9} m_userInfo.m_displayName='{text4}' m_id.m_platform={text6} m_id.m_userID='{text5}'");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = ButterPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[Diag] verify failed: " + ex.Message));
				}
			}
		}
		return (PlayerInfo)obj;
	}

	private static void SetField(object target, string name, object value)
	{
		try
		{
			target.GetType().GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(target, value);
		}
		catch
		{
		}
	}
}
[BepInPlugin("freyja.AuroraProjectButter", "AuroraProjectButter", "1.3.9")]
public class ButterPlugin : BaseUnityPlugin
{
	internal struct DeferredDungeon
	{
		public DungeonGenerator Generator;

		public Vector3 Position;
	}

	[Serializable]
	[CompilerGenerated]
	private sealed class <>c
	{
		public static readonly <>c <>9 = new <>c();

		public static ConsoleEvent <>9__27_0;

		public static Func<MethodInfo, bool> <>9__31_0;

		public static Func<MethodInfo, bool> <>9__31_1;

		public static Func<MethodInfo, bool> <>9__31_2;

		public static Func<MethodInfo, bool> <>9__31_3;

		public static Func<MethodInfo, bool> <>9__32_0;

		public static Func<ParameterInfo, string> <>9__32_1;

		public static Predicate<DeferredDungeon> <>9__37_0;

		internal void <Awake>b__27_0(ConsoleEventArgs args)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			DungeonCleanup();
			Player localPlayer = Player.m_localPlayer;
			float num = ((localPlayer != null) ? ((Component)localPlayer).transform.position.y : float.NaN);
			bool flag = IsPlayerTeleporting();
			bool flag2 = IsInGracePeriod();
			args.Context.AddString("[AuroraProjectButter v1.3.9]");
			args.Context.AddString($"  Dungeon Deferral: {TotalDeferred} deferred, {TotalAllowed} allowed, {Deferred.Count} queued");
			args.Context.AddString($"  Sky Filter: {SkyObjectsBlocked} blocked, {SkyObjectsAllowed} allowed");
			args.Context.AddString($"  Player Y: {num:F1}  Teleporting: {flag}  Grace: {flag2}");
			args.Context.AddString($"  World radius: {WorldRadius.Value}");
		}

		internal bool <ApplyDungeonPatches>b__31_0(MethodInfo m)
		{
			if (m.Name == "Generate")
			{
				return !m.IsAbstract;
			}
			return false;
		}

		internal bool <ApplyDungeonPatches>b__31_1(MethodInfo mi)
		{
			return mi.Name == "Interact";
		}

		internal bool <ApplyDungeonPatches>b__31_2(MethodInfo mi)
		{
			return mi.Name == "HaveTarget";
		}

		internal bool <ApplyDungeonPatches>b__31_3(MethodInfo mi)
		{
			return mi.Name == "OnSpawned";
		}

		internal bool <ApplySkyFilterPatches>b__32_0(MethodInfo m)
		{
			if (m.Name == "CreateObject")
			{
				return !m.IsAbstract;
			}
			return false;
		}

		internal string <ApplySkyFilterPatches>b__32_1(ParameterInfo p)
		{
			return p.ParameterType.Name;
		}

		internal bool <DungeonCleanup>b__37_0(DeferredDungeon d)
		{
			return (Object)(object)d.Generator == (Object)null;
		}
	}

	public const string PluginGUID = "freyja.AuroraProjectButter";

	public const string PluginName = "AuroraProjectButter";

	public const string PluginVersion = "1.3.9";

	internal static ButterPlugin Instance;

	internal static ManualLogSource Logger;

	private Harmony _harmony;

	internal static readonly List<DeferredDungeon> Deferred = new List<DeferredDungeon>();

	internal static bool IsForceLoading;

	internal static bool IsTeleporting;

	internal static float PlayerSpawnTime = -1f;

	internal static float TeleportEndTime = -1f;

	internal static MethodInfo DG_AwakeMethod;

	internal static int TotalDeferred;

	internal static int TotalAllowed;

	internal static int SkyObjectsBlocked;

	internal static int SkyObjectsAllowed;

	public static ConfigEntry<bool> ModEnabled;

	public static ConfigEntry<bool> VerboseLogging;

	public static ConfigEntry<float> SearchRadius;

	public static ConfigEntry<float> TeleportDelay;

	public static ConfigEntry<bool> ShowLoadingMsg;

	public static ConfigEntry<float> SpawnGracePeriod;

	public static ConfigEntry<bool> SkyFilterEnabled;

	public static ConfigEntry<float> SkyThreshold;

	public static ConfigEntry<float> TeleportGracePeriod;

	public static ConfigEntry<float> WorldRadius;

	private void Awake()
	{
		//IL_019c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Expected O, but got Unknown
		//IL_026b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0270: Unknown result type (might be due to invalid IL or missing references)
		//IL_0276: Expected O, but got Unknown
		//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b4: Expected O, but got Unknown
		Instance = this;
		Logger = ((BaseUnityPlugin)this).Logger;
		if (!ServerGuard.Init(this))
		{
			return;
		}
		ModEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Master toggle.");
		VerboseLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "VerboseLogging", false, "Extra logging.");
		GhostChatBypass.PermanentGhostName = ((BaseUnityPlugin)this).Config.Bind<string>("General", "PermanentAI", "Aurora", "Permanent AI player name (server-side AI chat uses this identifier).");
		SearchRadius = ((BaseUnityPlugin)this).Config.Bind<float>("DungeonDeferral", "SearchRadius", 300f, "Max distance from entrance to find deferred dungeon.");
		TeleportDelay = ((BaseUnityPlugin)this).Config.Bind<float>("DungeonDeferral", "TeleportDelay", 2.5f, "Seconds to wait after loading dungeon before teleport.");
		ShowLoadingMsg = ((BaseUnityPlugin)this).Config.Bind<bool>("DungeonDeferral", "ShowLoadingMessage", true, "Show 'Loading dungeon...' message.");
		SpawnGracePeriod = ((BaseUnityPlugin)this).Config.Bind<float>("DungeonDeferral", "SpawnGracePeriod", 2f, "Seconds after login to allow all loading.");
		SkyFilterEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("SkyFilter", "Enabled", true, "Skip creating GameObjects for dungeon interior objects while on surface.");
		SkyThreshold = ((BaseUnityPlugin)this).Config.Bind<float>("SkyFilter", "SkyThresholdY", 1000f, "Objects above this Y are considered dungeon interiors.");
		TeleportGracePeriod = ((BaseUnityPlugin)this).Config.Bind<float>("SkyFilter", "TeleportGracePeriod", 5f, "Seconds after ANY teleport where sky filter is disabled. Prevents loading screen freeze.");
		WorldRadius = ((BaseUnityPlugin)this).Config.Bind<float>("SkyFilter", "WorldRadius", 15000f, "Objects beyond this X/Z distance from world center are never filtered. Set higher than your world radius to protect custom sky zones. Default 15000 covers most Expand World Size configs.");
		_harmony = new Harmony("freyja.AuroraProjectButter");
		Logger.LogInfo((object)"── Dungeon Deferral patches ──");
		ApplyDungeonPatches();
		Logger.LogInfo((object)"── Sky Object Filter patches ──");
		ApplySkyFilterPatches();
		Logger.LogInfo((object)"── Ghost Chat Bypass + Player Injector patches ──");
		try
		{
			_harmony.PatchAll(typeof(Chat_RPC_ChatMessage_GhostPatch));
			Logger.LogInfo((object)"  OK: Chat.RPC_ChatMessage (ghost chat bypass)");
		}
		catch (Exception ex)
		{
			Logger.LogWarning((object)("  FAILED: Chat_RPC_ChatMessage_GhostPatch: " + ex.Message));
		}
		try
		{
			_harmony.PatchAll(typeof(GhostPlayerInjector.ZNet_RPC_PlayerList_Patch));
			Logger.LogInfo((object)"  OK: ZNet.RPC_PlayerList (ghost player injector — F2 menu + map pins)");
		}
		catch (Exception ex2)
		{
			Logger.LogWarning((object)("  FAILED: GhostPlayerInjector.ZNet_RPC_PlayerList_Patch: " + ex2.Message));
		}
		GameObject val = new GameObject("AuroraGhostInjectorPoller");
		Object.DontDestroyOnLoad((Object)val);
		val.AddComponent<GhostPlayerInjector.GhostInjectorMB>();
		Logger.LogInfo((object)"  OK: GhostInjectorMB polling fallback active (checks m_players every 2s)");
		object obj = <>c.<>9__27_0;
		if (obj == null)
		{
			ConsoleEvent val2 = delegate(ConsoleEventArgs args)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				DungeonCleanup();
				Player localPlayer = Player.m_localPlayer;
				float num = ((localPlayer != null) ? ((Component)localPlayer).transform.position.y : float.NaN);
				bool flag = IsPlayerTeleporting();
				bool flag2 = IsInGracePeriod();
				args.Context.AddString("[AuroraProjectButter v1.3.9]");
				args.Context.AddString($"  Dungeon Deferral: {TotalDeferred} deferred, {TotalAllowed} allowed, {Deferred.Count} queued");
				args.Context.AddString($"  Sky Filter: {SkyObjectsBlocked} blocked, {SkyObjectsAllowed} allowed");
				args.Context.AddString($"  Player Y: {num:F1}  Teleporting: {flag}  Grace: {flag2}");
				args.Context.AddString($"  World radius: {WorldRadius.Value}");
			};
			<>c.<>9__27_0 = val2;
			obj = (object)val2;
		}
		new ConsoleCommand("butter_status", "Show AuroraProjectButter stats", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		Logger.LogInfo((object)"=== AuroraProjectButter v1.3.9 loaded ===");
		Logger.LogInfo((object)"  Dungeon Deferral: ON");
		Logger.LogInfo((object)string.Format("  Sky Filter: {0} (Y > {1}, grace {2}s, radius {3})", SkyFilterEnabled.Value ? "ON" : "OFF", SkyThreshold.Value, TeleportGracePeriod.Value, WorldRadius.Value));
	}

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

	internal static bool IsPlayerTeleporting()
	{
		if (IsTeleporting)
		{
			return true;
		}
		if (IsForceLoading)
		{
			return true;
		}
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null)
		{
			return false;
		}
		try
		{
			FieldInfo field = typeof(Player).GetField("m_teleporting", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field != null)
			{
				return (bool)field.GetValue(localPlayer);
			}
		}
		catch
		{
		}
		return false;
	}

	internal static bool IsInGracePeriod()
	{
		float time = Time.time;
		if (PlayerSpawnTime > 0f && time - PlayerSpawnTime < SpawnGracePeriod.Value)
		{
			return true;
		}
		if (TeleportEndTime > 0f && time - TeleportEndTime < TeleportGracePeriod.Value)
		{
			return true;
		}
		return false;
	}

	private void ApplyDungeonPatches()
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Expected O, but got Unknown
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Expected O, but got Unknown
		//IL_017f: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Expected O, but got Unknown
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0251: Expected O, but got Unknown
		//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e5: Expected O, but got Unknown
		//IL_0371: Unknown result type (might be due to invalid IL or missing references)
		//IL_037e: Expected O, but got Unknown
		try
		{
			DG_AwakeMethod = typeof(DungeonGenerator).GetMethod("Awake", BindingFlags.Instance | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			if (DG_AwakeMethod != null)
			{
				_harmony.Patch((MethodBase)DG_AwakeMethod, new HarmonyMethod(typeof(DungeonPatches), "Awake_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Logger.LogInfo((object)"  OK: DungeonGenerator.Awake()");
			}
			else
			{
				Logger.LogError((object)"  FAIL: DungeonGenerator.Awake()");
			}
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"  DG.Awake: {arg}");
		}
		try
		{
			MethodInfo method = typeof(DungeonGenerator).GetMethod("LoadRoomPrefabsAsync", BindingFlags.Instance | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			if (method != null)
			{
				_harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(DungeonPatches), "LoadAsync_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Logger.LogInfo((object)"  OK: LoadRoomPrefabsAsync() (fallback)");
			}
		}
		catch (Exception ex)
		{
			Logger.LogWarning((object)("  LoadAsync: " + ex.Message));
		}
		try
		{
			List<MethodInfo> list = (from m in typeof(DungeonGenerator).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where m.Name == "Generate" && !m.IsAbstract
				select m).ToList();
			MethodInfo method2 = typeof(DungeonPatches).GetMethod("Generate_Prefix", BindingFlags.Static | BindingFlags.Public);
			int num = 0;
			foreach (MethodInfo item in list)
			{
				try
				{
					_harmony.Patch((MethodBase)item, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					num++;
				}
				catch
				{
				}
			}
			Logger.LogInfo((object)$"  OK: {num} Generate overload(s)");
		}
		catch (Exception arg2)
		{
			Logger.LogError((object)$"  Generate: {arg2}");
		}
		try
		{
			MethodInfo methodInfo = typeof(Teleport).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo mi) => mi.Name == "Interact");
			if (methodInfo != null)
			{
				_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(DungeonPatches), "Teleport_Interact_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Logger.LogInfo((object)"  OK: Teleport.Interact");
			}
		}
		catch (Exception arg3)
		{
			Logger.LogError((object)$"  Teleport.Interact: {arg3}");
		}
		try
		{
			MethodInfo methodInfo2 = typeof(Teleport).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo mi) => mi.Name == "HaveTarget");
			if (methodInfo2 != null)
			{
				_harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(DungeonPatches), "HaveTarget_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Logger.LogInfo((object)"  OK: Teleport.HaveTarget");
			}
		}
		catch (Exception ex2)
		{
			Logger.LogWarning((object)("  HaveTarget: " + ex2.Message));
		}
		try
		{
			MethodInfo methodInfo3 = typeof(Player).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo mi) => mi.Name == "OnSpawned");
			if (methodInfo3 != null)
			{
				_harmony.Patch((MethodBase)methodInfo3, (HarmonyMethod)null, new HarmonyMethod(typeof(DungeonPatches), "Player_OnSpawned_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Logger.LogInfo((object)"  OK: Player.OnSpawned");
			}
		}
		catch (Exception ex3)
		{
			Logger.LogWarning((object)("  Player.OnSpawned: " + ex3.Message));
		}
	}

	private void ApplySkyFilterPatches()
	{
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Expected O, but got Unknown
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Expected O, but got Unknown
		if (!SkyFilterEnabled.Value)
		{
			Logger.LogInfo((object)"  Sky Filter DISABLED in config.");
			return;
		}
		try
		{
			List<MethodInfo> list = (from m in typeof(ZNetScene).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where m.Name == "CreateObject" && !m.IsAbstract
				select m).ToList();
			MethodInfo method = typeof(SkyFilterPatches).GetMethod("CreateObject_Prefix", BindingFlags.Static | BindingFlags.Public);
			int num = 0;
			foreach (MethodInfo item in list)
			{
				ParameterInfo[] parameters = item.GetParameters();
				if (parameters.Length >= 1 && parameters[0].ParameterType == typeof(ZDO))
				{
					_harmony.Patch((MethodBase)item, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					string text = string.Join(", ", parameters.Select((ParameterInfo p) => p.ParameterType.Name));
					Logger.LogInfo((object)("  OK: ZNetScene.CreateObject(" + text + ")"));
					num++;
				}
			}
			if (num == 0)
			{
				Logger.LogWarning((object)"  No ZDO-parameter CreateObject found. Trying all overloads...");
				foreach (MethodInfo item2 in list)
				{
					try
					{
						_harmony.Patch((MethodBase)item2, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						num++;
					}
					catch
					{
					}
				}
			}
			if (num == 0)
			{
				Logger.LogError((object)"  FAIL: Could not patch any ZNetScene.CreateObject!");
			}
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"  ZNetScene.CreateObject: {arg}");
		}
	}

	internal static bool ShouldDefer(string caller, Vector3 genPos)
	{
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: 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_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		if (!ModEnabled.Value)
		{
			return false;
		}
		if (IsForceLoading)
		{
			return false;
		}
		if ((Object)(object)Player.m_localPlayer == (Object)null)
		{
			if (VerboseLogging.Value)
			{
				Logger.LogInfo((object)$"[ALLOW:no-player] {caller} at {genPos:F0}");
			}
			TotalAllowed++;
			return false;
		}
		Vector3 position = ((Component)Player.m_localPlayer).transform.position;
		if (IsInGracePeriod())
		{
			if (VerboseLogging.Value)
			{
				Logger.LogInfo((object)$"[ALLOW:grace] {caller} at {genPos:F0}");
			}
			TotalAllowed++;
			return false;
		}
		if (position.y > 1000f)
		{
			if (VerboseLogging.Value)
			{
				Logger.LogInfo((object)$"[ALLOW:in-dungeon] {caller} at {genPos:F0}");
			}
			TotalAllowed++;
			return false;
		}
		if (IsPlayerTeleporting())
		{
			if (VerboseLogging.Value)
			{
				Logger.LogInfo((object)$"[ALLOW:teleporting] {caller} at {genPos:F0}");
			}
			TotalAllowed++;
			return false;
		}
		Logger.LogInfo((object)$"[DEFER] {caller} at {genPos:F0}, player Y={position.y:F0}");
		TotalDeferred++;
		return true;
	}

	internal static void DeferDungeon(DungeonGenerator gen)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: 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)
		Vector3 position = ((Component)gen).transform.position;
		if (!Deferred.Any((DeferredDungeon d) => (Object)(object)d.Generator == (Object)(object)gen))
		{
			Deferred.Add(new DeferredDungeon
			{
				Generator = gen,
				Position = position
			});
		}
	}

	internal static DeferredDungeon? FindNearest(Vector3 origin, float maxDist)
	{
		//IL_0029: 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_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)
		DungeonCleanup();
		DeferredDungeon? result = null;
		float num = float.MaxValue;
		foreach (DeferredDungeon item in Deferred)
		{
			float num2 = item.Position.x - origin.x;
			float num3 = item.Position.z - origin.z;
			float num4 = Mathf.Sqrt(num2 * num2 + num3 * num3);
			if (num4 < maxDist && num4 < num)
			{
				num = num4;
				result = item;
			}
		}
		return result;
	}

	internal static void RemoveDeferred(DungeonGenerator gen)
	{
		Deferred.RemoveAll((DeferredDungeon d) => (Object)(object)d.Generator == (Object)(object)gen || (Object)(object)d.Generator == (Object)null);
	}

	internal static void DungeonCleanup()
	{
		Deferred.RemoveAll((DeferredDungeon d) => (Object)(object)d.Generator == (Object)null);
	}

	internal static void ForceLoadDungeon(DungeonGenerator gen)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		if (DG_AwakeMethod == null)
		{
			Logger.LogError((object)"[REPLAY] No Awake method!");
			return;
		}
		IsForceLoading = true;
		try
		{
			Logger.LogInfo((object)$"[REPLAY] Awake() at {((Component)gen).transform.position:F0}");
			DG_AwakeMethod.Invoke(gen, null);
		}
		finally
		{
			IsForceLoading = false;
		}
	}

	internal static Coroutine RunCoroutine(IEnumerator routine)
	{
		ButterPlugin instance = Instance;
		if (instance == null)
		{
			return null;
		}
		return ((MonoBehaviour)instance).StartCoroutine(routine);
	}
}
internal static class SkyFilterPatches
{
	public static bool CreateObject_Prefix(ZDO __0)
	{
		//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_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: 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_0076: 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)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		if (!ButterPlugin.SkyFilterEnabled.Value)
		{
			return true;
		}
		if (__0 == null)
		{
			return true;
		}
		if ((Object)(object)Player.m_localPlayer == (Object)null)
		{
			return true;
		}
		if (ButterPlugin.IsPlayerTeleporting())
		{
			ButterPlugin.SkyObjectsAllowed++;
			return true;
		}
		if (ButterPlugin.IsInGracePeriod())
		{
			ButterPlugin.SkyObjectsAllowed++;
			return true;
		}
		Vector3 position = __0.GetPosition();
		float y = position.y;
		if (y <= ButterPlugin.SkyThreshold.Value)
		{
			return true;
		}
		float num = Mathf.Sqrt(position.x * position.x + position.z * position.z);
		if (num > ButterPlugin.WorldRadius.Value)
		{
			ButterPlugin.SkyObjectsAllowed++;
			if (ButterPlugin.VerboseLogging.Value)
			{
				ButterPlugin.Logger.LogInfo((object)$"[SkyFilter:ALLOW] Outside world radius: Y={y:F0} dist={num:F0}");
			}
			return true;
		}
		if (((Component)Player.m_localPlayer).transform.position.y > ButterPlugin.SkyThreshold.Value)
		{
			ButterPlugin.SkyObjectsAllowed++;
			return true;
		}
		ButterPlugin.SkyObjectsBlocked++;
		if (ButterPlugin.VerboseLogging.Value && ButterPlugin.SkyObjectsBlocked % 100 == 1)
		{
			ButterPlugin.Logger.LogInfo((object)$"[SkyFilter:BLOCK] #{ButterPlugin.SkyObjectsBlocked} Y={y:F0} dist={num:F0}");
		}
		return false;
	}
}
internal static class DungeonPatches
{
	[CompilerGenerated]
	private sealed class <LoadAndTeleport>d__5 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public ButterPlugin.DeferredDungeon deferred;

		public Teleport teleport;

		public Humanoid character;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (ButterPlugin.ShowLoadingMsg.Value)
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)2, "Loading dungeon...", 0, (Sprite)null);
					}
				}
				ButterPlugin.TeleportEndTime = Time.time;
				<>2__current = null;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if ((Object)(object)deferred.Generator != (Object)null)
				{
					try
					{
						ButterPlugin.ForceLoadDungeon(deferred.Generator);
					}
					catch (Exception arg2)
					{
						ButterPlugin.Logger.LogError((object)$"[OnDemand] Failed: {arg2}");
					}
					ButterPlugin.RemoveDeferred(deferred.Generator);
				}
				<>2__current = (object)new WaitForSeconds(ButterPlugin.TeleportDelay.Value);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				ButterPlugin.TeleportEndTime = Time.time;
				if ((Object)(object)teleport != (Object)null && (Object)(object)character != (Object)null)
				{
					ButterPlugin.IsTeleporting = true;
					try
					{
						teleport.Interact(character, false, false);
					}
					catch (Exception arg)
					{
						ButterPlugin.Logger.LogError((object)$"[OnDemand] Teleport: {arg}");
					}
					finally
					{
						ButterPlugin.IsTeleporting = false;
					}
				}
				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();
		}
	}

	public static void Player_OnSpawned_Postfix(Player __instance)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
		{
			ButterPlugin.PlayerSpawnTime = Time.time;
			ButterPlugin.TeleportEndTime = Time.time;
			ButterPlugin.Logger.LogInfo((object)$"[Spawn] Player at {((Component)__instance).transform.position:F0}");
		}
	}

	public static bool Awake_Prefix(DungeonGenerator __instance)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		if (ButterPlugin.ShouldDefer("Awake", ((Component)__instance).transform.position))
		{
			ButterPlugin.DeferDungeon(__instance);
			return false;
		}
		return true;
	}

	public static bool LoadAsync_Prefix(DungeonGenerator __instance)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		if (ButterPlugin.ShouldDefer("LoadAsync", ((Component)__instance).transform.position))
		{
			ButterPlugin.DeferDungeon(__instance);
			return false;
		}
		return true;
	}

	public static bool Generate_Prefix(DungeonGenerator __instance)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		if (ButterPlugin.ShouldDefer("Generate", ((Component)__instance).transform.position))
		{
			ButterPlugin.DeferDungeon(__instance);
			return false;
		}
		return true;
	}

	public static bool Teleport_Interact_Prefix(Teleport __instance, Humanoid character, bool hold, bool alt)
	{
		//IL_0035: 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_0093: Unknown result type (might be due to invalid IL or missing references)
		if (!ButterPlugin.ModEnabled.Value)
		{
			return true;
		}
		if (ButterPlugin.IsTeleporting)
		{
			return true;
		}
		if ((Object)(object)character != (Object)(object)Player.m_localPlayer)
		{
			return true;
		}
		if (hold)
		{
			return true;
		}
		if (((Component)Player.m_localPlayer).transform.position.y > 1000f)
		{
			ButterPlugin.TeleportEndTime = Time.time;
			return true;
		}
		ButterPlugin.DeferredDungeon? deferredDungeon = ButterPlugin.FindNearest(((Component)__instance).transform.position, ButterPlugin.SearchRadius.Value);
		if (!deferredDungeon.HasValue)
		{
			ButterPlugin.TeleportEndTime = Time.time;
			return true;
		}
		ButterPlugin.Logger.LogInfo((object)$"[OnDemand] Entrance → loading dungeon at {deferredDungeon.Value.Position:F0}");
		ButterPlugin.RunCoroutine(LoadAndTeleport(__instance, deferredDungeon.Value, character));
		return false;
	}

	[IteratorStateMachine(typeof(<LoadAndTeleport>d__5))]
	private static IEnumerator LoadAndTeleport(Teleport teleport, ButterPlugin.DeferredDungeon deferred, Humanoid character)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <LoadAndTeleport>d__5(0)
		{
			teleport = teleport,
			deferred = deferred,
			character = character
		};
	}

	public static void HaveTarget_Postfix(Teleport __instance, ref bool __result)
	{
		//IL_0024: 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)
		if (ButterPlugin.ModEnabled.Value && (!((Object)(object)Player.m_localPlayer != (Object)null) || !(((Component)Player.m_localPlayer).transform.position.y > 1000f)) && !__result && ButterPlugin.FindNearest(((Component)__instance).transform.position, ButterPlugin.SearchRadius.Value).HasValue)
		{
			__result = true;
		}
	}
}
internal static class ServerGuard
{
	private const string PasswordHash = "e7aab22a4200ed38c615552e666633ba96140d314df8e1c00d08b886527a1dd4";

	private const string ConfigSection = "Protection";

	private const string ConfigKey = "password";

	private static ConfigEntry<string> _cfgPassword;

	public static bool Init(ButterPlugin plugin)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Invalid comparison between Unknown and I4
		_cfgPassword = ((BaseUnityPlugin)plugin).Config.Bind<string>("Protection", "password", "enter_password_here", "Server password required to run AuroraProjectButter on a dedicated server. Leave as-is on game clients — this check is ignored there.");
		if ((int)SystemInfo.graphicsDeviceType != 4)
		{
			ManualLogSource logger = ButterPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ServerGuard] Running on client - auth skipped");
			}
			return true;
		}
		if (HashPassword(_cfgPassword.Value?.Trim() ?? string.Empty) == "e7aab22a4200ed38c615552e666633ba96140d314df8e1c00d08b886527a1dd4")
		{
			ManualLogSource logger2 = ButterPlugin.Logger;
			if (logger2 != null)
			{
				logger2.LogInfo((object)"[ServerGuard] Server auth OK.");
			}
			return true;
		}
		ManualLogSource logger3 = ButterPlugin.Logger;
		if (logger3 != null)
		{
			logger3.LogError((object)"══════════════════════════════════════════════════\n  INVALID PASSWORD — AuroraProjectButter will not load.\n  Set the correct password in:\n  BepInEx/config/freyja.AuroraProjectButter.cfg\n  under [Protection] > password\n══════════════════════════════════════════════════");
		}
		return false;
	}

	private static string HashPassword(string input)
	{
		using SHA256 sHA = SHA256.Create();
		byte[] bytes = Encoding.UTF8.GetBytes(input);
		byte[] array = sHA.ComputeHash(bytes);
		StringBuilder stringBuilder = new StringBuilder(64);
		byte[] array2 = array;
		foreach (byte b in array2)
		{
			stringBuilder.Append(b.ToString("x2"));
		}
		return stringBuilder.ToString();
	}
}