using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using DunGen;
using GameNetcodeStuff;
using HarmonyLib;
using LethalCompanyInputUtils.Api;
using LethalConfig;
using LethalConfig.ConfigItems;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("DunGen")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Ratijas.ScrapValueDetector67")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("6.7.67.0")]
[assembly: AssemblyInformationalVersion("6.7.67+ba587a6af15c731d3d32386ab01503c2a301e3a0")]
[assembly: AssemblyProduct("ScrapValueDetector67")]
[assembly: AssemblyTitle("Ratijas.ScrapValueDetector67")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("6.7.67.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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		private readonly string <Name>k__BackingField;

		public string Name => <Name>k__BackingField;

		public ExtensionMarkerAttribute(string name)
		{
			<Name>k__BackingField = name;
		}
	}
}
namespace ScrapValueDetector67
{
	internal static class BoxTableFormatter
	{
		private class BoxTableFormatterInternal
		{
			[CompilerGenerated]
			private int <tableWidth>P;

			public const int HORIZONTAL_PADDING = 4;

			public int ContentWidth => <tableWidth>P - 4;

			public BoxTableFormatterInternal(int tableWidth)
			{
				<tableWidth>P = tableWidth;
				base..ctor();
			}

			public string FormatTableHeader()
			{
				return FormatSimpleRepeat('╒', '═', '╕');
			}

			public string FormatTableHeader(string text)
			{
				return FormatTableRowCentered('│', text, '│');
			}

			public string FormatTableSeparator()
			{
				return FormatSimpleRepeat('╞', '═', '╡');
			}

			public string FormatTableFooter()
			{
				return FormatSimpleRepeat('╘', '═', '╛');
			}

			public string FormatTableRow(string text)
			{
				return FormatTableRowLeftAligned('│', text, '│');
			}

			private string FormatSimpleRepeat(char start, char middle, char end)
			{
				StringBuilder stringBuilder = new StringBuilder(<tableWidth>P);
				stringBuilder.Append(start);
				int num = <tableWidth>P - 2;
				for (int i = 0; i < num; i++)
				{
					stringBuilder.Append(middle);
				}
				stringBuilder.Append(end);
				return stringBuilder.ToString();
			}

			private string FormatTableRowCentered(char start, string middle, char end)
			{
				StringBuilder stringBuilder = new StringBuilder(<tableWidth>P);
				stringBuilder.Append(start);
				stringBuilder.Append(' ');
				int num = (ContentWidth - middle.Length) / 2;
				if (num < 0)
				{
					stringBuilder.Append(middle);
				}
				else
				{
					for (int i = 0; i < num; i++)
					{
						stringBuilder.Append(' ');
					}
					stringBuilder.Append(middle);
					for (int j = num + middle.Length; j < ContentWidth; j++)
					{
						stringBuilder.Append(' ');
					}
				}
				stringBuilder.Append(' ');
				stringBuilder.Append(end);
				return stringBuilder.ToString();
			}

			private string FormatTableRowLeftAligned(char start, string middle, char end)
			{
				StringBuilder stringBuilder = new StringBuilder(<tableWidth>P);
				stringBuilder.Append(start);
				stringBuilder.Append(' ');
				stringBuilder.Append(middle);
				for (int i = middle.Length; i < ContentWidth; i++)
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(' ');
				stringBuilder.Append(end);
				return stringBuilder.ToString();
			}
		}

		[CompilerGenerated]
		private sealed class <FormatBoxTable>d__0 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string header;

			public string <>3__header;

			private string[] rows;

			public string[] <>3__rows;

			private int minWidth;

			public int <>3__minWidth;

			private int maxWidth;

			public int <>3__maxWidth;

			private BoxTableFormatterInternal <formatter>5__2;

			private int <contentWidth>5__3;

			private string[] <>7__wrap3;

			private int <>7__wrap4;

			private string[] <>7__wrap5;

			private int <>7__wrap6;

			private string[] <>7__wrap7;

			private int <>7__wrap8;

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

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

			[DebuggerHidden]
			public <FormatBoxTable>d__0(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<formatter>5__2 = null;
				<>7__wrap3 = null;
				<>7__wrap5 = null;
				<>7__wrap7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					int num = Math.Max(header.Length, (rows.Length != 0) ? rows.Max((string row) => row.Length) : 0);
					int tableWidth = Math.Clamp(num + 4, minWidth, maxWidth);
					<formatter>5__2 = new BoxTableFormatterInternal(tableWidth);
					<contentWidth>5__3 = <formatter>5__2.ContentWidth;
					<>2__current = <formatter>5__2.FormatTableHeader();
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					<>2__current = <formatter>5__2.FormatTableHeader(header);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = <formatter>5__2.FormatTableSeparator();
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>7__wrap3 = rows;
					<>7__wrap4 = 0;
					goto IL_0206;
				case 4:
					<>1__state = -1;
					<>7__wrap8++;
					goto IL_01b9;
				case 5:
					{
						<>1__state = -1;
						return false;
					}
					IL_0206:
					if (<>7__wrap4 < <>7__wrap3.Length)
					{
						string str = <>7__wrap3[<>7__wrap4];
						<>7__wrap5 = str.SplitLines();
						<>7__wrap6 = 0;
						goto IL_01de;
					}
					<>7__wrap3 = null;
					<>2__current = <formatter>5__2.FormatTableFooter();
					<>1__state = 5;
					return true;
					IL_01de:
					if (<>7__wrap6 < <>7__wrap5.Length)
					{
						string str2 = <>7__wrap5[<>7__wrap6];
						<>7__wrap7 = str2.WrapLines(<contentWidth>5__3);
						<>7__wrap8 = 0;
						goto IL_01b9;
					}
					<>7__wrap5 = null;
					<>7__wrap4++;
					goto IL_0206;
					IL_01b9:
					if (<>7__wrap8 < <>7__wrap7.Length)
					{
						string text = <>7__wrap7[<>7__wrap8];
						<>2__current = <formatter>5__2.FormatTableRow(text);
						<>1__state = 4;
						return true;
					}
					<>7__wrap7 = null;
					<>7__wrap6++;
					goto IL_01de;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<FormatBoxTable>d__0 <FormatBoxTable>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<FormatBoxTable>d__ = this;
				}
				else
				{
					<FormatBoxTable>d__ = new <FormatBoxTable>d__0(0);
				}
				<FormatBoxTable>d__.header = <>3__header;
				<FormatBoxTable>d__.rows = <>3__rows;
				<FormatBoxTable>d__.minWidth = <>3__minWidth;
				<FormatBoxTable>d__.maxWidth = <>3__maxWidth;
				return <FormatBoxTable>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		[IteratorStateMachine(typeof(<FormatBoxTable>d__0))]
		public static IEnumerable<string> FormatBoxTable(string header, string[] rows, int minWidth, int maxWidth)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FormatBoxTable>d__0(-2)
			{
				<>3__header = header,
				<>3__rows = rows,
				<>3__minWidth = minWidth,
				<>3__maxWidth = maxWidth
			};
		}
	}
	internal class Config
	{
		public int[] TargetValues { get; private set; } = Array.Empty<int>();


		public Config(ConfigFile configFile)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			Config config = this;
			string text = "General";
			ConfigEntry<string> entry = configFile.Bind<string>(text, "TargetValue", "67, 69", new ConfigDescription("Notify when scrap of this value spawns", (AcceptableValueBase)null, Array.Empty<object>()));
			LethalConfigCompatibility.AddTextInputFieldConfigItemSafe(entry, requiresRestart: false);
			entry.SettingChanged += delegate
			{
				apply();
			};
			apply();
			void apply()
			{
				config.TargetValues = config.ParseIntList(entry.Value);
				Plugin.Log.LogDebug((object)("TargetValues: " + string.Join(", ", config.TargetValues)));
			}
		}

		private int[] ParseIntList(string str)
		{
			List<int> list = new List<int>();
			string[] array = str.Split(",");
			foreach (string s in array)
			{
				if (int.TryParse(s, out var result))
				{
					list.Add(result);
				}
			}
			return list.ToArray();
		}
	}
	public class ScrapValueDetectorInputActions : LcInputActions
	{
		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction DetectKey { get; set; }
	}
	internal static class LethalConfigCompatibility
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void AddTextInputFieldConfigItemSafe(ConfigEntry<string> entry, bool requiresRestart = true)
		{
			if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
			{
				AddTextInputFieldConfigItemUnsafe(entry, requiresRestart);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void AddTextInputFieldConfigItemUnsafe(ConfigEntry<string> entry, bool requiresRestart)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			LethalConfigManager.AddConfigItem((BaseConfigItem)new TextInputFieldConfigItem(entry, requiresRestart));
		}
	}
	internal static class LethalDunGenUtils
	{
		public class TilesAndBounds
		{
			[CompilerGenerated]
			private (Tile, Bounds)[] <list>P;

			public TilesAndBounds((Tile, Bounds)[] list)
			{
				<list>P = list;
				base..ctor();
			}

			public Tile? FindTileContaining(GrabbableObject item)
			{
				//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_0027: Unknown result type (might be due to invalid IL or missing references)
				(Tile, Bounds)[] array = <list>P;
				for (int i = 0; i < array.Length; i++)
				{
					var (result, val) = array[i];
					if (((Bounds)(ref val)).Contains(((Component)item).transform.position))
					{
						return result;
					}
				}
				return null;
			}
		}

		public static GameObject? FindDungeonRoot(this RoundManager self)
		{
			List<(Tile, Bounds)> list = new List<(Tile, Bounds)>();
			GameObject val = null;
			if ((Object)(object)self.dungeonGenerator != (Object)null)
			{
				val = self.dungeonGenerator.Root;
			}
			if ((Object)(object)val == (Object)null)
			{
				val = GameObject.Find("/Systems/LevelGeneration/LevelGenerationRoot");
			}
			return val;
		}

		public static TilesAndBounds FindTilesAndBounds(GameObject dungeonRoot)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)dungeonRoot == (Object)null)
			{
				return new TilesAndBounds(Array.Empty<(Tile, Bounds)>());
			}
			List<(Tile, Bounds)> list = new List<(Tile, Bounds)>();
			Tile[] componentsInChildren = dungeonRoot.GetComponentsInChildren<Tile>();
			foreach (Tile val in componentsInChildren)
			{
				list.Add((val, val.OverrideAutomaticTileBounds ? UnityUtil.TransformBounds(((Component)val).transform, val.TileBoundsOverride) : val.Bounds));
			}
			return new TilesAndBounds(list.ToArray());
		}

		public static TilesAndBounds FindTilesAndBounds()
		{
			GameObject val = RoundManager.Instance.FindDungeonRoot();
			if ((Object)(object)val == (Object)null)
			{
				return new TilesAndBounds(Array.Empty<(Tile, Bounds)>());
			}
			return FindTilesAndBounds(val);
		}
	}
	internal static class NotificationManager
	{
		[CompilerGenerated]
		private sealed class <DelayedHUDReporterCoroutine>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SpawnedScrapItem[] items;

			private SpawnedScrapItem[] <>7__wrap1;

			private int <>7__wrap2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = _waitForSeconds1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>7__wrap1 = items;
					<>7__wrap2 = 0;
					break;
				case 2:
					<>1__state = -1;
					<>7__wrap2++;
					break;
				}
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					SpawnedScrapItem spawnedScrapItem = <>7__wrap1[<>7__wrap2];
					HUDManager.Instance.DisplayTip("OMFG! Lucky scrap spawned!", $"{spawnedScrapItem.Name} worth ${spawnedScrapItem.Value}\n" + "Located in " + spawnedScrapItem.TileName, false, false, "LC_Tip1");
					<>2__current = _waitForSeconds5;
					<>1__state = 2;
					return true;
				}
				<>7__wrap1 = null;
				return false;
			}

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

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

		private static readonly WaitForSeconds _waitForSeconds5 = new WaitForSeconds(5f);

		private static readonly WaitForSeconds _waitForSeconds1 = new WaitForSeconds(1f);

		public static void ReportAllProbabilities()
		{
			List<Item> list = new List<Item>();
			List<int> list2 = new List<int>();
			List<string> list3 = new List<string>();
			foreach (SpawnableItemWithRarity item in RoundManager.Instance.currentLevel.spawnableScrap)
			{
				list.Add(item.spawnableItem);
				list2.Add(item.rarity);
			}
			int num = list2.Sum();
			float num2 = 0f;
			for (int i = 0; i < list.Count; i++)
			{
				float num3 = (float)list2[i] / (float)num;
				int minValue = list[i].minValue;
				int maxValue = list[i].maxValue;
				int num4 = maxValue - minValue + 1;
				int[] targetValues = Plugin.Config.TargetValues;
				foreach (int num5 in targetValues)
				{
					if (num5 >= minValue && num5 <= maxValue)
					{
						float num6 = num3 / (float)num4;
						num2 += num6;
						list3.Add($"{i}, {minValue}, {maxValue}, {num6:N4}, {list[i].itemName}");
					}
				}
			}
			list3.Add($"Total: {num2}");
			foreach (string item2 in BoxTableFormatter.FormatBoxTable("Probabilities", list3.ToArray(), 40, 80))
			{
				Plugin.Log.LogInfo((object)item2);
			}
		}

		public static void Report(SpawnedScrapItem[] items)
		{
			ReportConsole(items);
			ReportHUD(items);
		}

		private static void ReportHUD(SpawnedScrapItem[] items)
		{
			((MonoBehaviour)HUDManager.Instance).StartCoroutine(DelayedHUDReporterCoroutine(items));
		}

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

		private static void ReportConsole(SpawnedScrapItem[] items)
		{
			string header = "< Scrap Value Detector >";
			List<string> list = new List<string>(items.Length * 3);
			for (int i = 0; i < items.Length; i++)
			{
				SpawnedScrapItem spawnedScrapItem = items[i];
				if (i != 0)
				{
					list.Add("");
				}
				list.Add($"Detected {spawnedScrapItem.Name} Worth ${spawnedScrapItem.Value}");
				list.Add("Located in " + spawnedScrapItem.TileName);
			}
			if (items.Length == 0)
			{
				list.Add("No valuable items detected");
			}
			foreach (string item in BoxTableFormatter.FormatBoxTable(header, list.ToArray(), 40, 80))
			{
				Plugin.Log.LogInfo((object)item);
			}
		}
	}
	internal readonly struct SpawnedScrapItem
	{
		[CompilerGenerated]
		private readonly GrabbableObject <GrabbableObject>P;

		public Item Item => <GrabbableObject>P.itemProperties;

		public string Name => Item.itemName;

		public int Value => <GrabbableObject>P.scrapValue;

		public string TileName { get; }

		public SpawnedScrapItem(GrabbableObject GrabbableObject, string TileName)
		{
			<GrabbableObject>P = GrabbableObject;
			this.TileName = TileName;
		}
	}
	[HarmonyPatch(typeof(GiftBoxItem))]
	internal static class GiftBoxPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("OpenGiftBoxClientRpc")]
		private static void SpawnScrapInLevelPrefixPatch(GiftBoxItem __instance, NetworkObjectReference netObjectRef, int presentValue, Vector3 startFallingPos, out __RpcExecStage __state)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected I4, but got Unknown
			__state = (__RpcExecStage)(int)((NetworkBehaviour)__instance).__rpc_exec_stage;
		}

		[HarmonyPostfix]
		[HarmonyPatch("OpenGiftBoxClientRpc")]
		private static void SpawnScrapInLevelPostfixPatch(GiftBoxItem __instance, NetworkObjectReference netObjectRef, int presentValue, Vector3 startFallingPos, __RpcExecStage __state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__state == 1)
			{
				((MonoBehaviour)__instance).StartCoroutine(__instance.DetectValuableScrap(netObjectRef));
			}
		}
	}
	internal static class GiftBoxExtensions
	{
		[SpecialName]
		public sealed class <G>$F8345873646F110A4436DEE177F2D532
		{
			[SpecialName]
			public static class <M>$A0B2C7B1B8F7FAE12BE9B0666051C2AC
			{
			}

			[ExtensionMarker("<M>$A0B2C7B1B8F7FAE12BE9B0666051C2AC")]
			public IEnumerator DetectValuableScrap(NetworkObjectReference netObjectRef)
			{
				throw new NotSupportedException();
			}
		}

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

			private object <>2__current;

			public NetworkObjectReference netObjectRef;

			private NetworkObject <netObject>5__2;

			private float <startTime>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<netObject>5__2 = null;
					<startTime>5__3 = Time.realtimeSinceStartup;
					goto IL_0051;
				case 1:
					<>1__state = -1;
					goto IL_0051;
				case 2:
					{
						<>1__state = -1;
						GrabbableObject val = default(GrabbableObject);
						if (!((Component)<netObject>5__2).TryGetComponent<GrabbableObject>(ref val))
						{
							return false;
						}
						LethalDunGenUtils.TilesAndBounds tilesAndBounds = LethalDunGenUtils.FindTilesAndBounds();
						if (!Plugin.Config.TargetValues.Contains(val.scrapValue))
						{
							return false;
						}
						Tile self = tilesAndBounds.FindTileContaining(val);
						string tileName = self.PrettyName();
						SpawnedScrapItem spawnedScrapItem = new SpawnedScrapItem(val, tileName);
						NotificationManager.Report(new SpawnedScrapItem[1] { spawnedScrapItem });
						return false;
					}
					IL_0051:
					if (Time.realtimeSinceStartup - <startTime>5__3 < 8f && !((NetworkObjectReference)(ref netObjectRef)).TryGet(ref <netObject>5__2, (NetworkManager)null))
					{
						<>2__current = _waitForSeconds0_03;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)<netObject>5__2 == (Object)null)
					{
						return false;
					}
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				}
			}

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

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

		private static readonly WaitForSeconds _waitForSeconds0_03 = new WaitForSeconds(0.03f);

		[IteratorStateMachine(typeof(<DetectValuableScrap>d__2))]
		public static IEnumerator DetectValuableScrap(this GiftBoxItem self, NetworkObjectReference netObjectRef)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DetectValuableScrap>d__2(0)
			{
				netObjectRef = netObjectRef
			};
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	internal static class HUDManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnEnable")]
		private static void OnEnablePrefix(HUDManager __instance)
		{
			Plugin.InputActionsInstance.DetectKey.performed += __instance.DetectValuableScrap_performed;
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnDisable")]
		private static void OnDisablePrefix(HUDManager __instance)
		{
			Plugin.InputActionsInstance.DetectKey.performed -= __instance.DetectValuableScrap_performed;
		}

		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		private static void UpdatePostfix(HUDManager __instance)
		{
			if (HUDManagerExtensions.replacePingingScanWithValuableScrapTimer > 0f)
			{
				HUDManagerExtensions.replacePingingScanWithValuableScrapTimer -= Time.deltaTime;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("AssignNewNodes")]
		private static bool AssignNewNodesPrefix(HUDManager __instance, PlayerControllerB playerScript)
		{
			foreach (ScanNodeProperties item in __instance.nodesOnScreen)
			{
				item.ClearDistanceHint();
			}
			if (HUDManagerExtensions.replacePingingScanWithValuableScrapTimer <= 0f)
			{
				return true;
			}
			__instance.AssignNewValuableNodes_NoCast(playerScript);
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch("PingScan_performed")]
		private static void PingScan_performedPrefix(CallbackContext context)
		{
			HUDManagerExtensions.replacePingingScanWithValuableScrapTimer = 0f;
		}
	}
	internal static class HUDManagerExtensions
	{
		[SpecialName]
		public sealed class <G>$0ABFCA468B010F10941E8D3AFD4DF38A
		{
			[SpecialName]
			public static class <M>$DBC100433FB32BFD83416BE321C142C4
			{
			}

			[ExtensionMarker("<M>$DBC100433FB32BFD83416BE321C142C4")]
			public void AssignNewValuableNodes_NoCast(PlayerControllerB playerScript)
			{
				throw new NotSupportedException();
			}

			[ExtensionMarker("<M>$DBC100433FB32BFD83416BE321C142C4")]
			public void AttemptScanValuableNode(ScanNodeProperties node, PlayerControllerB playerScript)
			{
				throw new NotSupportedException();
			}

			[ExtensionMarker("<M>$DBC100433FB32BFD83416BE321C142C4")]
			public bool MeetsScanValuableNodeRequirements(ScanNodeProperties node, PlayerControllerB playerScript)
			{
				throw new NotSupportedException();
			}

			[ExtensionMarker("<M>$DBC100433FB32BFD83416BE321C142C4")]
			public void DetectValuableScrap_performed(CallbackContext context)
			{
				throw new NotSupportedException();
			}
		}

		public static float detectorPingingScan;

		public static float replacePingingScanWithValuableScrapTimer;

		public static void AssignNewValuableNodes_NoCast(this HUDManager self, PlayerControllerB playerScript)
		{
			ScanNodeProperties[] array = Object.FindObjectsOfType<ScanNodeProperties>();
			self.nodesOnScreen.Clear();
			self.scannedScrapNum = 0;
			ScanNodeProperties[] array2 = array;
			foreach (ScanNodeProperties node in array2)
			{
				self.AttemptScanValuableNode(node, playerScript);
				if (self.nodesOnScreen.Count >= self.scanElements.Length)
				{
					break;
				}
			}
		}

		public static void AttemptScanValuableNode(this HUDManager self, ScanNodeProperties node, PlayerControllerB playerScript)
		{
			if (self.MeetsScanValuableNodeRequirements(node, playerScript))
			{
				if (node.nodeType == 2)
				{
					self.scannedScrapNum++;
				}
				if (!self.nodesOnScreen.Contains(node))
				{
					self.nodesOnScreen.Add(node);
				}
				if (self.playerPingingScan >= 0f)
				{
					self.AssignNodeToUIElement(node);
				}
				node.AddDistanceHint(playerScript);
			}
		}

		public static bool MeetsScanValuableNodeRequirements(this HUDManager self, ScanNodeProperties node, PlayerControllerB playerScript)
		{
			//IL_005f: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)node == (Object)null)
			{
				return false;
			}
			if (node.nodeType != 2)
			{
				return false;
			}
			if (!Plugin.Config.TargetValues.Contains(node.scrapValue))
			{
				return false;
			}
			GrabbableObject componentInParent = ((Component)node).GetComponentInParent<GrabbableObject>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return false;
			}
			if ((Object)(object)componentInParent.playerHeldBy == (Object)(object)playerScript)
			{
				return false;
			}
			Camera gameplayCamera = playerScript.gameplayCamera;
			Vector3 val = gameplayCamera.WorldToViewportPoint(((Component)componentInParent).transform.position);
			if (val.x < 0f || val.x > 1f || val.y < 0f || val.y > 1f || val.z < 0f)
			{
				return false;
			}
			return true;
		}

		public static void DetectValuableScrap_performed(this HUDManager self, CallbackContext context)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			HUDManager instance = HUDManager.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.PingScan_performed(context);
				replacePingingScanWithValuableScrapTimer = 5f;
			}
		}
	}
	internal static class ScanNodePropertiesExtensions
	{
		[SpecialName]
		public sealed class <G>$9B07504E30D3AC2D0B45AEE537383467
		{
			[SpecialName]
			public static class <M>$32EA96B722A95F78847ED5BAF3703422
			{
			}

			[ExtensionMarker("<M>$32EA96B722A95F78847ED5BAF3703422")]
			public void AddDistanceHint(PlayerControllerB playerScript)
			{
				throw new NotSupportedException();
			}

			[ExtensionMarker("<M>$32EA96B722A95F78847ED5BAF3703422")]
			public void ClearDistanceHint()
			{
				throw new NotSupportedException();
			}
		}

		public static void AddDistanceHint(this ScanNodeProperties self, PlayerControllerB playerScript)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			self.ClearDistanceHint();
			GrabbableObject componentInParent = ((Component)self).GetComponentInParent<GrabbableObject>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				float num = Vector3.Distance(((Component)playerScript).transform.position, ((Component)componentInParent).transform.position);
				float num2 = Mathf.Round(num * 10f) / 10f;
				self.subText += $"\n(distance: {num2:F1})";
			}
		}

		public static void ClearDistanceHint(this ScanNodeProperties self)
		{
			int num = self.subText.IndexOf("\n(distance: ");
			if (num != -1)
			{
				self.subText = self.subText.Substring(0, num);
			}
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal static class RoundManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("SyncScrapValuesClientRpc")]
		private static void SpawnScrapInLevelPrefixPatch(RoundManager __instance, NetworkObjectReference[] spawnedScrap, int[] allScrapValue, out __RpcExecStage __state)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected I4, but got Unknown
			__state = (__RpcExecStage)(int)((NetworkBehaviour)__instance).__rpc_exec_stage;
		}

		[HarmonyPostfix]
		[HarmonyPatch("SyncScrapValuesClientRpc")]
		private static void SpawnScrapInLevelPostfixPatch(RoundManager __instance, NetworkObjectReference[] spawnedScrap, int[] allScrapValue, __RpcExecStage __state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)__state != 1)
			{
				return;
			}
			List<SpawnedScrapItem> list = new List<SpawnedScrapItem>();
			LethalDunGenUtils.TilesAndBounds tilesAndBounds = LethalDunGenUtils.FindTilesAndBounds();
			NetworkObject val = default(NetworkObject);
			GrabbableObject val2 = default(GrabbableObject);
			for (int i = 0; i < spawnedScrap.Length; i++)
			{
				if (((NetworkObjectReference)(ref spawnedScrap[i])).TryGet(ref val, (NetworkManager)null) && ((Component)val).TryGetComponent<GrabbableObject>(ref val2) && Plugin.Config.TargetValues.Contains(val2.scrapValue))
				{
					Tile self = tilesAndBounds.FindTileContaining(val2);
					string tileName = self.PrettyName();
					SpawnedScrapItem item = new SpawnedScrapItem(val2, tileName);
					list.Add(item);
				}
			}
			NotificationManager.Report(list.ToArray());
		}
	}
	[BepInPlugin("Ratijas.ScrapValueDetector67", "ScrapValueDetector67", "6.7.67")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		internal static ScrapValueDetectorInputActions InputActionsInstance;

		private static Harmony Harmony;

		internal static Config Config { get; private set; }

		private void Awake()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			InputActionsInstance = new ScrapValueDetectorInputActions();
			Config = new Config(((BaseUnityPlugin)this).Config);
			Harmony = new Harmony("ScrapValueDetector67");
			Harmony.PatchAll();
		}
	}
	internal static class StringExtensions
	{
		public static string PadMiddle(this string str, int totalWidth)
		{
			return str.PadLeft(totalWidth / 2).PadRight(totalWidth);
		}

		public static string Repeat(this char chatToRepeat, int repeat)
		{
			return new string(chatToRepeat, repeat);
		}

		public static string Repeat(this string stringToRepeat, int repeat)
		{
			StringBuilder stringBuilder = new StringBuilder(repeat * stringToRepeat.Length);
			for (int i = 0; i < repeat; i++)
			{
				stringBuilder.Append(stringToRepeat);
			}
			return stringBuilder.ToString();
		}

		public static string[] SplitLines(this string str)
		{
			return str.Split('\n');
		}

		public static string[] WrapLines(this string str, int maxWidth)
		{
			List<string> list = new List<string>((int)Math.Ceiling((float)str.Length / (float)maxWidth));
			ReadOnlySpan<char> span = str.AsSpan();
			while (span.Length > maxWidth)
			{
				int num = span.Slice(0, maxWidth).LastIndexOf(' ');
				int num2 = ((num == -1) ? maxWidth : Math.Min(num, maxWidth));
				ReadOnlySpan<char> span2 = span.Slice(0, num2);
				int num3 = num2;
				span = span.Slice(num3, span.Length - num3);
				list.Add(span2.Trim().ToString());
			}
			list.Add(span.Trim().ToString());
			return list.ToArray();
		}
	}
	internal static class TileExtensions
	{
		[SpecialName]
		public sealed class <G>$6D6CC2FFC067E3E657D2E9EF47862B9D
		{
			[SpecialName]
			public static class <M>$87131BAECBC5787F7F5BCFCB40AA4315
			{
			}

			[ExtensionMarker("<M>$87131BAECBC5787F7F5BCFCB40AA4315")]
			public string PrettyName()
			{
				throw new NotSupportedException();
			}
		}

		public static string PrettyName(this Tile? self)
		{
			string text = "unknown";
			if ((Object)(object)self != (Object)null)
			{
				text = ((Object)self).name;
				if (text.EndsWith("(Clone)"))
				{
					ReadOnlySpan<char> readOnlySpan = text.AsSpan();
					int length = "(Clone)".Length;
					text = readOnlySpan.Slice(0, readOnlySpan.Length - length).Trim().ToString();
				}
			}
			return text;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Ratijas.ScrapValueDetector67";

		public const string PLUGIN_NAME = "ScrapValueDetector67";

		public const string PLUGIN_VERSION = "6.7.67";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}