using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+c78724dd7713b3d310be1e81a00b271706b0f66d")]
[assembly: AssemblyProduct("EmpressMinecraft")]
[assembly: AssemblyTitle("EmpressMinecraft")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EmpressMinecraft
{
	[BepInPlugin("Omniscye.EmpressMinecraft", "EmpressMinecraft", "1.0")]
	public class EmpressMinecraft : BaseUnityPlugin
	{
		internal static EmpressMinecraft Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal void Patch()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
		}
	}
}
namespace Empress.REPO.MinecraftLite
{
	[BepInPlugin("empress.repo.minecraftlite", "Empress Minecraft-Lite", "1.3.1")]
	public class EmpressMinecraftLitePlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <LoadAudioClips>d__19 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string dir;

			public EmpressMinecraftLitePlugin <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.LoadOne(dir, "place.ogg", delegate(AudioClip c)
					{
						<>4__this._placeClip = c;
					}));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.LoadOne(dir, "break.ogg", delegate(AudioClip c)
					{
						<>4__this._breakClip = c;
					}));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public string dir;

			public string fileName;

			public Action<AudioClip> setter;

			public EmpressMinecraftLitePlugin <>4__this;

			private string <full>5__1;

			private string <uri>5__2;

			private UnityWebRequest <req>5__3;

			private bool <err>5__4;

			private AudioClip <clip>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<full>5__1 = null;
				<uri>5__2 = null;
				<req>5__3 = null;
				<clip>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<full>5__1 = Path.Combine(dir, fileName);
						if (!File.Exists(<full>5__1))
						{
							((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("[MinecraftLite] Audio missing: " + fileName + " (optional)"));
							result = false;
							break;
						}
						<uri>5__2 = new Uri(<full>5__1).AbsoluteUri;
						<req>5__3 = UnityWebRequestMultimedia.GetAudioClip(<uri>5__2, (AudioType)14);
						<>1__state = -3;
						<>2__current = <req>5__3.SendWebRequest();
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -3;
						<err>5__4 = <req>5__3.isNetworkError || <req>5__3.isHttpError;
						if (<err>5__4)
						{
							((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("[MinecraftLite] Failed loading " + fileName + ": " + <req>5__3.error));
							result = false;
							<>m__Finally1();
							break;
						}
						<clip>5__5 = DownloadHandlerAudioClip.GetContent(<req>5__3);
						if ((Object)(object)<clip>5__5 != (Object)null)
						{
							((Object)<clip>5__5).name = Path.GetFileNameWithoutExtension(fileName);
							setter?.Invoke(<clip>5__5);
							((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[MinecraftLite] Audio OK: " + fileName));
						}
						else
						{
							((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("[MinecraftLite] " + fileName + " decoded to null clip."));
						}
						<clip>5__5 = null;
						<>m__Finally1();
						<req>5__3 = null;
						result = false;
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__3 != null)
				{
					((IDisposable)<req>5__3).Dispose();
				}
			}

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

		public const string PluginGuid = "empress.repo.minecraftlite";

		public const string PluginName = "Empress Minecraft-Lite";

		public const string PluginVersion = "1.3.1";

		internal static ManualLogSource Log;

		internal static EmpressMinecraftLitePlugin Instance;

		private BlockSystem _blocks;

		private PlacementPreview _preview;

		private BlockUI _ui;

		private int _selectedIndex = -1;

		private float _scrollCooldown;

		private bool _placementEnabled = true;

		private int _lastSelectedIndexBeforeDisable = -1;

		private float _lastSelectionTime;

		private const float UI_AUTOHIDE_SEC = 5f;

		private AudioClip _placeClip;

		private AudioClip _breakClip;

		private void Awake()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			_blocks = new GameObject("Empress_BlockSystem").AddComponent<BlockSystem>();
			_preview = new GameObject("Empress_PlacementPreview").AddComponent<PlacementPreview>();
			_ui = new GameObject("Empress_BlockUI").AddComponent<BlockUI>();
			string text = ResolveContentPath();
			_blocks.Init(text);
			_preview.Init(_blocks);
			_ui.Init(GetSelectedKind, _blocks);
			((MonoBehaviour)this).StartCoroutine(LoadAudioClips(text));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Empress Minecraft-Lite 1.3.1 loaded. Content: " + text));
		}

		private BlockKind GetSelectedKind()
		{
			int count = _blocks.Kinds.Count;
			if (count == 0)
			{
				return null;
			}
			if (_selectedIndex < 0)
			{
				return null;
			}
			_selectedIndex = Mathf.Clamp(_selectedIndex, 0, count - 1);
			return _blocks.Kinds[_selectedIndex];
		}

		public string ResolveContentPath()
		{
			string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			if (!string.IsNullOrEmpty(directoryName) && Directory.Exists(directoryName))
			{
				return directoryName;
			}
			string text = Path.Combine(Paths.PluginPath, "EmpressMinecraftLite");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			return text;
		}

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

		[IteratorStateMachine(typeof(<LoadOne>d__20))]
		private IEnumerator LoadOne(string dir, string fileName, Action<AudioClip> setter)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadOne>d__20(0)
			{
				<>4__this = this,
				dir = dir,
				fileName = fileName,
				setter = setter
			};
		}

		internal void PlayClipAt(AudioClip clip, Vector3 worldPos, float volume = 0.9f)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)clip == (Object)null))
			{
				GameObject val = new GameObject("Empress_AudioOneShot_" + ((Object)clip).name);
				val.transform.position = worldPos;
				AudioSource val2 = val.AddComponent<AudioSource>();
				val2.spatialBlend = 1f;
				val2.rolloffMode = (AudioRolloffMode)1;
				val2.minDistance = 2f;
				val2.maxDistance = 20f;
				val2.playOnAwake = false;
				val2.clip = clip;
				val2.volume = Mathf.Clamp01(volume);
				val2.dopplerLevel = 0f;
				val2.spread = 0f;
				val2.priority = 128;
				val2.Play();
				Object.Destroy((Object)(object)val, clip.length + 0.1f);
			}
		}

		private void Update()
		{
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: 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_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			Camera main = Camera.main;
			if ((Object)(object)main == (Object)null)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)287))
			{
				_blocks.ReloadTextures(ResolveContentPath());
				if (_selectedIndex >= 0)
				{
					_selectedIndex = Mathf.Clamp(_selectedIndex, 0, Mathf.Max(0, _blocks.Kinds.Count - 1));
				}
				_ui.Refresh(pulse: true);
				_ui.ShowPanel();
				_lastSelectionTime = Time.unscaledTime;
				Log.LogInfo((object)"[MinecraftLite] Reloaded textures.");
			}
			if (Input.GetKeyDown((KeyCode)120))
			{
				if (_placementEnabled)
				{
					_lastSelectedIndexBeforeDisable = _selectedIndex;
					_placementEnabled = false;
					SetNoneAndHideUI();
					Log.LogInfo((object)"[MinecraftLite] Disabled (scroll returns to base game).");
				}
				else
				{
					_placementEnabled = true;
					_ui.Refresh(pulse: true);
					_ui.ShowPanel();
					_lastSelectionTime = Time.unscaledTime;
					Log.LogInfo((object)"[MinecraftLite] Enabled.");
				}
			}
			Ray val = main.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0f));
			RaycastHit hit = default(RaycastHit);
			if (Physics.Raycast(val, ref hit, 8f))
			{
				if (_placementEnabled && _selectedIndex >= 0)
				{
					Vector3Int placementPosition = GridUtil.GetPlacementPosition(hit);
					bool flag = !_blocks.HasBlock(placementPosition);
					_preview.UpdatePreview(placementPosition, flag);
					if (Input.GetMouseButtonDown(1) && flag)
					{
						BlockKind selectedKind = GetSelectedKind();
						if (selectedKind != null)
						{
							_blocks.PlaceBlock(placementPosition, selectedKind, _placeClip);
						}
					}
				}
				else
				{
					_preview.Hide();
				}
				if (Input.GetMouseButton(0))
				{
					Block componentInParent = ((Component)((RaycastHit)(ref hit)).collider).GetComponentInParent<Block>();
					if ((Object)(object)componentInParent != (Object)null)
					{
						componentInParent.TickMining(Time.deltaTime);
						if (componentInParent.IsBroken)
						{
							_blocks.RemoveBlock(componentInParent.GridPos, _breakClip);
						}
					}
				}
				else
				{
					((Component)((RaycastHit)(ref hit)).collider).GetComponentInParent<Block>()?.ResetMining();
				}
			}
			else
			{
				_preview.Hide();
			}
			if (_placementEnabled)
			{
				HandleScroll(Input.mouseScrollDelta.y);
			}
			if (_ui.IsVisible && _selectedIndex >= 0 && Time.unscaledTime - _lastSelectionTime > 5f)
			{
				_ui.HidePanel();
			}
		}

		private void SetNoneAndHideUI()
		{
			_selectedIndex = -1;
			_ui.Refresh();
			_ui.HidePanel();
			_preview.Hide();
			Log.LogInfo((object)"[MinecraftLite] Selection set to NONE; UI hidden.");
		}

		private void HandleScroll(float scrollY)
		{
			if (!(Mathf.Abs(scrollY) <= 0.1f) && !(Time.unscaledTime <= _scrollCooldown) && _blocks.Kinds.Count != 0)
			{
				_scrollCooldown = Time.unscaledTime + 0.15f;
				if (_selectedIndex < 0)
				{
					_selectedIndex = ((!(scrollY > 0f)) ? (_blocks.Kinds.Count - 1) : 0);
				}
				else
				{
					_selectedIndex = ((scrollY > 0f) ? ((_selectedIndex + 1) % _blocks.Kinds.Count) : ((_selectedIndex - 1 + _blocks.Kinds.Count) % _blocks.Kinds.Count));
				}
				_lastSelectionTime = Time.unscaledTime;
				_ui.Refresh(pulse: true);
				_ui.ShowPanel();
			}
		}
	}
	public static class OmnibinReader
	{
		public class Entry
		{
			public string Name;

			public byte[] Data;
		}

		private static readonly byte[] MAGIC = new byte[4] { 79, 77, 66, 78 };

		public static List<Entry> ReadOmnibin(string path)
		{
			List<Entry> list = new List<Entry>();
			using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
			{
				using BinaryReader binaryReader = new BinaryReader(fileStream);
				byte[] array = binaryReader.ReadBytes(4);
				if (array.Length != 4 || array[0] != MAGIC[0] || array[1] != MAGIC[1] || array[2] != MAGIC[2] || array[3] != MAGIC[3])
				{
					throw new InvalidDataException("Not a valid .omnibin file (bad magic).");
				}
				ushort num = binaryReader.ReadUInt16();
				if (num != 1)
				{
					throw new InvalidDataException($"Unsupported omnibin version: {num}");
				}
				ushort num2 = binaryReader.ReadUInt16();
				uint num3 = binaryReader.ReadUInt32();
				List<(string, ulong, uint, uint, uint)> list2 = new List<(string, ulong, uint, uint, uint)>();
				for (uint num4 = 0u; num4 < num3; num4++)
				{
					ushort count = binaryReader.ReadUInt16();
					byte[] bytes = binaryReader.ReadBytes(count);
					string @string = Encoding.UTF8.GetString(bytes);
					ulong item = binaryReader.ReadUInt64();
					uint item2 = binaryReader.ReadUInt32();
					uint item3 = binaryReader.ReadUInt32();
					uint item4 = binaryReader.ReadUInt32();
					list2.Add((@string, item, item2, item3, item4));
				}
				foreach (var item5 in list2)
				{
					fileStream.Seek((long)item5.Item2, SeekOrigin.Begin);
					byte[] array2 = binaryReader.ReadBytes((int)item5.Item4);
					byte[] array3 = (((item5.Item5 & 1) == 0) ? array2 : DecompressDeflate(array2));
					if (array3.Length != item5.Item3)
					{
						ManualLogSource log = EmpressMinecraftLitePlugin.Log;
						if (log != null)
						{
							log.LogWarning((object)$"[OMNIBIN] Size mismatch for {item5.Item1}: {array3.Length} != {item5.Item3}");
						}
					}
					list.Add(new Entry
					{
						Name = item5.Item1,
						Data = array3
					});
				}
			}
			return list;
		}

		private static byte[] DecompressDeflate(byte[] compressed)
		{
			using MemoryStream stream = new MemoryStream(compressed);
			using DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress);
			using MemoryStream memoryStream = new MemoryStream();
			deflateStream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}
	}
	public class BlockKind
	{
		public string Id;

		public Material Material;

		public Texture2D Texture;
	}
	public static class GridUtil
	{
		public static Vector3Int RoundToGrid(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3Int(Mathf.RoundToInt(pos.x), Mathf.RoundToInt(pos.y), Mathf.RoundToInt(pos.z));
		}

		public static Vector3Int GetPlacementPosition(RaycastHit hit)
		{
			//IL_0003: 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_0014: 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_001e: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			Vector3 pos = ((RaycastHit)(ref hit)).point + ((RaycastHit)(ref hit)).normal * 0.5f;
			return RoundToGrid(pos);
		}
	}
	public class BlockSystem : MonoBehaviour
	{
		public readonly Dictionary<Vector3Int, Block> Blocks = new Dictionary<Vector3Int, Block>();

		public readonly List<BlockKind> Kinds = new List<BlockKind>();

		public readonly Dictionary<string, BlockKind> KindById = new Dictionary<string, BlockKind>(StringComparer.OrdinalIgnoreCase);

		public Material CrackOverlayMaterial;

		public Material PreviewGoodMat;

		public Material PreviewBadMat;

		private Transform _root;

		private string _textureDir;

		public void Init(string textureDir)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			_textureDir = textureDir;
			_root = new GameObject("Empress_BlocksRoot").transform;
			_root.SetParent(((Component)this).transform);
			LoadAllMaterials(_textureDir);
		}

		public void ReloadTextures(string textureDir)
		{
			if (!string.IsNullOrEmpty(textureDir))
			{
				_textureDir = textureDir;
			}
			LoadAllMaterials(_textureDir);
			foreach (KeyValuePair<Vector3Int, Block> block in Blocks)
			{
				Block value = block.Value;
				if (!((Object)(object)value == (Object)null) && !string.IsNullOrEmpty(value.KindId) && KindById.TryGetValue(value.KindId, out BlockKind value2) && (Object)(object)value2.Material != (Object)null)
				{
					Renderer component = ((Component)value).GetComponent<Renderer>();
					if ((Object)(object)component != (Object)null)
					{
						component.sharedMaterial = value2.Material;
					}
				}
			}
		}

		private void LoadAllMaterials(string textureDir)
		{
			//IL_00b4: 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)
			ManualLogSource log = EmpressMinecraftLitePlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[MinecraftLite] Loading textures from: " + textureDir));
			}
			Kinds.Clear();
			KindById.Clear();
			string text = Path.Combine(textureDir, "RMC.omnibin");
			if (File.Exists(text))
			{
				LoadFromOmnibin(text);
			}
			else
			{
				ManualLogSource log2 = EmpressMinecraftLitePlugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)"[MinecraftLite] RMC.omnibin not found, loading loose PNGs...");
				}
				LoadFromLooseFiles(textureDir);
			}
			if (Kinds.Count == 0)
			{
				ManualLogSource log3 = EmpressMinecraftLitePlugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)"[MinecraftLite] No selectable block textures found. Add RMC.omnibin or drop some *.png files next to the DLL.");
				}
			}
			PreviewGoodMat = MakeTintMat(new Color(0f, 1f, 0f, 0.35f));
			PreviewBadMat = MakeTintMat(new Color(1f, 0f, 0f, 0.35f));
		}

		private void LoadFromOmnibin(string omnibinPath)
		{
			try
			{
				ManualLogSource log = EmpressMinecraftLitePlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[MinecraftLite] Loading from OMNIBIN: " + omnibinPath));
				}
				List<OmnibinReader.Entry> list = OmnibinReader.ReadOmnibin(omnibinPath);
				OmnibinReader.Entry entry = null;
				foreach (OmnibinReader.Entry item in list)
				{
					if (item.Name.Equals("crack.png", StringComparison.OrdinalIgnoreCase) || item.Name.Equals("cracked.png", StringComparison.OrdinalIgnoreCase))
					{
						entry = item;
						break;
					}
				}
				if (entry != null)
				{
					CrackOverlayMaterial = MakeTransparentMatFromBytes(entry.Data);
					ManualLogSource log2 = EmpressMinecraftLitePlugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)string.Format("  {0,8}  {1}", "OK", entry.Name));
					}
				}
				else
				{
					CrackOverlayMaterial = null;
					ManualLogSource log3 = EmpressMinecraftLitePlugin.Log;
					if (log3 != null)
					{
						log3.LogInfo((object)string.Format("  {0,8}  crack.png", "MISSING"));
					}
				}
				foreach (OmnibinReader.Entry item2 in list)
				{
					if (!item2.Name.Equals("crack.png", StringComparison.OrdinalIgnoreCase) && !item2.Name.Equals("cracked.png", StringComparison.OrdinalIgnoreCase) && item2.Name.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
					{
						string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item2.Name);
						Texture2D outTex;
						Material material = MakeMatFromBytes(item2.Data, out outTex);
						BlockKind blockKind = new BlockKind
						{
							Id = fileNameWithoutExtension,
							Material = material,
							Texture = outTex
						};
						Kinds.Add(blockKind);
						KindById[fileNameWithoutExtension] = blockKind;
						ManualLogSource log4 = EmpressMinecraftLitePlugin.Log;
						if (log4 != null)
						{
							log4.LogInfo((object)string.Format("  {0,8}  {1}", "OK", item2.Name));
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log5 = EmpressMinecraftLitePlugin.Log;
				if (log5 != null)
				{
					log5.LogError((object)("[MinecraftLite] Failed to load OMNIBIN: " + ex.Message));
				}
			}
		}

		private void LoadFromLooseFiles(string textureDir)
		{
			string text = FindTexture(textureDir, new string[2] { "crack.png", "cracked.png" });
			CrackOverlayMaterial = ((!string.IsNullOrEmpty(text)) ? MakeTransparentMat(text) : null);
			ManualLogSource log = EmpressMinecraftLitePlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)string.Format("  {0,8}  crack.png", ((Object)(object)CrackOverlayMaterial != (Object)null) ? "OK" : "MISSING"));
			}
			string[] array = Array.Empty<string>();
			try
			{
				if (Directory.Exists(textureDir))
				{
					array = Directory.GetFiles(textureDir, "*.png", SearchOption.TopDirectoryOnly);
				}
			}
			catch
			{
			}
			Array.Sort(array, (IComparer<string>?)StringComparer.OrdinalIgnoreCase);
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				string fileName = Path.GetFileName(text2);
				if (!fileName.Equals("crack.png", StringComparison.OrdinalIgnoreCase) && !fileName.Equals("cracked.png", StringComparison.OrdinalIgnoreCase))
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text2);
					Texture2D outTex;
					Material material = MakeMat(text2, out outTex);
					BlockKind blockKind = new BlockKind
					{
						Id = fileNameWithoutExtension,
						Material = material,
						Texture = outTex
					};
					Kinds.Add(blockKind);
					KindById[fileNameWithoutExtension] = blockKind;
					ManualLogSource log2 = EmpressMinecraftLitePlugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)string.Format("  {0,8}  {1}", "OK", fileName));
					}
				}
			}
		}

		private static string FindTexture(string dir, string[] candidates)
		{
			try
			{
				if (!Directory.Exists(dir))
				{
					return null;
				}
				string[] files = Directory.GetFiles(dir, "*.png", SearchOption.TopDirectoryOnly);
				foreach (string b in candidates)
				{
					string[] array = files;
					foreach (string text in array)
					{
						if (string.Equals(Path.GetFileName(text), b, StringComparison.OrdinalIgnoreCase))
						{
							return text;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static Texture2D LoadTexture(string path)
		{
			byte[] data = File.ReadAllBytes(path);
			return LoadTextureFromBytes(data);
		}

		private static Texture2D LoadTextureFromBytes(byte[] data)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, true);
			ImageConversion.LoadImage(val, data, false);
			((Texture)val).wrapMode = (TextureWrapMode)0;
			((Texture)val).filterMode = (FilterMode)0;
			return val;
		}

		private static Material MakeMat(string pngPath, out Texture2D outTex)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			outTex = null;
			Shader val = Shader.Find("Standard");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Legacy Shaders/Diffuse");
			}
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				val = val2.GetComponent<Renderer>().sharedMaterial.shader;
				Object.Destroy((Object)(object)val2);
			}
			Material val3 = new Material(val);
			val3.color = Color.white;
			if (!string.IsNullOrEmpty(pngPath) && File.Exists(pngPath))
			{
				Texture2D val4 = (outTex = LoadTexture(pngPath));
				if (val3.HasProperty("_MainTex"))
				{
					val3.SetTexture("_MainTex", (Texture)(object)val4);
				}
			}
			return val3;
		}

		private static Material MakeMatFromBytes(byte[] pngData, out Texture2D outTex)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			outTex = null;
			Shader val = Shader.Find("Standard");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Legacy Shaders/Diffuse");
			}
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				val = val2.GetComponent<Renderer>().sharedMaterial.shader;
				Object.Destroy((Object)(object)val2);
			}
			Material val3 = new Material(val);
			val3.color = Color.white;
			if (pngData != null && pngData.Length != 0)
			{
				Texture2D val4 = (outTex = LoadTextureFromBytes(pngData));
				if (val3.HasProperty("_MainTex"))
				{
					val3.SetTexture("_MainTex", (Texture)(object)val4);
				}
			}
			return val3;
		}

		private static Material MakeTransparentMat(string pngPath)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			Shader val = Shader.Find("Standard");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Legacy Shaders/Transparent/Diffuse");
			}
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				val = val2.GetComponent<Renderer>().sharedMaterial.shader;
				Object.Destroy((Object)(object)val2);
			}
			Material val3 = new Material(val);
			if (((Object)val3.shader).name.Contains("Standard"))
			{
				val3.SetFloat("_Mode", 3f);
				val3.SetInt("_SrcBlend", 5);
				val3.SetInt("_DstBlend", 10);
				val3.SetInt("_ZWrite", 0);
				val3.DisableKeyword("_ALPHATEST_ON");
				val3.EnableKeyword("_ALPHABLEND_ON");
				val3.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				val3.renderQueue = 3000;
			}
			if (!string.IsNullOrEmpty(pngPath) && File.Exists(pngPath))
			{
				Texture2D val4 = LoadTexture(pngPath);
				if (val3.HasProperty("_MainTex"))
				{
					val3.SetTexture("_MainTex", (Texture)(object)val4);
				}
			}
			return val3;
		}

		private static Material MakeTransparentMatFromBytes(byte[] pngData)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			Shader val = Shader.Find("Standard");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Legacy Shaders/Transparent/Diffuse");
			}
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				val = val2.GetComponent<Renderer>().sharedMaterial.shader;
				Object.Destroy((Object)(object)val2);
			}
			Material val3 = new Material(val);
			if (((Object)val3.shader).name.Contains("Standard"))
			{
				val3.SetFloat("_Mode", 3f);
				val3.SetInt("_SrcBlend", 5);
				val3.SetInt("_DstBlend", 10);
				val3.SetInt("_ZWrite", 0);
				val3.DisableKeyword("_ALPHATEST_ON");
				val3.EnableKeyword("_ALPHABLEND_ON");
				val3.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				val3.renderQueue = 3000;
			}
			if (pngData != null && pngData.Length != 0)
			{
				Texture2D val4 = LoadTextureFromBytes(pngData);
				if (val3.HasProperty("_MainTex"))
				{
					val3.SetTexture("_MainTex", (Texture)(object)val4);
				}
			}
			return val3;
		}

		private static Material MakeTintMat(Color c)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Standard");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Legacy Shaders/Diffuse");
			}
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				val = val2.GetComponent<Renderer>().sharedMaterial.shader;
				Object.Destroy((Object)(object)val2);
			}
			Material val3 = new Material(val);
			if (((Object)val3.shader).name.Contains("Standard"))
			{
				val3.SetFloat("_Mode", 3f);
				val3.SetInt("_SrcBlend", 5);
				val3.SetInt("_DstBlend", 10);
				val3.SetInt("_ZWrite", 0);
				val3.DisableKeyword("_ALPHATEST_ON");
				val3.EnableKeyword("_ALPHABLEND_ON");
				val3.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				val3.renderQueue = 3000;
			}
			val3.color = c;
			return val3;
		}

		public bool HasBlock(Vector3Int grid)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return Blocks.ContainsKey(grid);
		}

		public void PlaceBlock(Vector3Int grid, BlockKind kind, AudioClip placeClip)
		{
			//IL_0007: 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_005b: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			if (!Blocks.ContainsKey(grid) && kind != null)
			{
				GameObject val = GameObject.CreatePrimitive((PrimitiveType)3);
				((Object)val).name = $"Block_{kind.Id}_{grid}";
				val.transform.SetParent(_root);
				val.transform.position = Vector3Int.op_Implicit(grid);
				val.transform.localScale = Vector3.one;
				Renderer component = val.GetComponent<Renderer>();
				if ((Object)(object)kind.Material != (Object)null && (Object)(object)component != (Object)null)
				{
					component.sharedMaterial = kind.Material;
				}
				Block block = val.AddComponent<Block>();
				block.Init(this, grid, kind.Id);
				Blocks[grid] = block;
				if ((Object)(object)placeClip != (Object)null)
				{
					EmpressMinecraftLitePlugin.Instance.PlayClipAt(placeClip, Vector3Int.op_Implicit(grid) + new Vector3(0.5f, 0.5f, 0.5f));
				}
			}
		}

		public void RemoveBlock(Vector3Int grid, AudioClip breakClip)
		{
			//IL_0007: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (Blocks.TryGetValue(grid, out Block value))
			{
				if ((Object)(object)breakClip != (Object)null)
				{
					EmpressMinecraftLitePlugin.Instance.PlayClipAt(breakClip, Vector3Int.op_Implicit(grid) + new Vector3(0.5f, 0.5f, 0.5f));
				}
				Blocks.Remove(grid);
				Object.Destroy((Object)(object)((Component)value).gameObject);
			}
		}
	}
	public class Block : MonoBehaviour
	{
		private BlockSystem _sys;

		private float _miningTime;

		private const float BreakTime = 1f;

		private GameObject _crackOverlay;

		private Renderer _renderer;

		private Color _baseColor = Color.white;

		public Vector3Int GridPos { get; private set; }

		public string KindId { get; private set; }

		public bool IsBroken => _miningTime >= 1f;

		public void Init(BlockSystem sys, Vector3Int grid, string kindId)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			_sys = sys;
			GridPos = grid;
			KindId = kindId;
			_renderer = ((Component)this).GetComponent<Renderer>();
			if ((Object)(object)_renderer != (Object)null && (Object)(object)_renderer.sharedMaterial != (Object)null)
			{
				_baseColor = _renderer.sharedMaterial.color;
			}
		}

		public void TickMining(float dt)
		{
			_miningTime = Mathf.Clamp(_miningTime + dt, 0f, 1f);
			UpdateCrackVisual();
		}

		public void ResetMining()
		{
			if (_miningTime > 0f)
			{
				_miningTime = Mathf.Max(0f, _miningTime - Time.deltaTime * 2f);
				UpdateCrackVisual();
			}
		}

		private void UpdateCrackVisual()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_012f: Expected O, but got Unknown
			if ((Object)(object)_renderer == (Object)null)
			{
				return;
			}
			float num = Mathf.InverseLerp(0f, 1f, _miningTime);
			Material material = _renderer.material;
			material.color = Color.Lerp(_baseColor, Color.black, num * 0.35f);
			if ((Object)(object)_sys.CrackOverlayMaterial != (Object)null)
			{
				if ((Object)(object)_crackOverlay == (Object)null)
				{
					_crackOverlay = GameObject.CreatePrimitive((PrimitiveType)3);
					((Object)_crackOverlay).name = "CrackOverlay";
					_crackOverlay.transform.SetParent(((Component)this).transform, false);
					_crackOverlay.transform.localPosition = Vector3.zero;
					_crackOverlay.transform.localRotation = Quaternion.identity;
					_crackOverlay.transform.localScale = new Vector3(1.005f, 1.005f, 1.005f);
					Renderer component = _crackOverlay.GetComponent<Renderer>();
					component.sharedMaterial = new Material(_sys.CrackOverlayMaterial);
					component.sharedMaterial.renderQueue = 3100;
					Object.Destroy((Object)(object)_crackOverlay.GetComponent<Collider>());
					_crackOverlay.layer = 2;
				}
				Material material2 = _crackOverlay.GetComponent<Renderer>().material;
				material2.color = new Color(1f, 1f, 1f, Mathf.Lerp(0f, 0.9f, num));
			}
		}
	}
	public class PlacementPreview : MonoBehaviour
	{
		private GameObject _cube;

		private Renderer _renderer;

		private GameObject _outlineRoot;

		private LineRenderer[] _edges;

		private BlockSystem _sys;

		private Material _outlineGoodMat;

		private Material _outlineBadMat;

		public void Init(BlockSystem sys)
		{
			_sys = sys;
			EnsureBuilt();
			Hide();
		}

		private void EnsureBuilt()
		{
			//IL_006a: 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_0157: 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: Expected O, but got Unknown
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Expected O, but got Unknown
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Expected O, but got Unknown
			if ((Object)(object)_sys == (Object)null)
			{
				return;
			}
			if ((Object)(object)_cube == (Object)null)
			{
				_cube = GameObject.CreatePrimitive((PrimitiveType)3);
				((Object)_cube).name = "Empress_PreviewCube";
				_cube.transform.SetParent(((Component)this).transform, false);
				_cube.transform.localScale = Vector3.one;
				_renderer = _cube.GetComponent<Renderer>();
				Collider component = _cube.GetComponent<Collider>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				_cube.layer = 2;
			}
			if ((Object)(object)_renderer == (Object)null && (Object)(object)_cube != (Object)null)
			{
				_renderer = _cube.GetComponent<Renderer>();
			}
			if ((Object)(object)_sys.PreviewGoodMat == (Object)null)
			{
				_sys.PreviewGoodMat = BlockSystemTint(new Color(0f, 1f, 0f, 0.35f));
			}
			if ((Object)(object)_sys.PreviewBadMat == (Object)null)
			{
				_sys.PreviewBadMat = BlockSystemTint(new Color(1f, 0f, 0f, 0.35f));
			}
			if ((Object)(object)_outlineRoot == (Object)null)
			{
				_outlineRoot = new GameObject("Empress_PreviewOutline");
				_outlineRoot.transform.SetParent(((Component)this).transform, false);
				_outlineRoot.layer = 2;
				_edges = (LineRenderer[])(object)new LineRenderer[12];
				for (int i = 0; i < _edges.Length; i++)
				{
					GameObject val = new GameObject($"Edge_{i}")
					{
						layer = 2
					};
					val.transform.SetParent(_outlineRoot.transform, false);
					LineRenderer val2 = val.AddComponent<LineRenderer>();
					val2.positionCount = 2;
					val2.useWorldSpace = false;
					val2.widthMultiplier = 0.06f;
					val2.numCapVertices = 2;
					((Renderer)val2).shadowCastingMode = (ShadowCastingMode)0;
					((Renderer)val2).receiveShadows = false;
					((Renderer)val2).motionVectorGenerationMode = (MotionVectorGenerationMode)2;
					val2.textureMode = (LineTextureMode)0;
					val2.alignment = (LineAlignment)0;
					((Renderer)val2).sortingOrder = 32767;
					Shader val3 = Shader.Find("Unlit/Color");
					if ((Object)(object)val3 == (Object)null)
					{
						val3 = Shader.Find("Sprites/Default");
					}
					if ((Object)(object)val3 == (Object)null)
					{
						val3 = Shader.Find("Legacy Shaders/Particles/Alpha Blended");
					}
					((Renderer)val2).material = new Material(val3);
					_edges[i] = val2;
				}
				SetOutlineBox(_edges);
			}
			if ((Object)(object)_outlineGoodMat == (Object)null)
			{
				_outlineGoodMat = MakeFlatColor(new Color(0f, 1f, 0f, 0.95f));
			}
			if ((Object)(object)_outlineBadMat == (Object)null)
			{
				_outlineBadMat = MakeFlatColor(new Color(1f, 0f, 0f, 0.95f));
			}
		}

		private static void SetOutlineBox(LineRenderer[] edges)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_00da: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[8]
			{
				new Vector3(-0.5f, -0.5f, -0.5f),
				new Vector3(0.5f, -0.5f, -0.5f),
				new Vector3(0.5f, -0.5f, 0.5f),
				new Vector3(-0.5f, -0.5f, 0.5f),
				new Vector3(-0.5f, 0.5f, -0.5f),
				new Vector3(0.5f, 0.5f, -0.5f),
				new Vector3(0.5f, 0.5f, 0.5f),
				new Vector3(-0.5f, 0.5f, 0.5f)
			};
			int[,] array2 = new int[12, 2]
			{
				{ 0, 1 },
				{ 1, 2 },
				{ 2, 3 },
				{ 3, 0 },
				{ 4, 5 },
				{ 5, 6 },
				{ 6, 7 },
				{ 7, 4 },
				{ 0, 4 },
				{ 1, 5 },
				{ 2, 6 },
				{ 3, 7 }
			};
			for (int i = 0; i < 12; i++)
			{
				edges[i].SetPosition(0, array[array2[i, 0]]);
				edges[i].SetPosition(1, array[array2[i, 1]]);
			}
		}

		private static Material BlockSystemTint(Color c)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Standard");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Legacy Shaders/Diffuse");
			}
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				val = val2.GetComponent<Renderer>().sharedMaterial.shader;
				Object.Destroy((Object)(object)val2);
			}
			Material val3 = new Material(val);
			if (((Object)val3.shader).name.Contains("Standard"))
			{
				val3.SetFloat("_Mode", 3f);
				val3.SetInt("_SrcBlend", 5);
				val3.SetInt("_DstBlend", 10);
				val3.SetInt("_ZWrite", 0);
				val3.DisableKeyword("_ALPHATEST_ON");
				val3.EnableKeyword("_ALPHABLEND_ON");
				val3.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				val3.renderQueue = 3000;
			}
			val3.color = c;
			return val3;
		}

		private static Material MakeFlatColor(Color c)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Unlit/Color");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Sprites/Default");
			}
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				val = val2.GetComponent<Renderer>().sharedMaterial.shader;
				Object.Destroy((Object)(object)val2);
			}
			Material val3 = new Material(val);
			if (val3.HasProperty("_Color"))
			{
				val3.color = c;
			}
			val3.renderQueue = 3100;
			return val3;
		}

		public void UpdatePreview(Vector3Int grid, bool canPlace)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			EnsureBuilt();
			if (!((Object)(object)_cube == (Object)null) && !((Object)(object)_renderer == (Object)null) && !((Object)(object)_outlineRoot == (Object)null) && _edges != null)
			{
				_cube.SetActive(true);
				_outlineRoot.SetActive(true);
				((Component)this).transform.position = Vector3Int.op_Implicit(grid);
				_renderer.sharedMaterial = (canPlace ? _sys.PreviewGoodMat : _sys.PreviewBadMat);
				Material sharedMaterial = (canPlace ? _outlineGoodMat : _outlineBadMat);
				for (int i = 0; i < _edges.Length; i++)
				{
					((Renderer)_edges[i]).sharedMaterial = sharedMaterial;
				}
			}
		}

		public void Hide()
		{
			if ((Object)(object)_cube != (Object)null)
			{
				_cube.SetActive(false);
			}
			if ((Object)(object)_outlineRoot != (Object)null)
			{
				_outlineRoot.SetActive(false);
			}
		}
	}
	public class BlockUI : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <_InitLate>d__15 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public BlockUI <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.EnsureUI();
					<>4__this.Refresh(pulse: true);
					<>4__this.ShowPanel();
					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 Func<BlockKind> _getSelected;

		private BlockSystem _sys;

		private RawImage _icon;

		private Text _label;

		private CanvasGroup _panelGroup;

		private Canvas _canvas;

		private GameObject _panel;

		private float _pulseUntil;

		private bool _initialized;

		private bool _building;

		private bool _isPulsing;

		private float _fadeT;

		public bool IsVisible => (Object)(object)_panel != (Object)null && _panel.activeSelf;

		public void Init(Func<BlockKind> selected, BlockSystem sys)
		{
			_getSelected = selected;
			_sys = sys;
			((MonoBehaviour)this).StartCoroutine(_InitLate());
		}

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

		private void EnsureUI()
		{
			if (_initialized || _building)
			{
				return;
			}
			_building = true;
			try
			{
				BuildUI();
				_initialized = true;
				ManualLogSource log = EmpressMinecraftLitePlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[MinecraftLite] Block UI initialized");
				}
			}
			finally
			{
				_building = false;
			}
		}

		private void BuildUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Expected O, but got Unknown
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Empress_BlockCanvas");
			Object.DontDestroyOnLoad((Object)(object)val);
			_canvas = val.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.overrideSorting = true;
			_canvas.sortingOrder = 32767;
			CanvasScaler val2 = val.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.screenMatchMode = (ScreenMatchMode)0;
			val2.matchWidthOrHeight = 0.5f;
			val.AddComponent<GraphicRaycaster>().blockingObjects = (BlockingObjects)0;
			_panel = new GameObject("Panel");
			_panel.transform.SetParent(val.transform, false);
			RectTransform val3 = _panel.AddComponent<RectTransform>();
			val3.anchorMin = new Vector2(0.5f, 0f);
			val3.anchorMax = new Vector2(0.5f, 0f);
			val3.pivot = new Vector2(0.5f, 0f);
			val3.anchoredPosition = new Vector2(0f, 16f);
			val3.sizeDelta = new Vector2(280f, 64f);
			Image val4 = _panel.AddComponent<Image>();
			((Graphic)val4).color = new Color(0f, 0f, 0f, 0.75f);
			_panelGroup = _panel.AddComponent<CanvasGroup>();
			_panelGroup.alpha = 0.9f;
			GameObject val5 = new GameObject("Icon");
			val5.transform.SetParent(_panel.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			val6.anchorMin = new Vector2(0f, 0f);
			val6.anchorMax = new Vector2(0f, 1f);
			val6.pivot = new Vector2(0f, 0.5f);
			val6.anchoredPosition = new Vector2(8f, 0f);
			val6.sizeDelta = new Vector2(48f, 48f);
			_icon = val5.AddComponent<RawImage>();
			((Graphic)_icon).raycastTarget = false;
			_icon.texture = null;
			((Graphic)_icon).color = Color.white;
			((Behaviour)_icon).enabled = false;
			GameObject val7 = new GameObject("Label");
			val7.transform.SetParent(_panel.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = new Vector2(0f, 0f);
			val8.anchorMax = new Vector2(1f, 1f);
			val8.pivot = new Vector2(0.5f, 0.5f);
			val8.anchoredPosition = new Vector2(32f, 0f);
			val8.sizeDelta = new Vector2(-72f, 0f);
			_label = val7.AddComponent<Text>();
			_label.text = "";
			_label.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			_label.fontSize = 18;
			_label.alignment = (TextAnchor)3;
			((Graphic)_label).color = Color.white;
			((Graphic)_label).raycastTarget = false;
			_panel.SetActive(true);
		}

		public void Refresh(bool pulse = false)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			if (!_initialized)
			{
				EnsureUI();
			}
			if (_initialized && !((Object)(object)_label == (Object)null))
			{
				BlockKind blockKind = _getSelected?.Invoke();
				string text = blockKind?.Id ?? "(none)";
				_label.text = "Selected: " + text;
				if (blockKind != null && (Object)(object)blockKind.Texture != (Object)null && (Object)(object)_icon != (Object)null)
				{
					_icon.texture = (Texture)(object)blockKind.Texture;
					((Behaviour)_icon).enabled = true;
					_icon.uvRect = new Rect(0f, 0f, 1f, 1f);
				}
				else if ((Object)(object)_icon != (Object)null)
				{
					_icon.texture = null;
					((Behaviour)_icon).enabled = false;
				}
				if (pulse && (Object)(object)_panelGroup != (Object)null)
				{
					Pulse();
				}
			}
		}

		public void ShowPanel()
		{
			if (_initialized)
			{
				if ((Object)(object)_panel != (Object)null && !_panel.activeSelf)
				{
					_panel.SetActive(true);
				}
				if ((Object)(object)_panelGroup != (Object)null)
				{
					_panelGroup.alpha = 0.9f;
				}
			}
		}

		public void HidePanel()
		{
			if (_initialized && (Object)(object)_panel != (Object)null && _panel.activeSelf)
			{
				_panel.SetActive(false);
			}
		}

		private void Pulse()
		{
			if (!((Object)(object)_panelGroup == (Object)null))
			{
				_isPulsing = true;
				_fadeT = 0f;
				_panelGroup.alpha = 1f;
				_pulseUntil = Time.unscaledTime + 0.8f;
			}
		}

		private void Update()
		{
			if (!_isPulsing || (Object)(object)_panelGroup == (Object)null || !IsVisible)
			{
				return;
			}
			if (Time.unscaledTime < _pulseUntil)
			{
				_panelGroup.alpha = 1f;
				return;
			}
			_fadeT += Time.unscaledDeltaTime;
			if (_fadeT < 0.2f)
			{
				_panelGroup.alpha = Mathf.Lerp(1f, 0.9f, _fadeT / 0.2f);
				return;
			}
			_panelGroup.alpha = 0.9f;
			_isPulsing = false;
		}
	}
}