using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using Darkbound.Commands;
using Darkbound.Components;
using Darkbound.DarkEffects;
using Darkbound.DarkPieces;
using Darkbound.DarkPieces.DarkBeacons;
using Darkbound.DarkPieces.Necromes;
using Darkbound.DarkPieces.PlacementRestrictions;
using Darkbound.DarkPieces.Sentinels.Managers;
using Darkbound.DarkSigns;
using Darkbound.HUD;
using Darkbound.Items;
using Darkbound.Items.ArmorAndClothing;
using Darkbound.Items.ArmorAndClothing.Capes;
using Darkbound.Items.ArmorAndClothing.Hoods;
using Darkbound.Items.ArmorAndClothing.Robes;
using Darkbound.Items.Components;
using Darkbound.Items.Cores;
using Darkbound.Items.DurabilityStones;
using Darkbound.Items.EssencePotions;
using Darkbound.Items.SummoningCrystals;
using Darkbound.Items.Talismans;
using Darkbound.Localizations;
using Darkbound.OdinRunestones;
using Darkbound.Patches;
using Darkbound.Summons;
using Darkbound.Summons.DarkTagComponents;
using Darkbound.Summons.SpecialSpawns;
using Darkbound.Utilities;
using Darkbound.Utilities.Accessories;
using Darkbound.Utilities.ConsoleCommands;
using Darkbound.Utilities.NameGenerators;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.Win32;
using Newtonsoft.Json;
using TMPro;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Darkbound")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Darkbound")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3579ed80-e9f8-44e0-a3c8-872d9f7d9e2c")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
public class SmokePrefabGenerator : MonoBehaviour
{
	public static GameObject CreateSmokePrefab()
	{
		//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_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)
		//IL_0043: 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_0065: 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_0087: 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_00b2: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: 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_0115: 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_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Expected O, but got Unknown
		GameObject val = new GameObject("SmokeEffect");
		ParticleSystem obj = val.AddComponent<ParticleSystem>();
		MainModule main = obj.main;
		((MainModule)(ref main)).duration = 5f;
		((MainModule)(ref main)).loop = true;
		((MainModule)(ref main)).startLifetime = MinMaxCurve.op_Implicit(3f);
		((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(1f);
		((MainModule)(ref main)).startSpeed = MinMaxCurve.op_Implicit(0.5f);
		((MainModule)(ref main)).startRotation = MinMaxCurve.op_Implicit(0f);
		((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(Color.gray);
		((MainModule)(ref main)).gravityModifier = MinMaxCurve.op_Implicit(0f);
		ParticleSystemRenderer component = ((Component)obj).GetComponent<ParticleSystemRenderer>();
		component.renderMode = (ParticleSystemRenderMode)0;
		((Renderer)component).material = new Material(Shader.Find("Particles/Standard Unlit"));
		ColorOverLifetimeModule colorOverLifetime = obj.colorOverLifetime;
		((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
		((ColorOverLifetimeModule)(ref colorOverLifetime)).color = new MinMaxGradient(Color.white, Color.black);
		SizeOverLifetimeModule sizeOverLifetime = obj.sizeOverLifetime;
		((SizeOverLifetimeModule)(ref sizeOverLifetime)).enabled = true;
		((SizeOverLifetimeModule)(ref sizeOverLifetime)).size = new MinMaxCurve(1f, AnimationCurve.Linear(0f, 1f, 1f, 0f));
		VelocityOverLifetimeModule velocityOverLifetime = obj.velocityOverLifetime;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).enabled = true;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).x = MinMaxCurve.op_Implicit(0f);
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).y = MinMaxCurve.op_Implicit(0.5f);
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).z = MinMaxCurve.op_Implicit(0f);
		return val;
	}
}
public class DebugPointerHandler : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler
{
	public void OnPointerEnter(PointerEventData eventData)
	{
		Debug.Log((object)("[DEBUG] Pointer entered: " + ((Object)((Component)this).gameObject).name));
	}
}
[BepInPlugin("com.robfrancis.darkbound", "Darkbound", "0.1.008")]
public class DarkboundPlugin : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <ClearMistAroundPlayer>d__28 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Player player;

		public float radius;

		public float interval;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//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_005f: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			case 2:
				<>1__state = -1;
				break;
			}
			if (NecromancerAltar.HasNecromancerLeggingsEquipped(player))
			{
				Vector3 position = ((Component)player).transform.position;
				List<Mister> list = new List<Mister>();
				foreach (Mister mister in Mister.GetMisters())
				{
					if (Vector3.Distance(position, ((Component)mister).transform.position) < radius)
					{
						list.Add(mister);
					}
				}
				foreach (Mister item in list)
				{
					((Component)item).gameObject.SetActive(false);
				}
				<>2__current = (object)new WaitForSeconds(interval);
				<>1__state = 1;
				return true;
			}
			<>2__current = (object)new WaitForSeconds(interval * 30f);
			<>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 <DarkboundPlayerSetup>d__21 : 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 <DarkboundPlayerSetup>d__21(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

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

		private bool MoveNext()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer3;
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				goto IL_0044;
			case 1:
				<>1__state = -1;
				goto IL_0044;
			case 2:
				{
					<>1__state = -1;
					DarkboundHelpers.AttachAttackCommandToPlayer();
					DarkboundHelpers.AttachEssencePotionCommandToPlayer();
					DarkboundHelpers.AttachEquipUtilityCommandToPlayer();
					DarkboundHelpers.AttachNecromancerToPlayer();
					DarkboundHelpers.AttachSummonsHudToPlayer();
					DarkboundHelpers.AttachNecroplasmHudToPlayer();
					DarkboundHelpers.AttachAnimalCooldownHudToPlayer();
					DarkboundHelpers.AttachDarkboundInventoryToPlayer();
					DarkboundHelpers.AttachWraithlightToPlayer();
					DarkboundHelpers.AttachMerchantRingToPlayer();
					PlayerPrefsDataManager.LoadNecromancerData();
					OdinDailyGiftSystem.Init();
					_ = DarkboundInventory.darkboundInventory;
					Player localPlayer = Player.m_localPlayer;
					((Character)localPlayer).m_onDamaged = (Action<float, Character>)Delegate.Remove(((Character)localPlayer).m_onDamaged, new Action<float, Character>(DamageTakenCommand.DamageRedirect));
					Player localPlayer2 = Player.m_localPlayer;
					((Character)localPlayer2).m_onDamaged = (Action<float, Character>)Delegate.Combine(((Character)localPlayer2).m_onDamaged, new Action<float, Character>(DamageTakenCommand.DamageRedirect));
					return false;
				}
				IL_0044:
				if ((Object)(object)Player.m_localPlayer == (Object)null || ((Character)Player.m_localPlayer).InIntro() || ((Character)Player.m_localPlayer).IsDead())
				{
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				}
				localPlayer3 = Player.m_localPlayer;
				if ((Object)(object)localPlayer3 != (Object)null)
				{
					localPlayer3.GetPlayerID();
					localPlayer3.GetPlayerName();
					localPlayer3.GetPlayerModel();
					((Character)localPlayer3).GetZDOID();
				}
				<>2__current = (object)new WaitForSeconds(1f);
				<>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 <UpdateElementsOccasionally>d__29 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public DarkboundPlugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			int num = <>1__state;
			DarkboundPlugin darkboundPlugin = <>4__this;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
			}
			else
			{
				<>1__state = -1;
			}
			darkboundPlugin.UpdateElements();
			<>2__current = (object)new WaitForSeconds(10f);
			<>1__state = 1;
			return true;
		}

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

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

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

		private object <>2__current;

		public DarkboundPlugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			int num = <>1__state;
			DarkboundPlugin darkboundPlugin = <>4__this;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
			}
			else
			{
				<>1__state = -1;
			}
			darkboundPlugin.UpdateEquipment();
			<>2__current = (object)new WaitForSeconds(5f);
			<>1__state = 1;
			return true;
		}

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

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

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

		private object <>2__current;

		public DarkboundPlugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			int num = <>1__state;
			DarkboundPlugin darkboundPlugin = <>4__this;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
			}
			else
			{
				<>1__state = -1;
			}
			darkboundPlugin.UpdateSummonsCount();
			<>2__current = (object)new WaitForSeconds(2f);
			<>1__state = 1;
			return true;
		}

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

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

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

		private object <>2__current;

		public float delay;

		public string sceneName;

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

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

		[DebuggerHidden]
		public <WaitAndReplaceLogo>d__12(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_0028: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(delay);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				DarkboundLogo.ReplaceMenuLogo(sceneName);
				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 bool isCoreInitialized;

	private bool areVanillaPrefabsAvailable;

	private bool areVanillaCreaturesAvailable;

	private Harmony _harmony;

	public static GameObject GlobalChestOfForgottenSouls;

	private static DateTime _lastCleanupTimeA = DateTime.MinValue;

	private static DateTime _lastCleanupTimeB = DateTime.MinValue;

	private float elementUpdateTimer;

	private void Awake()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		InitializeCore();
		HookRegularEvents();
		HookJotunnEvents();
		_harmony = new Harmony("com.robfrancis.darkbound");
		_harmony.PatchAll();
		new GameObject("DarkboundDayNightManager").AddComponent<DarkboundDayNight>();
	}

	private void InitializeCore()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		RegisterLocalizations();
		NecromancySkill.Initialize();
		DarkboundColor.NecromancerColor = DarkboundColor.NothingGrey;
		new RegisterConsoleCommands().CreateConsoleCommands();
		isCoreInitialized = true;
	}

	private void HookRegularEvents()
	{
		SceneManager.sceneLoaded += OnSceneLoaded;
	}

	private void HookJotunnEvents()
	{
		PrefabManager.OnVanillaPrefabsAvailable += OnVanillaPrefabsAvailable;
		CreatureManager.OnVanillaCreaturesAvailable += OnVanillaCreaturesAvailable;
	}

	private void OnVanillaPrefabsAvailable()
	{
		areVanillaPrefabsAvailable = true;
		TryInitializeGameElements();
	}

	private void OnVanillaCreaturesAvailable()
	{
		areVanillaCreaturesAvailable = true;
		TryInitializeGameElements();
	}

	private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
	{
		if (((Scene)(ref scene)).name == "loading" || ((Scene)(ref scene)).name == "start")
		{
			((MonoBehaviour)this).StartCoroutine(WaitAndReplaceLogo(((Scene)(ref scene)).name, 1f));
		}
		else if (((Scene)(ref scene)).name == "main")
		{
			((MonoBehaviour)this).StartCoroutine(WaitAndReplaceLogo(((Scene)(ref scene)).name, 0f));
			((MonoBehaviour)this).StartCoroutine(DarkboundPlayerSetup());
			InitializeHUDs();
		}
	}

	[IteratorStateMachine(typeof(<WaitAndReplaceLogo>d__12))]
	private IEnumerator WaitAndReplaceLogo(string sceneName, float delay)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <WaitAndReplaceLogo>d__12(0)
		{
			sceneName = sceneName,
			delay = delay
		};
	}

	private void TryInitializeGameElements()
	{
		if (isCoreInitialized && areVanillaPrefabsAvailable && areVanillaCreaturesAvailable)
		{
			DarkboundRegistrations.RegisterAll();
			PrefabManager.OnVanillaPrefabsAvailable -= OnVanillaPrefabsAvailable;
			CreatureManager.OnVanillaCreaturesAvailable -= OnVanillaCreaturesAvailable;
		}
	}

	private void InitializeHUDs()
	{
		((MonoBehaviour)this).StartCoroutine(UpdateSummonsCountPeriodically());
		((MonoBehaviour)this).StartCoroutine(UpdateElementsOccasionally());
		((MonoBehaviour)this).StartCoroutine(UpdateEquipmentOccasionally());
	}

	private void Start()
	{
		((MonoBehaviour)this).InvokeRepeating("AddPlayerComponent", 0f, 2f);
	}

	private void AddPlayerComponent()
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		Player localPlayer = Player.m_localPlayer;
		if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)((Component)localPlayer).gameObject == (Object)null))
		{
			CleanUpInvalidTameSummons();
			CleanUpInvalidTameSkeletons();
			if (!((Object)(object)((Component)localPlayer).gameObject.GetComponent<AttackCommand>() != (Object)null))
			{
				((Component)localPlayer).gameObject.AddComponent<AttackCommand>();
				DarkboundColor.NecromancerColor = DarkboundColor.LoadNecromancerColor();
				SpectralChestComponent.CleanOrphanedChests();
			}
		}
	}

	private void CleanUpInvalidTameSummons()
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		if ((DateTime.Now - _lastCleanupTimeA).TotalSeconds < 30.0)
		{
			return;
		}
		_lastCleanupTimeA = DateTime.Now;
		float num = 100f;
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null)
		{
			return;
		}
		Collider[] array = Physics.OverlapSphere(((Component)localPlayer).transform.position, num);
		for (int i = 0; i < array.Length; i++)
		{
			Character component = ((Component)array[i]).GetComponent<Character>();
			if (!((Object)(object)component == (Object)null) && component.IsTamed())
			{
				SummonIdentifier component2 = ((Component)component).GetComponent<SummonIdentifier>();
				Tameable component3 = ((Component)component).GetComponent<Tameable>();
				MonsterAI component4 = ((Component)component).GetComponent<MonsterAI>();
				if ((Object)(object)component2 == (Object)null || (Object)(object)component3 == (Object)null || (Object)(object)component4 == (Object)null)
				{
					component.m_health = 0f;
					DarkboundDeath.DeathByDamage(component);
				}
			}
		}
	}

	private void CleanUpInvalidTameSkeletons()
	{
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Invalid comparison between Unknown and I4
		DateTime now = DateTime.Now;
		if ((now - _lastCleanupTimeB).TotalSeconds < 30.0)
		{
			return;
		}
		_lastCleanupTimeB = now;
		float num = 200f;
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null)
		{
			Logger.LogWarning((object)"[CleanUpInvalidTameSkeletons] Player is null");
			return;
		}
		Transform transform = ((Component)localPlayer).transform;
		if ((Object)(object)localPlayer == (Object)null)
		{
			Logger.LogWarning((object)"[CleanUpInvalidTameSkeletons] Player Transform is null");
			return;
		}
		Vector3 position = transform.position;
		Character component = ((Component)localPlayer).GetComponent<Character>();
		Collider[] array = Physics.OverlapSphere(position, num, LayerMask.GetMask(new string[1] { "character" }));
		for (int i = 0; i < array.Length; i++)
		{
			Character component2 = ((Component)array[i]).GetComponent<Character>();
			if (!((Object)(object)component2 == (Object)null) && !((Object)(object)component2 == (Object)(object)component))
			{
				if (!((Component)component2).gameObject.activeInHierarchy)
				{
					Logger.LogWarning((object)"[CleanUpInvalidTameSkeletons] Character is INACTIVE");
				}
				else if (component2.IsTamed() && ((Behaviour)component2).isActiveAndEnabled && (int)component2.m_faction != 11 && (((Object)component2).name.ToLower() == "skeleton(clone)" || component2.m_name.ToLower() == "$enemy_skeleton"))
				{
					component2.m_health = 0f;
					DarkboundDeath.DeathByDamage(component2);
					Logger.LogError((object)"[CleanUpInvalidTameSkeletons] Skeleton TERMINATED");
				}
			}
		}
	}

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

	private void RegisterLocalizations()
	{
		new LocalizationHandler().RegisterLocalizations();
	}

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

	private void UpdateSummonsCount()
	{
		if (!((Object)(object)Player.m_localPlayer == (Object)null))
		{
			((Component)Player.m_localPlayer).GetComponent<DarkboundNecromancer>()?.CheckForPriorSummons();
		}
	}

	private void OnDestroy()
	{
		PrefabManager.OnVanillaPrefabsAvailable -= OnVanillaPrefabsAvailable;
		CreatureManager.OnVanillaCreaturesAvailable -= OnVanillaCreaturesAvailable;
		Harmony harmony = _harmony;
		if (harmony != null)
		{
			harmony.UnpatchAll((string)null);
		}
	}

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

	private void UpdateEquipment()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Invalid comparison between Unknown and I4
		Player localPlayer = Player.m_localPlayer;
		if (!((Object)(object)localPlayer == (Object)null) && (int)localPlayer.GetCurrentBiome() == 512 && NecromancerAltar.HasNecromancerLeggingsEquipped(Player.m_localPlayer) && PlayerPrefsDataManager.LoadBool(PlayerPrefsDataManager.GenerateKey("NECROMANCER_WISPLIGHT")))
		{
			((MonoBehaviour)this).StartCoroutine(ClearMistAroundPlayer(Player.m_localPlayer, 36f, 0.6f));
		}
	}

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

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

	private void Update()
	{
		DarkboundKeyPress.CheckKeys();
		if ((Object)(object)Player.m_localPlayer != (Object)null)
		{
			((Character)Player.m_localPlayer).IsTeleporting();
			if (((Character)Player.m_localPlayer).IsDead())
			{
				SummonsHUD component = ((Component)Player.m_localPlayer).GetComponent<SummonsHUD>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				AnimalCooldownHUD component2 = ((Component)Player.m_localPlayer).GetComponent<AnimalCooldownHUD>();
				if ((Object)(object)component2 != (Object)null)
				{
					Object.Destroy((Object)(object)component2);
				}
				NecroplasmHUD component3 = ((Component)Player.m_localPlayer).GetComponent<NecroplasmHUD>();
				if ((Object)(object)component3 != (Object)null)
				{
					Object.Destroy((Object)(object)component3);
				}
				((MonoBehaviour)this).StartCoroutine(DarkboundPlayerSetup());
			}
		}
		elementUpdateTimer += Time.deltaTime;
		if (elementUpdateTimer >= 10f)
		{
			elementUpdateTimer = 0f;
			UpdateElements();
		}
	}

	private void UpdateElements()
	{
		if (DarkboundSceneUtility.IsScene(DarkboundSceneUtility.GameScenes.Main) && !((Object)(object)Player.m_localPlayer == (Object)null) && !((Character)Player.m_localPlayer).InIntro() && !Player.m_localPlayer.IsSleeping())
		{
			RenameSummonsCommand.CommandAllRename();
		}
	}
}
namespace Darkbound
{
	public static class NecromancerSacrificeTrigger
	{
		private static readonly string itemName = "$item_necromancersacrificetrigger";

		private static readonly string basePrefab = "StaffSkeleton";

		private static readonly string iconResourceName = "Darkbound.Assets.Icons.skull-purple.png";

		public static void RegisterItem()
		{
			//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_0036: 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_005b: 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_006e: 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: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: 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_012d: 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_0145: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			if (ItemManager.Instance.GetItem(itemName) != null)
			{
				Logger.LogWarning((object)(itemName + " already exists, skipping registration."));
				return;
			}
			ItemConfig val = new ItemConfig
			{
				Name = itemName,
				Description = itemName + "_desc",
				Icon = DarkboundIcon.GetIconFromResourceAsSprite(iconResourceName),
				StackSize = 100,
				CraftingStation = "$piece_crystalworkbench",
				MinStationLevel = 1,
				Weight = 0.01f
			};
			val.AddRequirement(new RequirementConfig("TrophySkeleton", 1, 0, true));
			val.AddRequirement(new RequirementConfig("BoneFragments", 10, 0, true));
			CustomItem val2 = new CustomItem(itemName, basePrefab, val);
			GameObject itemPrefab = val2.ItemPrefab;
			if ((Object)(object)itemPrefab != (Object)null)
			{
				ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null)
				{
					Logger.LogError((object)"ItemDrop component is missing!");
					return;
				}
				Attack attack = new Attack
				{
					m_attackType = (AttackType)3,
					m_attackAnimation = "staff_fireball",
					m_attackProjectile = null,
					m_burstInterval = 0f,
					m_cantUseInDungeon = true,
					m_reloadEitrDrain = 0f,
					m_drawEitrDrain = 0f,
					m_attackEitr = 0f,
					m_attackStamina = 0f
				};
				component.m_itemData.m_shared.m_attack = attack;
				component.m_itemData.m_shared.m_animationState = (AnimationState)14;
				component.m_itemData.m_shared.m_useDurability = false;
				component.m_itemData.m_shared.m_itemType = (ItemType)22;
				ItemManager.Instance.AddItem(val2);
			}
			else
			{
				Logger.LogError((object)("Failed to load base prefab '" + basePrefab + "' for " + itemName + "."));
			}
		}

		public static bool HandleSacrifice()
		{
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			foreach (ItemData equippedItem in inventory.GetEquippedItems())
			{
				if (equippedItem.m_shared.m_name == "$item_necromancersacrificetrigger")
				{
					if (equippedItem.m_stack == 0)
					{
						((Humanoid)Player.m_localPlayer).UnequipItem(equippedItem, true);
						inventory.RemoveItem(equippedItem);
						MessageHud.instance.ShowMessage((MessageType)2, "No " + equippedItem.m_shared.m_name + " remaining", 0, (Sprite)null, false);
						return false;
					}
					GameObject val = FindNearbyNecromancerAltar();
					if ((Object)(object)val == (Object)null)
					{
						Logger.LogError((object)"NECROMANCER_SACRIFICE: No altar found within range.");
						MessageHud.instance.ShowMessage((MessageType)2, "No necromancer sacrifice altar nearby", 0, (Sprite)null, false);
						return false;
					}
					Container component = val.GetComponent<Container>();
					if ((Object)(object)component == (Object)null)
					{
						Logger.LogError((object)"NECROMANCER_SACRIFICE: Container component not found on altar!");
						MessageHud.instance.ShowMessage((MessageType)2, "You insult the undead", 0, (Sprite)null, false);
						return false;
					}
					if (!NecromancerAltar.ProcessAltarContents(component))
					{
						MessageHud.instance.ShowMessage((MessageType)2, "No sacrifice made", 0, (Sprite)null, false);
						return false;
					}
					MessageHud.instance.ShowMessage((MessageType)2, "Sacrifice made", 0, (Sprite)null, false);
					SignNecromancerAltarStats component2 = val.GetComponent<SignNecromancerAltarStats>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.UpdateSignStats();
					}
					RefreshNecromancerGear();
					inventory.RemoveOneItem(equippedItem);
					if (equippedItem.m_stack == 0)
					{
						((Humanoid)Player.m_localPlayer).UnequipItem(equippedItem, true);
						inventory.RemoveItem(equippedItem);
					}
					return true;
				}
			}
			return false;
		}

		private static GameObject FindNearbyNecromancerAltar()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_005a: 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)
			Vector3 val = DarkboundHelpers.PlayerPosition();
			float num = 5f;
			Collider[] array = Physics.OverlapSphere(val, num);
			if (array == null)
			{
				Logger.LogWarning((object)"[FindNearbyNecromancerAltar] colliders is null!");
				return null;
			}
			if (array.Length == 0)
			{
				Logger.LogWarning((object)"[FindNearbyNecromancerAltar] No colliders found!");
				return null;
			}
			GameObject val2 = null;
			float num2 = float.PositiveInfinity;
			Collider[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				NecromancerAltar.DarkboundNecromancerAltar componentInParent = ((Component)array2[i]).GetComponentInParent<NecromancerAltar.DarkboundNecromancerAltar>();
				if (!((Object)(object)componentInParent == (Object)null))
				{
					float num3 = Vector3.Distance(val, ((Component)componentInParent).gameObject.transform.position);
					if (num3 < num2)
					{
						num2 = num3;
						val2 = ((Component)componentInParent).gameObject;
					}
				}
			}
			if (!((Object)(object)val2 != (Object)null))
			{
				Logger.LogWarning((object)"[FindNearbyNecromancerAltar] No matching altar found!");
			}
			return val2;
		}

		private static void RefreshNecromancerGear()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead())
			{
				return;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			string[] array = new string[4] { "$item_necromancerhood", "$item_necromancerrobes", "$item_necromancerleggings", "$item_necromancercape" };
			foreach (string itemName in array)
			{
				ItemData val = inventory.GetEquippedItems().Find((ItemData i) => i.m_shared.m_name == itemName);
				if (val != null)
				{
					((Humanoid)localPlayer).UnequipItem(val, false);
					((Humanoid)localPlayer).EquipItem(val, false);
				}
			}
		}
	}
	public static class SkeletalSacrificeTrigger
	{
		public static readonly string displayName = "Skeletal Sacrifice Trigger";

		private static readonly string itemName = "SkeletalSacrificeTrigger";

		private static readonly string basePrefab = "StaffSkeleton";

		private static readonly string iconResourceName = "Darkbound.Assets.Icons.skull-red.png";

		public static void RegisterItem()
		{
			//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_0036: 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_0051: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: 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)
			//IL_015b: 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_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: 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_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			if (ItemManager.Instance.GetItem(itemName) != null)
			{
				Logger.LogWarning((object)(itemName + " already exists, skipping registration."));
				return;
			}
			ItemConfig val = new ItemConfig
			{
				Name = displayName,
				Description = "Consumed during ritual by the Skeleton Sacrifice Altar",
				Icon = DarkboundIcon.GetIconFromResourceAsSprite(iconResourceName),
				StackSize = 10,
				CraftingStation = "$piece_crystalworkbench",
				MinStationLevel = 1,
				Weight = 0.01f
			};
			val.AddRequirement(new RequirementConfig("TrophySkeleton", 5, 0, true));
			val.AddRequirement(new RequirementConfig("BoneFragments", 100, 0, true));
			val.AddRequirement(new RequirementConfig("Raspberry", 50, 0, true));
			val.AddRequirement(new RequirementConfig("Honey", 50, 0, true));
			val.AddRequirement(new RequirementConfig("AncientSeed", 5, 0, true));
			val.AddRequirement(new RequirementConfig("BeechSeeds", 10, 0, true));
			val.AddRequirement(new RequirementConfig("GreydwarfEye", 10, 0, true));
			val.AddRequirement(new RequirementConfig("Coins", 10, 0, true));
			CustomItem val2 = new CustomItem(itemName, basePrefab, val);
			GameObject itemPrefab = val2.ItemPrefab;
			if ((Object)(object)itemPrefab != (Object)null)
			{
				ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null)
				{
					Logger.LogError((object)"ItemDrop component is missing!");
					return;
				}
				Attack attack = new Attack
				{
					m_attackType = (AttackType)3,
					m_attackAnimation = "staff_summon",
					m_attackProjectile = null,
					m_burstInterval = 0f,
					m_cantUseInDungeon = true,
					m_reloadEitrDrain = 0f,
					m_drawEitrDrain = 0f,
					m_attackEitr = 0f,
					m_attackStamina = 0f
				};
				component.m_itemData.m_shared.m_attack = attack;
				component.m_itemData.m_shared.m_animationState = (AnimationState)14;
				component.m_itemData.m_shared.m_useDurability = false;
				component.m_itemData.m_shared.m_itemType = (ItemType)22;
				ItemManager.Instance.AddItem(val2);
			}
			else
			{
				Logger.LogError((object)("Failed to load base prefab '" + basePrefab + "' for " + itemName + "."));
			}
		}

		public static bool HandleSacrifice()
		{
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			foreach (ItemData equippedItem in inventory.GetEquippedItems())
			{
				if (equippedItem.m_shared.m_name == displayName)
				{
					if (equippedItem.m_stack == 0)
					{
						inventory.RemoveItem(equippedItem);
						MessageHud.instance.ShowMessage((MessageType)2, "No " + displayName + " remaining", 0, (Sprite)null, false);
						return false;
					}
					GameObject val = FindNearbySkeletonAltar();
					if ((Object)(object)val == (Object)null)
					{
						MessageHud.instance.ShowMessage((MessageType)2, "No skeleton sacrifice altar nearby", 0, (Sprite)null, false);
						return false;
					}
					Container component = val.GetComponent<Container>();
					if ((Object)(object)component == (Object)null)
					{
						MessageHud.instance.ShowMessage((MessageType)2, "You insult the undead", 0, (Sprite)null, false);
						return false;
					}
					if (!SkeletonAltar.ProcessAltarContents(component))
					{
						MessageHud.instance.ShowMessage((MessageType)2, "No sacrifice made", 0, (Sprite)null, false);
						return false;
					}
					MessageHud.instance.ShowMessage((MessageType)2, "Sacrifice made", 0, (Sprite)null, false);
					SignSkeletonAltarStats component2 = val.GetComponent<SignSkeletonAltarStats>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.UpdateSignStats();
					}
					inventory.RemoveOneItem(equippedItem);
					if (equippedItem.m_stack == 0)
					{
						inventory.RemoveItem(equippedItem);
					}
					return true;
				}
			}
			return false;
		}

		private static GameObject FindNearbySkeletonAltar()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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)
			Vector3 val = DarkboundHelpers.PlayerPosition();
			float num = 5f;
			List<Piece> list = new List<Piece>();
			Piece.GetAllPiecesInRadius(val, num, list);
			GameObject result = null;
			float num2 = float.PositiveInfinity;
			foreach (Piece item in list)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				SkeletonAltar.DarkboundSkeletonAltar componentInParent = ((Component)item).GetComponentInParent<SkeletonAltar.DarkboundSkeletonAltar>();
				if (!((Object)(object)componentInParent == (Object)null))
				{
					float num3 = Vector3.Distance(val, ((Component)componentInParent).gameObject.transform.position);
					if (num3 < num2)
					{
						num2 = num3;
						result = ((Component)componentInParent).gameObject;
					}
				}
			}
			return result;
		}
	}
}
namespace Darkbound.Utilities
{
	public class ChestOfForgottenSoulsManager : MonoBehaviour
	{
		private Dictionary<string, int> itemQuantities = new Dictionary<string, int>();

		public static ChestOfForgottenSoulsManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		public void AddItem(string prefabName, int amount)
		{
			if (itemQuantities.ContainsKey(prefabName))
			{
				itemQuantities[prefabName] += amount;
			}
			else
			{
				itemQuantities[prefabName] = amount;
			}
		}

		public bool RemoveItem(string prefabName, int amount)
		{
			if (!itemQuantities.TryGetValue(prefabName, out var value) || value < amount)
			{
				return false;
			}
			itemQuantities[prefabName] -= amount;
			if (itemQuantities[prefabName] <= 0)
			{
				itemQuantities.Remove(prefabName);
			}
			return true;
		}

		public int GetItemCount(string prefabName)
		{
			if (!itemQuantities.TryGetValue(prefabName, out var value))
			{
				return 0;
			}
			return value;
		}

		public Dictionary<string, int> GetAllItems()
		{
			return new Dictionary<string, int>(itemQuantities);
		}
	}
	public class CoroutineRunner : MonoBehaviour
	{
		private static CoroutineRunner _instance;

		public static CoroutineRunner Instance
		{
			get
			{
				//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)
				//IL_0027: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("CoroutineRunner (Darkbound)");
					_instance = val.AddComponent<CoroutineRunner>();
					Object.DontDestroyOnLoad((Object)val);
				}
				return _instance;
			}
		}
	}
	public class DarkboundCharacters
	{
		public static void ResetCharacterGroup(GameObject summonObject, string group)
		{
			ResetCharacterGroup(summonObject.GetComponent<Character>(), group);
		}

		public static void ResetCharacterGroup(Character characterComponent, string group)
		{
			if ((Object)(object)characterComponent != (Object)null)
			{
				characterComponent.m_group = group;
			}
		}

		public static void ResetCharacterFaction(GameObject summonObject, Faction faction)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ResetCharacterFaction(summonObject.GetComponent<Character>(), faction);
		}

		public static void ResetCharacterFaction(Character characterComponent, Faction faction)
		{
			//IL_000a: 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)
			if ((Object)(object)characterComponent != (Object)null)
			{
				characterComponent.m_faction = faction;
			}
		}

		public static void SetCreatureStars(GameObject summonObject, int stars)
		{
			SetCreatureStars(summonObject.GetComponent<Character>(), stars);
		}

		public static void SetCreatureStars(Character creatureComponent, int stars)
		{
			if ((Object)(object)creatureComponent != (Object)null)
			{
				stars = Mathf.Clamp(stars, 0, 9);
				creatureComponent.SetLevel(stars);
			}
		}

		public static void IncreaseCreatureStars(GameObject summonObject)
		{
			Character component = summonObject.GetComponent<Character>();
			if ((Object)(object)component != (Object)null)
			{
				int level = component.GetLevel();
				SetCreatureStars(component, level + 1);
			}
		}

		public static void DecreaseCreatureStars(GameObject summonObject)
		{
			Character component = summonObject.GetComponent<Character>();
			if ((Object)(object)component != (Object)null)
			{
				int level = component.GetLevel();
				SetCreatureStars(component, level - 1);
			}
		}

		public static List<Character> GetNearbySummons()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			List<Character> list = new List<Character>();
			Player localPlayer = Player.m_localPlayer;
			Character val = ((localPlayer != null) ? ((Component)localPlayer).GetComponent<Character>() : null);
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogWarning((object)"Local player character not found.");
				return list;
			}
			Vector3 position = ((Component)val).transform.position;
			float num = 80f;
			Collider[] array = Physics.OverlapSphere(position, num, LayerMask.GetMask(new string[1] { "character" }));
			for (int i = 0; i < array.Length; i++)
			{
				Character component = ((Component)array[i]).GetComponent<Character>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)component == (Object)(object)val) && ((Component)component).gameObject.activeInHierarchy && !((Object)(object)((Component)component).GetComponent<SummonIdentifier>() == (Object)null) && IsSummonedByLocalPlayer(component))
				{
					list.Add(component);
				}
			}
			return list;
		}

		public static Character GetCharacterWithLowestHealth()
		{
			Character result = null;
			float num = float.MaxValue;
			List<Character> nearbySummons = GetNearbySummons();
			if (nearbySummons == null || nearbySummons.Count == 0)
			{
				return null;
			}
			foreach (Character item in nearbySummons)
			{
				SummonIdentifier component = ((Component)item).GetComponent<SummonIdentifier>();
				if (!((Object)(object)component == (Object)null) && !component.IsSentinel() && IsSummonedByLocalPlayer(item) && item.m_health < num)
				{
					num = item.m_health;
					result = item;
				}
			}
			return result;
		}

		public static bool IsSummonedByLocalPlayer(Character character)
		{
			//IL_0030: 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)
			ZNetView component = ((Component)character).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			ZDOID zDOID = ((Character)localPlayer).GetZDOID();
			return zDO.GetOwner() == ((ZDOID)(ref zDOID)).UserID;
		}
	}
	public class DarkboundDayNight : MonoBehaviour
	{
		public enum TimeMode
		{
			Unknown,
			Day,
			Night
		}

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

			private object <>2__current;

			public DarkboundDayNight <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Expected O, but got Unknown
				int num = <>1__state;
				DarkboundDayNight darkboundDayNight = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					darkboundDayNight.UpdateAllCharactersHealth();
				}
				else
				{
					<>1__state = -1;
				}
				darkboundDayNight.SetTimeMode();
				<>2__current = (object)new WaitForSeconds(30f);
				<>1__state = 1;
				return true;
			}

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

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

		private TimeMode m_Mode;

		private bool _started;

		public static DarkboundDayNight Instance { get; private set; }

		public static event Action OnDawn;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void Start()
		{
			if (!_started)
			{
				_started = true;
				((MonoBehaviour)this).StartCoroutine(CheckDayNightRoutine());
			}
		}

		public static bool IsNightTime()
		{
			EnvMan instance = EnvMan.instance;
			if ((Object)(object)instance != (Object)null)
			{
				float dayFraction = instance.GetDayFraction();
				if (!(dayFraction >= 0.75f))
				{
					return dayFraction < 0.25f;
				}
				return true;
			}
			return false;
		}

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

		private void SetTimeMode()
		{
			if (m_Mode == TimeMode.Unknown)
			{
				m_Mode = ((!IsNightTime()) ? TimeMode.Day : TimeMode.Night);
			}
			if (IsNightTime() && m_Mode == TimeMode.Day)
			{
				EnterNightMode();
			}
			if (!IsNightTime() && m_Mode == TimeMode.Night)
			{
				ExitNightMode();
			}
		}

		public void UpdateAllCharactersHealth()
		{
			foreach (Character nearbySummon in DarkboundCharacters.GetNearbySummons())
			{
				if ((Object)(object)nearbySummon == (Object)null)
				{
					continue;
				}
				if (IsNightTime())
				{
					if ((Object)(object)((Component)nearbySummon).GetComponent<NightEmpoweredTag>() == (Object)null)
					{
						AddNightTag(nearbySummon);
						DoubleHealth(nearbySummon);
					}
					UpdateHealthDisplay(nearbySummon);
				}
				else
				{
					if ((Object)(object)((Component)nearbySummon).GetComponent<NightEmpoweredTag>() != (Object)null)
					{
						RemoveNightTag(nearbySummon);
						HalveHealth(nearbySummon);
					}
					UpdateHealthDisplay(nearbySummon);
				}
			}
		}

		private void EnterNightMode()
		{
			m_Mode = TimeMode.Night;
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				DarkboundNecromancer component = ((Component)localPlayer).GetComponent<DarkboundNecromancer>();
				if (!((Object)(object)component == (Object)null) && component.CurrentSummons >= 1 && !((Character)localPlayer).InIntro() && (Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "Your undead grow stronger as shadows deepen", 0, (Sprite)null, false);
				}
			}
		}

		private void ExitNightMode()
		{
			m_Mode = TimeMode.Day;
			DarkboundDayNight.OnDawn?.Invoke();
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				DarkboundNecromancer component = ((Component)localPlayer).GetComponent<DarkboundNecromancer>();
				if (!((Object)(object)component == (Object)null) && component.CurrentSummons >= 1 && !((Character)localPlayer).InIntro() && (Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "Daybreak weakens your undead", 0, (Sprite)null, false);
				}
			}
		}

		private static void AddNightTag(Character character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				((Component)character).gameObject.AddComponent<NightEmpoweredTag>();
			}
		}

		private static void RemoveNightTag(Character character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				NightEmpoweredTag component = ((Component)character).GetComponent<NightEmpoweredTag>();
				if (!((Object)(object)component == (Object)null))
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		private static void DoubleHealth(Character character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				float maxHealth = character.GetMaxHealth();
				character.SetMaxHealth(maxHealth * 2f);
			}
		}

		private static void HalveHealth(Character character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				float maxHealth = character.GetMaxHealth();
				character.SetMaxHealth(maxHealth / 2f);
			}
		}

		public void UpdateHealthDisplay(Character character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				float maxHealth = character.GetMaxHealth();
				SummonHealthDisplay component = ((Component)character).GetComponent<SummonHealthDisplay>();
				if ((Object)(object)component != (Object)null)
				{
					component.SetBuffActive(IsNightTime(), maxHealth);
				}
			}
		}
	}
	public class NightEmpoweredTag : MonoBehaviour
	{
	}
	public static class DarkboundDeath
	{
		private static DateTime _lastCleanupTime = DateTime.MinValue;

		public static void DeleteNearbySummons()
		{
			if ((DateTime.Now - _lastCleanupTime).TotalSeconds < 30.0)
			{
				return;
			}
			_lastCleanupTime = DateTime.Now;
			List<Character> nearbySummons = DarkboundCharacters.GetNearbySummons();
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			Character component = ((Component)localPlayer).GetComponent<Character>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			foreach (Character item in nearbySummons)
			{
				ApplyDamage(item, component);
			}
		}

		public static void DeleteNearbySummonsWithDropsIntact()
		{
			bool flag = true;
			List<Character> nearbySummons = DarkboundCharacters.GetNearbySummons();
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			Character component = ((Component)localPlayer).GetComponent<Character>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			int num = 0;
			while (flag)
			{
				num++;
				foreach (Character item in nearbySummons)
				{
					ApplyDamage(item, component, keepDrops: true, 1000f);
				}
				nearbySummons = DarkboundCharacters.GetNearbySummons();
				if (nearbySummons.Count == 0)
				{
					flag = false;
				}
				if (num >= 10)
				{
					flag = false;
				}
			}
		}

		public static void DeathByDamage(Character character)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				Character component = ((Component)localPlayer).GetComponent<Character>();
				if (!((Object)(object)component == (Object)null))
				{
					ApplyDamage(character, component);
				}
			}
		}

		public static void ApplyDamage(Character character, Character attacker, bool keepDrops = false, float damageAmount = float.MaxValue)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//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_0094: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: 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_0178: 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_0182: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || (Object)(object)((Component)character).gameObject == (Object)null || (Object)(object)((Component)character).GetComponent<SummonIdentifier>() == (Object)null)
			{
				return;
			}
			HitData val = new HitData();
			val.m_damage.m_slash = damageAmount;
			val.m_damage.m_blunt = damageAmount;
			val.m_damage.m_pickaxe = damageAmount;
			val.m_damage.m_chop = damageAmount;
			val.m_damage.m_damage = damageAmount;
			val.m_damage.m_pierce = damageAmount;
			val.m_damage.m_spirit = damageAmount;
			val.m_point = ((Component)character).transform.position;
			val.m_dir = Vector3.left;
			val.SetAttacker(attacker);
			val.m_itemLevel = 1;
			val.m_hitType = (HitType)1;
			val.m_skill = (SkillType)1;
			val.m_pushForce = 1f;
			character.Damage(val);
			if (!((Object)(object)character == (Object)null) && !(character.m_health <= 0f))
			{
				return;
			}
			DarkboundNecromancer component = ((Component)Player.m_localPlayer).GetComponent<DarkboundNecromancer>();
			if ((Object)(object)component != (Object)null)
			{
				component.RemoveSummon();
			}
			if (!character.IsDead())
			{
				return;
			}
			CharacterDrop component2 = ((Component)character).GetComponent<CharacterDrop>();
			if (!((Object)(object)component2 != (Object)null))
			{
				return;
			}
			if (keepDrops)
			{
				component2.SetDropsEnabled(true);
				{
					foreach (Drop drop in component2.m_drops)
					{
						if (!((Object)(object)drop.m_prefab == (Object)null))
						{
							int num = drop.m_amountMax + 1;
							for (int i = 0; i < num; i++)
							{
								Vector3 val2 = ((Component)character).transform.position + Random.insideUnitSphere * 0.5f;
								val2.y = ((Component)character).transform.position.y + 0.5f;
								Object.Instantiate<GameObject>(drop.m_prefab, val2, Quaternion.identity);
							}
						}
					}
					return;
				}
			}
			component2.m_drops.Clear();
		}

		public static void DeathByZNetScene(Character character)
		{
			if ((Object)(object)character == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			Character component = ((Component)Player.m_localPlayer).GetComponent<Character>();
			if (!((Object)(object)component == (Object)null) && !((Object)(object)character == (Object)(object)component))
			{
				ZNetView component2 = ((Component)character).GetComponent<ZNetView>();
				if ((Object)(object)component2 == (Object)null || !component2.IsValid())
				{
					Logger.LogWarning((object)("[Darkbound] Attempted to destroy a character without a valid ZNetView: " + ((Object)character).name));
					return;
				}
				component2.ClaimOwnership();
				component2.Destroy();
			}
		}
	}
	public class DarkboundEffects
	{
		public static GameObject AttachEffectToSummon(GameObject summonObject, string prefabName, string effectName)
		{
			//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_0062: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab = PrefabManager.Instance.GetPrefab(prefabName);
			if ((Object)(object)prefab == (Object)null || (Object)(object)summonObject == (Object)null)
			{
				Logger.LogWarning((object)("[Darkbound] Effect '" + prefabName + "' not found or summonObject is null."));
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(prefab, summonObject.transform.position, Quaternion.identity);
			obj.transform.SetParent(summonObject.transform);
			obj.transform.localPosition = Vector3.zero;
			obj.transform.localRotation = Quaternion.identity;
			obj.transform.localScale = Vector3.one;
			((Object)obj).name = effectName;
			return obj;
		}
	}
	public class DarkboundInventory : MonoBehaviour
	{
		public static class InventorySerializer
		{
			[Serializable]
			private class SerializedItem
			{
				public string prefab;

				public int stack;

				public float durability;

				public int quality;

				public int variant;

				public long crafterID;

				public string crafterName;
			}

			public static string SerializeInventory(Inventory inventory)
			{
				if (inventory == null)
				{
					Logger.LogWarning((object)"[SerializeInventory] Inventory is null.");
					return "";
				}
				List<SerializedItem> list = new List<SerializedItem>();
				foreach (ItemData allItem in inventory.GetAllItems())
				{
					if (allItem != null && !((Object)(object)allItem.m_dropPrefab == (Object)null) && !(((Object)allItem.m_dropPrefab).name == "$item_ringofforgottensouls") && !(allItem.m_shared.m_name == "$item_ringofforgottensouls"))
					{
						list.Add(new SerializedItem
						{
							prefab = ((Object)allItem.m_dropPrefab).name,
							stack = allItem.m_stack,
							durability = allItem.m_durability,
							quality = allItem.m_quality,
							variant = allItem.m_variant,
							crafterID = allItem.m_crafterID,
							crafterName = allItem.m_crafterName
						});
					}
				}
				return JsonConvert.SerializeObject((object)list);
			}

			public static void DeserializeInventory(string json, Inventory targetInventory)
			{
				if (string.IsNullOrEmpty(json) || targetInventory == null)
				{
					Logger.LogWarning((object)"[DeserializeInventory] Invalid input.");
					return;
				}
				List<SerializedItem> list = JsonConvert.DeserializeObject<List<SerializedItem>>(json);
				if (list == null)
				{
					Logger.LogWarning((object)"[DeserializeInventory] Failed to deserialize.");
					return;
				}
				targetInventory.RemoveAll();
				EnsureChestRing();
				foreach (SerializedItem item in list)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item.prefab);
					if ((Object)(object)itemPrefab == (Object)null)
					{
						Logger.LogWarning((object)("[DeserializeInventory] Prefab not found: " + item.prefab));
						continue;
					}
					ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
					if ((Object)(object)component == (Object)null)
					{
						Logger.LogWarning((object)("[DeserializeInventory] No ItemDrop on prefab: " + item.prefab));
					}
					else if (!(((Object)component).name == "$item_ringofforgottensouls") && !(component.m_itemData.m_shared.m_name == "$item_ringofforgottensouls"))
					{
						ItemData val = component.m_itemData.Clone();
						val.m_stack = item.stack;
						val.m_durability = item.durability;
						val.m_quality = item.quality;
						val.m_variant = item.variant;
						val.m_crafterID = item.crafterID;
						val.m_crafterName = item.crafterName;
						targetInventory.AddItem(val);
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <DelayLoadInventory>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 <DelayLoadInventory>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)Player.m_localPlayer != (Object)null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					LoadInventory();
					DarkboundInventoryGUI.RefreshSlots();
					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 const int width = 8;

		public const int height = 4;

		private static Inventory m_inventory;

		public static Inventory darkboundInventory
		{
			get
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				if (m_inventory == null)
				{
					m_inventory = new Inventory("DARKBOUND_INVENTORY", (Sprite)null, 8, 4);
					((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(DelayLoadInventory());
				}
				return m_inventory;
			}
		}

		private static string inventoryIdKey => PlayerPrefsDataManager.GenerateKey("DARKBOUND_INVENTORY___" + Game.instance.m_devWorldName);

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

		public static ItemData GetItemBySlot(int index)
		{
			Inventory val = darkboundInventory;
			if (val == null)
			{
				return null;
			}
			int num = 32;
			if (index < 0 || index >= num)
			{
				Debug.LogWarning((object)$"[DarkboundInventory] Invalid slot index: {index}");
				return null;
			}
			foreach (ItemData allItem in val.GetAllItems())
			{
				if (allItem.m_gridPos.y * 8 + allItem.m_gridPos.x == index)
				{
					return allItem;
				}
			}
			return null;
		}

		public static void SaveInventory()
		{
			darkboundInventory.GetAllItems();
			string value = InventorySerializer.SerializeInventory(darkboundInventory);
			PlayerPrefsDataManager.SaveString(inventoryIdKey, value);
		}

		public static void LoadInventory()
		{
			InventorySerializer.DeserializeInventory(PlayerPrefsDataManager.LoadString(inventoryIdKey), darkboundInventory);
		}

		public static void EnsureChestRing()
		{
			Inventory val = darkboundInventory;
			if (val == null)
			{
				return;
			}
			RingOfForgottenSouls.RegisterItem();
			if (val.ContainsItemByName("$item_ringofforgottensouls"))
			{
				return;
			}
			GameObject prefab = PrefabManager.Instance.GetPrefab("$item_ringofforgottensouls");
			if ((Object)(object)prefab == (Object)null)
			{
				Logger.LogWarning((object)"[DarkboundInventory] Missing prefab for Chest of Forgotten Souls ring: $item_ringofforgottensouls");
				return;
			}
			ItemData val2 = prefab.GetComponent<ItemDrop>().m_itemData.Clone();
			val2.m_durability = val2.GetMaxDurability();
			if (val.CanAddItem(val2, -1))
			{
				val.AddItem(val2);
			}
		}
	}
	public class DarkboundLights
	{
		public static void InspectAllLights(Transform root, Color color)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_0031: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in root)
			{
				Light component = ((Component)item).GetComponent<Light>();
				if ((Object)(object)component != (Object)null)
				{
					component.color = color;
				}
				InspectAllLights(item, color);
			}
		}

		public static Light AddPointLight(GameObject parent, Color lightColor)
		{
			//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_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_0038: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("PointLight");
			val.transform.SetParent(parent.transform);
			val.transform.localPosition = Vector3.zero;
			Light obj = val.AddComponent<Light>();
			obj.type = (LightType)2;
			obj.color = lightColor;
			obj.intensity = 1.5f;
			obj.range = 5f;
			obj.shadows = (LightShadows)0;
			return obj;
		}

		public static bool EnablePointLight(GameObject parent)
		{
			Light component = parent.GetComponent<Light>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = true;
				return true;
			}
			return false;
		}

		public static bool DisablePointLight(GameObject parent)
		{
			Light component = parent.GetComponent<Light>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
				return true;
			}
			return false;
		}
	}
	public static class DarkboundRegistrations
	{
		public static void RegisterAll()
		{
			NecromancerWorkbench.RegisterWorkbench();
			CrystalWorkbench.RegisterWorkbench();
			new NoviceSummoningCrystal().RegisterItem();
			new ApprenticeSummoningCrystal().RegisterItem();
			new AdeptSummoningCrystal().RegisterItem();
			new ProficientSummoningCrystal().RegisterItem();
			new ExpertSummoningCrystal().RegisterItem();
			new MasterSummoningCrystal().RegisterItem();
			new GrandmasterSummoningCrystal().RegisterItem();
			new LegendarySummoningCrystal().RegisterItem();
			new MythicSummoningCrystal().RegisterItem();
			new AscendantSummoningCrystal().RegisterItem();
			new NoviceSummoningCrystalX5().RegisterRecipe();
			new NoviceSummoningCrystalX50().RegisterRecipe();
			new ApprenticeSummoningCrystalX5().RegisterRecipe();
			new AdeptSummoningCrystalX5().RegisterRecipe();
			new ProficientSummoningCrystalX5().RegisterRecipe();
			new ExpertSummoningCrystalX5().RegisterRecipe();
			new MasterSummoningCrystalX5().RegisterRecipe();
			new GrandmasterSummoningCrystalX5().RegisterRecipe();
			new LegendarySummoningCrystalX5().RegisterRecipe();
			new NoviceCore().RegisterItem();
			new ApprenticeCore().RegisterItem();
			new AdeptCore().RegisterItem();
			new ProficientCore().RegisterItem();
			new ExpertCore().RegisterItem();
			new MasterCore().RegisterItem();
			new GrandmasterCore().RegisterItem();
			new LegendaryCore().RegisterItem();
			new MythicCore().RegisterItem();
			new AscendantCore().RegisterItem();
			new ApprenticeDurabilityStone().RegisterItem();
			new AdeptDurabilityStone().RegisterItem();
			new ProficientDurabilityStone().RegisterItem();
			new ExpertDurabilityStone().RegisterItem();
			new MasterDurabilityStone().RegisterItem();
			new GrandmasterDurabilityStone().RegisterItem();
			new LegendaryDurabilityStone().RegisterItem();
			new MythicDurabilityStone().RegisterItem();
			new AscendantDurabilityStone().RegisterItem();
			NecromancerRobes.RegisterItem();
			NecromancerLeggings.RegisterItem();
			NecromancerCape.RegisterItem();
			NecromancerHood.RegisterItem();
			ApprenticeCape.RegisterItem();
			CapeBlue.RegisterItem();
			CapeDarkGreen.RegisterItem();
			CapeGreen.RegisterItem();
			CapeOrange.RegisterItem();
			CapePurple.RegisterItem();
			CapeRed.RegisterItem();
			CapeTeal.RegisterItem();
			CapeYellow.RegisterItem();
			DarkFenringRobes.RegisterItem();
			DarkFenringRobesPlus.RegisterItem();
			DarkTrollRobes.RegisterItem();
			new NoviceNecrome().RegisterPiece();
			new ApprenticeNecrome().RegisterPiece();
			new AdeptNecrome().RegisterPiece();
			new ProficientNecrome().RegisterPiece();
			new ExpertNecrome().RegisterPiece();
			new MasterNecrome().RegisterPiece();
			new GrandmasterNecrome().RegisterPiece();
			new LegendaryNecrome().RegisterPiece();
			new MythicNecrome().RegisterPiece();
			new AscendantNecrome().RegisterPiece();
			RingOfForgottenSouls.RegisterItem();
			PlankDamned.RegisterPiece();
			Bloodboard.RegisterPiece();
			PlankOfEmbers.RegisterPiece();
			SpectralChest.RegisterPiece();
			Deathstone.RegisterPiece();
			WyldfireAshstone.RegisterPiece();
			WyldfireAshstoneWide.RegisterPiece();
			WyldfireSkyPillar.RegisterPiece();
			WyldPoisonStone.RegisterPiece();
			WyldfrostGlacierstone.RegisterPiece();
			WyldfrostWall.RegisterPiece();
			SoulfireSconce.RegisterPiece();
			RingOfAncientRecall.RegisterItem();
			RingOfSkeletalHands.RegisterItem();
			ThornsOfTheMasterRing.RegisterItem();
			WraithlightRing.RegisterItem();
			RingOfLostMerchants.RegisterItem();
			DarkStone_1x1.RegisterPiece();
			DarkStone_2x1.RegisterPiece();
			DarkStone_2x2.RegisterPiece();
			DarkStone_4x2.RegisterPiece();
			DarkStone_Thin2x2.RegisterPiece();
			DarkStone_Thin4x4.RegisterPiece();
			DarkStoneArch.RegisterPiece();
			DarkStonePillar.RegisterPiece();
			DarkStoneStairs.RegisterPiece();
			BoneStakes.RegisterPiece();
			DarkBeaconBlue.RegisterPiece();
			DarkBeaconGreen.RegisterPiece();
			DarkBeaconGreenDark.RegisterPiece();
			DarkBeaconOrange.RegisterPiece();
			DarkBeaconPurple.RegisterPiece();
			DarkBeaconRed.RegisterPiece();
			DarkBeaconTeal.RegisterPiece();
			DarkBeaconYellow.RegisterPiece();
			new SkeletonTalisman().RegisterItem();
			new SkeletonTalismanRecipe().RegisterRecipe();
			new SkeletonLightningTalisman().RegisterItem();
			new SkeletonLightningTalismanRecipe().RegisterRecipe();
			new SkeletonPoisonTalisman().RegisterItem();
			new SkeletonPoisonTalismanRecipe().RegisterRecipe();
			new SkeletonFlameTalisman().RegisterItem();
			new SkeletonFlameTalismanRecipe().RegisterRecipe();
			new SkeletonFrostSpiritTalisman().RegisterItem();
			new SkeletonFrostSpiritTalismanRecipe().RegisterRecipe();
			new SkeletonPestilenceTalisman().RegisterItem();
			new SkeletonPestilenceTalismanRecipe().RegisterRecipe();
			new SkeletonStoneTalisman().RegisterItem();
			new SkeletonStoneTalismanRecipe().RegisterRecipe();
			new BearTalisman().RegisterItem();
			new BearTalismanRecipe().RegisterRecipe();
			new BoarTalisman().RegisterItem();
			new BoarTalismanRecipe().RegisterRecipe();
			new BoarRedTalisman().RegisterItem();
			new BoarRedTalismanRecipe().RegisterRecipe();
			new DeerTalisman().RegisterItem();
			new DeerTalismanRecipe().RegisterRecipe();
			new NeckTalisman().RegisterItem();
			new NeckTalismanRecipe().RegisterRecipe();
			new GreylingTalisman().RegisterItem();
			new GreylingTalismanRecipe().RegisterRecipe();
			new GreylingRedTalisman().RegisterItem();
			new GreylingRedTalismanRecipe().RegisterRecipe();
			new GreydwarfTalisman().RegisterItem();
			new GreydwarfTalismanRecipe().RegisterRecipe();
			new GhostTalisman().RegisterItem();
			new GhostTalismanRecipe().RegisterRecipe();
			new GreydwarfBruteTalisman().RegisterItem();
			new GreydwarfBruteTalismanRecipe().RegisterRecipe();
			new GreydwarfShamanTalisman().RegisterItem();
			new GreydwarfShamanTalismanRecipe().RegisterRecipe();
			new TrollTalisman().RegisterItem();
			new TrollTalismanRecipe().RegisterRecipe();
			new RancidRemainsTalisman().RegisterItem();
			new RancidRemainsTalismanRecipe().RegisterRecipe();
			new OozerTalisman().RegisterItem();
			new OozerTalismanRecipe().RegisterRecipe();
			new OozerWildTalisman().RegisterItem();
			new OozerWildTalismanRecipe().RegisterRecipe();
			new DraugrArcherTalisman().RegisterItem();
			new DraugrArcherTalismanRecipe().RegisterRecipe();
			new LeechTalisman().RegisterItem();
			new LeechTalismanRecipe().RegisterRecipe();
			new WraithTalisman().RegisterItem();
			new WraithTalismanRecipe().RegisterRecipe();
			new SurtlingTalisman().RegisterItem();
			new SurtlingTalismanRecipe().RegisterRecipe();
			new WolfTalisman().RegisterItem();
			new WolfTalismanRecipe().RegisterRecipe();
			new DrakeTalisman().RegisterItem();
			new DrakeTalismanRecipe().RegisterRecipe();
			new DvergrFireMageTalisman().RegisterItem();
			new DvergrFireMageTalismanRecipe().RegisterRecipe();
			new DvergrRogueTalisman().RegisterItem();
			new DvergrRogueTalismanRecipe().RegisterRecipe();
			new FenringTalisman().RegisterItem();
			new FenringTalismanRecipe().RegisterRecipe();
			new FenringFireCultistTalisman().RegisterItem();
			new FenringFireCultistTalismanRecipe().RegisterRecipe();
			new FenringIceCultistTalisman().RegisterItem();
			new FenringIceCultistTalismanRecipe().RegisterRecipe();
			new FulingTalisman().RegisterItem();
			new FulingTalismanRecipe().RegisterRecipe();
			new FulingBerserkerTalisman().RegisterItem();
			new FulingBerserkerTalismanRecipe().RegisterRecipe();
			new LoxTalisman().RegisterItem();
			new LoxTalismanRecipe().RegisterRecipe();
			new GrowthTalisman().RegisterItem();
			new GrowthTalismanRecipe().RegisterRecipe();
			new DeathsquitoTalisman().RegisterItem();
			new DeathsquitoTalismanRecipe().RegisterRecipe();
			new AbominationTalisman().RegisterItem();
			new AbominationTalismanRecipe().RegisterRecipe();
			new StoneGolemTalisman().RegisterItem();
			new StoneGolemTalismanRecipe().RegisterRecipe();
			new SeekerTalisman().RegisterItem();
			new SeekerTalismanRecipe().RegisterRecipe();
			new SeekerSoldierTalisman().RegisterItem();
			new SeekerSoldierTalismanRecipe().RegisterRecipe();
			new HareTalisman().RegisterItem();
			new HareTalismanRecipe().RegisterRecipe();
			new VoltureTalisman().RegisterItem();
			new VoltureTalismanRecipe().RegisterRecipe();
			SkullAltar.RegisterPiece();
			SkeletonAltar.RegisterPiece();
			SkeletalSacrificeTrigger.RegisterItem();
			NecromancerAltar.RegisterPiece();
			NecromancerSacrificeTrigger.RegisterItem();
			new SummonsSlayer().RegisterItem();
			new UndeadSledgeOfRebuke().RegisterItem();
			new ShadowBarrier().RegisterItem();
			IronForge.RegisterPiece();
			IronHangingBrazier.RegisterPiece();
			IronStandingBrazier.RegisterPiece();
			new EssenceRed().RegisterItem();
			new EssenceGreen().RegisterItem();
			new EssenceBlue().RegisterItem();
			new EssencePurple().RegisterItem();
			new EssenceOrange().RegisterItem();
			new EssenceYellow().RegisterItem();
			new EssenceTeal().RegisterItem();
			new EssenceGreenDark().RegisterItem();
			new OdinRunestoneEntries().RegisterOdinRunestones();
			OdinRunestone.RegisterPrefab();
			NecromancerCapeBlue.RegisterItem();
			NecromancerCapeGreen.RegisterItem();
			NecromancerCapeGreenDark.RegisterItem();
			NecromancerCapeOrange.RegisterItem();
			NecromancerCapePurple.RegisterItem();
			NecromancerCapeRed.RegisterItem();
			NecromancerCapeTeal.RegisterItem();
			NecromancerCapeYellow.RegisterItem();
			NecromancerHoodBlue.RegisterItem();
			NecromancerHoodGreen.RegisterItem();
			NecromancerHoodGreenDark.RegisterItem();
			NecromancerHoodOrange.RegisterItem();
			NecromancerHoodPurple.RegisterItem();
			NecromancerHoodRed.RegisterItem();
			NecromancerHoodTeal.RegisterItem();
			NecromancerHoodYellow.RegisterItem();
			NecromancerRobesBlue.RegisterItem();
			NecromancerRobesGreen.RegisterItem();
			NecromancerRobesGreenDark.RegisterItem();
			NecromancerRobesOrange.RegisterItem();
			NecromancerRobesPurple.RegisterItem();
			NecromancerRobesRed.RegisterItem();
			NecromancerRobesTeal.RegisterItem();
			NecromancerRobesYellow.RegisterItem();
		}
	}
	public static class DarkboundShaders
	{
		public static Shader FindOrFallback(string shaderName, Shader fallback = null)
		{
			Shader val = Shader.Find(shaderName);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)("Shader '" + shaderName + "' not found. Using fallback."));
				if ((Object)(object)fallback == (Object)null)
				{
					fallback = Shader.Find("Standard");
					if ((Object)(object)fallback == (Object)null)
					{
						Debug.LogError((object)"Failed to find fallback Standard shader.");
						return null;
					}
				}
				return fallback;
			}
			return val;
		}

		public static Shader LoadShaderFromEmbeddedResource(string resourceName)
		{
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName);
			if (stream == null)
			{
				Debug.LogError((object)("Resource '" + resourceName + "' not found."));
				return null;
			}
			new StreamReader(stream).ReadToEnd();
			Debug.Log((object)("Shader code for '" + resourceName + "' loaded successfully."));
			return null;
		}

		public static Material CreateMaterialWithShader(string shaderName)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Shader val = FindOrFallback(shaderName);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return new Material(val);
		}
	}
	public class DarkboundSlotHandler : MonoBehaviour, IPointerClickHandler, IEventSystemHandler, IPointerEnterHandler, IPointerExitHandler
	{
		public int SlotIndex;

		public Image HoverImage;

		public Image IconImage;

		public Image BackgroundImage;

		private GameObject goBackground = new GameObject("Background");

		private GameObject goHover = new GameObject("Hover");

		private GameObject goIcon = new GameObject("Icon");

		private void Awake()
		{
		}

		public void InitializeSlotUI()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			CreateLayer(ref goBackground, "Background", ref BackgroundImage, "Darkbound.Assets.Icons.inventory-slot.png", 0);
			CreateLayer(ref goHover, "Hover", ref HoverImage, "Darkbound.Assets.Icons.inventory-slot-hover.png", 1);
			CreateLayer(ref goIcon, "Icon", ref IconImage, null, 2);
			((Graphic)BackgroundImage).color = DarkboundColor.HexToColor("#0000008A");
			((Graphic)BackgroundImage).raycastTarget = true;
			((Behaviour)BackgroundImage).enabled = true;
			((Graphic)HoverImage).color = DarkboundColor.HexToColor("#FFFFFFB0");
			((Behaviour)HoverImage).enabled = false;
			((Graphic)HoverImage).raycastTarget = false;
			((Behaviour)IconImage).enabled = false;
			((Graphic)IconImage).raycastTarget = false;
		}

		private void CreateLayer(ref GameObject go, string name, ref Image image, string resourceName, int siblingIndex)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0021: 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_004a: 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_0060: 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)
			go = new GameObject(name);
			go.transform.SetParent(((Component)this).transform);
			go.transform.localScale = Vector3.one;
			RectTransform obj = go.AddComponent<RectTransform>();
			((Transform)obj).SetParent(((Component)this).transform);
			((Transform)obj).localScale = Vector3.one;
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			go.transform.SetSiblingIndex(siblingIndex);
			image = go.AddComponent<Image>();
			if (!string.IsNullOrEmpty(resourceName))
			{
				Sprite iconFromResourceAsSprite = DarkboundIcon.GetIconFromResourceAsSprite(resourceName);
				if ((Object)(object)iconFromResourceAsSprite != (Object)null)
				{
					image.sprite = iconFromResourceAsSprite;
					image.type = (Type)0;
				}
			}
		}

		private void Update()
		{
		}

		private bool IsSlotHoveredOver()
		{
			//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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).gameObject.transform;
			Transform obj = ((transform is RectTransform) ? transform : null);
			Vector2 val = Vector2.op_Implicit(obj.InverseTransformPoint(ZInput.mousePosition));
			Rect rect = ((RectTransform)obj).rect;
			if (((Rect)(ref rect)).Contains(val))
			{
				return true;
			}
			return false;
		}

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0016: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			GameObject dragGo = DarkboundInventoryPatches.GetDragGo();
			if (dragGo != null)
			{
				dragGo.transform.SetAsLastSibling();
			}
			if ((int)eventData.button == 0 && InputControlExtensions.IsPressed((InputControl)(object)Keyboard.current.ctrlKey, 0f))
			{
				DarkboundInventoryGUI.OnSlotCtrlLeftClick(SlotIndex);
			}
			else if ((int)eventData.button == 0)
			{
				DarkboundInventoryGUI.OnSlotLeftClick(SlotIndex);
			}
			else if ((int)eventData.button == 1)
			{
				DarkboundInventoryGUI.OnSlotRightClick(SlotIndex);
			}
		}

		void IPointerEnterHandler.OnPointerEnter(PointerEventData eventData)
		{
			((Behaviour)HoverImage).enabled = true;
			DarkboundTooltip.EnsureTooltip();
			ItemData itemBySlot = DarkboundInventory.GetItemBySlot(SlotIndex);
			if (itemBySlot != null)
			{
				string name = itemBySlot.m_shared.m_name;
				string tooltip = ItemData.GetTooltip(itemBySlot, itemBySlot.m_quality, false, (float)itemBySlot.m_worldLevel, -1);
				string message = "<b><color=#FFB65B>" + Localization.instance.Localize(name) + "</color></b>\n\n" + tooltip;
				DarkboundTooltip.Instance.ShowTooltip(message, ((Component)this).transform);
			}
		}

		void IPointerExitHandler.OnPointerExit(PointerEventData eventData)
		{
			((Behaviour)HoverImage).enabled = false;
			DarkboundTooltip.Instance.HideTooltip();
		}
	}
	public class DarkboundSnap
	{
		public void ClearExistingSnapPoints(GameObject prefab)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			foreach (Transform item in prefab.transform)
			{
				Transform val = item;
				if (((Object)val).name.StartsWith("snap", StringComparison.OrdinalIgnoreCase))
				{
					Object.DestroyImmediate((Object)(object)((Component)val).gameObject);
				}
			}
		}

		public Transform CreateSnapPoint(Transform parent, Vector3 localPosition, string name)
		{
			//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)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.transform.localPosition = localPosition;
			val.transform.localRotation = Quaternion.identity;
			return val.transform;
		}

		public bool IsLikelySnapPoint(Transform t)
		{
			if ((Object)(object)((Component)t).GetComponent<MeshRenderer>() == (Object)null && (Object)(object)((Component)t).GetComponent<Collider>() == (Object)null && t.childCount == 0)
			{
				return ((Object)t).name.Length <= 20;
			}
			return false;
		}

		public void AddStandard2x2Snaps(GameObject prefab)
		{
			//IL_0018: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = prefab.transform;
			CreateSnapPoint(transform, new Vector3(1f, 0f, 0f), "snapX+");
			CreateSnapPoint(transform, new Vector3(-1f, 0f, 0f), "snapX-");
			CreateSnapPoint(transform, new Vector3(0f, 0f, 1f), "snapZ+");
			CreateSnapPoint(transform, new Vector3(0f, 0f, -1f), "snapZ-");
		}

		public void AddVerticalCornerSnaps(GameObject prefab, float height = 0.25f)
		{
			//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_0041: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0088: 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_0091: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = prefab.transform;
			float num = height / 2f;
			Vector3[] array = (Vector3[])(object)new Vector3[4]
			{
				new Vector3(1f, 0f, 1f),
				new Vector3(-1f, 0f, 1f),
				new Vector3(1f, 0f, -1f),
				new Vector3(-1f, 0f, -1f)
			};
			for (int i = 0; i < array.Length; i++)
			{
				Vector3 val = array[i];
				CreateSnapPoint(transform, new Vector3(val.x, 0f - num, val.z), $"snapCorner{i + 1}_bottom");
				CreateSnapPoint(transform, new Vector3(val.x, num, val.z), $"snapCorner{i + 1}_top");
			}
		}
	}
	public class DarkboundTooltip : MonoBehaviour
	{
		public static DarkboundTooltip Instance;

		private GameObject tooltipGO;

		private Text tooltipText;

		private RectTransform rectTransform;

		private Image backgroundImage;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
				Init();
			}
		}

		public void Init()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_00a2: 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_00d6: 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_0100: 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_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: 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_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			GameObject customGUIFront = GUIManager.CustomGUIFront;
			if ((Object)(object)customGUIFront == (Object)null)
			{
				Logger.LogWarning((object)"[DarkboundTooltip] GUI root not found. Cannot initialize tooltip.");
				return;
			}
			tooltipGO = new GameObject("DarkboundTooltip", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			tooltipGO.transform.SetParent(customGUIFront.transform, false);
			rectTransform = tooltipGO.GetComponent<RectTransform>();
			rectTransform.pivot = new Vector2(0f, 1f);
			rectTransform.anchorMin = new Vector2(0f, 0f);
			rectTransform.anchorMax = new Vector2(0f, 0f);
			rectTransform.anchoredPosition = Vector2.zero;
			rectTransform.sizeDelta = new Vector2(400f, 600f);
			backgroundImage = tooltipGO.GetComponent<Image>();
			((Graphic)backgroundImage).color = new Color(0f, 0f, 0f, 0.9f);
			((Graphic)backgroundImage).raycastTarget = false;
			GameObject val = new GameObject("TooltipText", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(tooltipGO.transform, false);
			tooltipText = val.AddComponent<Text>();
			tooltipText.font = GUIManager.Instance.AveriaSerifBold;
			tooltipText.fontSize = 18;
			((Graphic)tooltipText).color = Color.white;
			tooltipText.alignment = (TextAnchor)0;
			tooltipText.supportRichText = true;
			tooltipText.horizontalOverflow = (HorizontalWrapMode)0;
			tooltipText.verticalOverflow = (VerticalWrapMode)1;
			((Graphic)tooltipText).raycastTarget = false;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(10f, 10f);
			component.offsetMax = new Vector2(-10f, -10f);
			tooltipGO.SetActive(false);
		}

		public void ShowTooltip(string message, Transform slotTransform)
		{
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)tooltipGO == (Object)null || (Object)(object)tooltipText == (Object)null || (Object)(object)rectTransform == (Object)null)
			{
				Logger.LogWarning((object)"[DarkboundTooltip] One or more tooltip components are null — reinitializing.");
				Init();
			}
			if ((Object)(object)tooltipGO == (Object)null || (Object)(object)tooltipText == (Object)null || (Object)(object)rectTransform == (Object)null)
			{
				Logger.LogError((object)"[DarkboundTooltip] Tooltip initialization failed. Cannot show tooltip.");
				return;
			}
			if ((Object)(object)tooltipGO.transform.parent == (Object)null || ((Object)tooltipGO.transform.parent).name != "GUI")
			{
				GameObject obj = GameObject.Find("GUI");
				Transform val = ((obj != null) ? obj.transform : null);
				if ((Object)(object)val != (Object)null)
				{
					tooltipGO.transform.SetParent(val, false);
				}
				else
				{
					Logger.LogError((object)"[DarkboundTooltip] Could not find GUI to re-parent tooltip.");
				}
			}
			tooltipText.text = Localization.instance.Localize(message);
			LayoutRebuilder.ForceRebuildLayoutImmediate(((Graphic)tooltipText).rectTransform);
			tooltipText.text = Localization.instance.Localize(message);
			LayoutRebuilder.ForceRebuildLayoutImmediate(((Graphic)tooltipText).rectTransform);
			tooltipGO.transform.SetParent(slotTransform, false);
			tooltipGO.transform.SetAsLastSibling();
			rectTransform.pivot = new Vector2(0f, 0f);
			rectTransform.anchoredPosition = new Vector2(0f, 40f);
			tooltipGO.SetActive(true);
		}

		public void HideTooltip()
		{
			if ((Object)(object)tooltipGO != (Object)null)
			{
				tooltipGO.SetActive(false);
			}
		}

		public bool IsValid()
		{
			if ((Object)(object)tooltipGO != (Object)null && (Object)(object)tooltipText != (Object)null