using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LethalCompanyInputUtils.Api;
using Newtonsoft.Json;
using TerminalApi;
using TerminalApi.Events;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LethalAutocomplete")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LethalAutocomplete")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("B5A3A159-6BFF-43BE-840B-173ABE0E1D7F")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace LethalAutocomplete;

public class WordNode
{
	public string Word { get; set; }

	public List<WordNode> Children { get; set; }

	public int Weight { get; set; }

	public WordNode(string word, int weight)
	{
		Word = word;
		Weight = weight;
		Children = new List<WordNode>();
	}

	public List<WordNode> FindMatchingWords(string[] inputs)
	{
		List<WordNode> list = new List<WordNode>();
		if (inputs.Length == 0 || Word.ToLower().StartsWith(inputs[0].ToLower()))
		{
			if (inputs.Length == 1)
			{
				list.Add(this);
			}
			else
			{
				foreach (WordNode child in Children)
				{
					list.AddRange(child.FindMatchingWords(inputs.Skip(1).ToArray()));
				}
			}
		}
		return list;
	}
}
public class Autocomplete
{
	private List<WordNode> _words;

	public static ManualLogSource Logger;

	private readonly int _defaultWeight = 10;

	public Autocomplete()
	{
		_words = new List<WordNode>();
	}

	public void Insert(TerminalKeyword terminalKeyword)
	{
		string name = ((Object)terminalKeyword).name;
		if (ContainsWord(name))
		{
			return;
		}
		WordNode wordNode = new WordNode(name, _defaultWeight);
		for (int i = 0; i < terminalKeyword.compatibleNouns.Length; i++)
		{
			string text = "";
			text = ((!new string[2] { "route", "info" }.Any(name.ToLower().Contains)) ? ((object)terminalKeyword.compatibleNouns[i].noun).ToString().Split(new char[1] { ' ' })[0] : terminalKeyword.compatibleNouns[i].noun.word);
			WordNode wordNode2 = new WordNode(text, _defaultWeight);
			if (name.ToLower() == "buy")
			{
				for (int j = 1; j < 10; j++)
				{
					wordNode2.Children.Add(new WordNode(j.ToString(), 10 - j));
				}
			}
			wordNode.Children.Add(wordNode2);
		}
		_words.Add(wordNode);
	}

	private bool ContainsWord(string word)
	{
		return _words.Any((WordNode node) => node.Word == word);
	}

	public List<string> GetAutocomplete(string input)
	{
		try
		{
			string[] array = input.Split(new char[1] { ' ' });
			List<WordNode> list = new List<WordNode>();
			string matching_start = "";
			for (int i = 0; i < array.Length - 1; i++)
			{
				matching_start = matching_start + array[i] + " ";
			}
			foreach (WordNode word in _words)
			{
				list.AddRange(word.FindMatchingWords(array));
			}
			list = (from n in list.Distinct()
				where n.Weight > 0
				orderby n.Weight descending
				select n).ToList();
			return list.Select((WordNode n) => matching_start + n.Word).ToList();
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"Failed on autocomplete search. Error: {arg}");
			return null;
		}
	}

	public List<WordNode> GetWords()
	{
		return _words;
	}

	public void SetWords(List<WordNode> words)
	{
		_words = new List<WordNode>(words);
	}
}
internal class AutocompleteManager
{
	private class SaveData
	{
		public List<WordNode> Words { get; set; }

		public Dictionary<string, List<string>> History { get; set; }
	}

	public static Keybinds keybinds;

	public static string saveFilePath = "";

	public static string autocompleteKey = "<Keyboard>/tab";

	public static string historyNextKey = "<Keyboard>/upArrow";

	public static string historyPrevKey = "<Keyboard>/downArrow";

	public static bool saveHistory = true;

	public static int historyMaxCount = 20;

	public bool exited;

	private Terminal _terminal;

	private string _input;

	private List<string> _terminalCommands;

	private List<string> _commandsHistory;

	private int _historyIndex;

	private string _lastAutocomplete = "";

	private bool _startedAutocomplete;

	private List<string> _autocompleteOptions;

	private int _autocompleteOptionIndex;

	public static ManualLogSource Logger;

	private Autocomplete _autocomplete;

	public void Awake()
	{
		if (Plugin.IsDebug)
		{
			Logger.LogInfo((object)("Lethal Autocomplete Plugin is loaded! Autocomplete Key: " + autocompleteKey));
		}
		_terminalCommands = new List<string>();
		_commandsHistory = new List<string>();
		_autocomplete = new Autocomplete();
		Autocomplete.Logger = Logger;
		LoadFromJson();
		SetupTerminalCallbacks();
	}

	private void OnTerminalTextChanged(object sender, TerminalTextChangedEventArgs e)
	{
		try
		{
			_input = TerminalApi.GetTerminalInput();
			_input = _input.Replace("\n", "");
			if (Plugin.IsDebug)
			{
				Logger.LogMessage((object)("OnTerminalTextChanged: " + _input));
			}
			if (_input != _lastAutocomplete)
			{
				ResetAutocomplete();
			}
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"On terminal text changed event. Error: {arg}");
		}
	}

	private void OnTerminalExit(object sender, TerminalEventArgs e)
	{
		if (Plugin.IsDebug)
		{
			Logger.LogMessage((object)"Terminal Exited");
		}
		if (!saveHistory)
		{
			_commandsHistory = new List<string>();
		}
		try
		{
			RemoveKeybindCallbacks();
			SaveToJson();
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"On terminal exit. Error: {arg}");
		}
	}

	private void TerminalIsStarting(object sender, TerminalEventArgs e)
	{
		try
		{
			if (Plugin.IsDebug)
			{
				Logger.LogMessage((object)"Terminal is starting");
			}
			_terminal = TerminalApi.Terminal;
			if (autocompleteKey.Contains("tab"))
			{
				RemoveTerminalExitBinding();
			}
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"On terminal starting. Error: {arg}");
		}
	}

	private void RemoveTerminalExitBinding()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: 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_0069: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			MovementActions movement = _terminal.playerActions.Movement;
			InputAction openMenu = ((MovementActions)(ref movement)).OpenMenu;
			if (Plugin.IsDebug)
			{
				Logger.LogMessage((object)(openMenu.name + " " + InputActionRebindingExtensions.GetBindingDisplayString(openMenu, (DisplayStringOptions)0, (string)null)));
			}
			openMenu.Disable();
			InputBinding val = default(InputBinding);
			((InputBinding)(ref val)).path = "<Keyboard>/tab";
			((InputBinding)(ref val)).overridePath = "";
			InputActionRebindingExtensions.ApplyBindingOverride(openMenu, val);
			openMenu.Enable();
			if (Plugin.IsDebug)
			{
				Logger.LogMessage((object)(openMenu.name + " " + InputActionRebindingExtensions.GetBindingDisplayString(openMenu, (DisplayStringOptions)0, (string)null)));
			}
		}
		catch (Exception ex)
		{
			Logger.LogWarning((object)"Remove terminal tab exit binded key");
			Logger.LogError((object)ex);
			throw;
		}
	}

	private void TerminalIsStarted(object sender, TerminalEventArgs e)
	{
		try
		{
			if (Plugin.IsDebug)
			{
				Logger.LogMessage((object)"Terminal is started");
			}
			_terminalCommands.Clear();
			for (int i = 0; i < _terminal.terminalNodes.allKeywords.Length; i++)
			{
				_autocomplete.Insert(_terminal.terminalNodes.allKeywords[i]);
			}
		}
		catch (Exception ex)
		{
			Logger.LogWarning((object)"Terminal is started");
			Logger.LogError((object)ex);
			throw;
		}
	}

	private void TextSubmitted(object sender, TerminalParseSentenceEventArgs e)
	{
		if (Plugin.IsDebug)
		{
			Logger.LogMessage((object)("TextSubmitted: " + _input));
		}
		try
		{
			if (e.SubmittedText != "")
			{
				if (_commandsHistory.Count + 1 > historyMaxCount)
				{
					_commandsHistory.RemoveAt(0);
				}
				_commandsHistory.Add(e.SubmittedText);
				_historyIndex = _commandsHistory.Count;
			}
			_input = "";
			ResetAutocomplete();
		}
		catch (Exception ex)
		{
			Logger.LogWarning((object)$"Text submitted: {e.SubmittedText} Node Returned: {e.ReturnedNode}");
			Logger.LogError((object)ex);
		}
	}

	private void OnBeginUsing(object sender, TerminalEventArgs e)
	{
		Logger.LogMessage((object)"Player has just started using the terminal");
		SetupKeybindCallbacks();
	}

	private void OnBeganUsing(object sender, TerminalEventArgs e)
	{
		if (autocompleteKey.Contains("tab"))
		{
			HUDManager.Instance.ChangeControlTip(0, "Quit terminal : [Esc]", true);
		}
	}

	private void SetupTerminalCallbacks()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Expected O, but got Unknown
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Expected O, but got Unknown
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Expected O, but got Unknown
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Expected O, but got Unknown
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Expected O, but got Unknown
		Events.TerminalStarting += new TerminalEventHandler(TerminalIsStarting);
		Events.TerminalStarted += new TerminalEventHandler(TerminalIsStarted);
		Events.TerminalParsedSentence += new TerminalParseSentenceEventHandler(TextSubmitted);
		Events.TerminalBeginUsing += new TerminalEventHandler(OnBeginUsing);
		Events.TerminalBeganUsing += new TerminalEventHandler(OnBeganUsing);
		Events.TerminalExited += new TerminalEventHandler(OnTerminalExit);
		Events.TerminalTextChanged += new TerminalTextChangedEventHandler(OnTerminalTextChanged);
	}

	private void SetupKeybindCallbacks()
	{
		Logger.LogMessage((object)"Setup Keybind Callbacks");
		keybinds.AutocompleteAction.performed += OnAutocompleteKey;
		keybinds.HistoryNextAction.performed += OnHistoryNextKey;
		keybinds.HistoryPrevAction.performed += OnHistoryPrevKey;
	}

	private void RemoveKeybindCallbacks()
	{
		Logger.LogMessage((object)"Remove Keybind Callbacks");
		keybinds.AutocompleteAction.performed -= OnAutocompleteKey;
		keybinds.HistoryNextAction.performed -= OnHistoryNextKey;
		keybinds.HistoryPrevAction.performed -= OnHistoryPrevKey;
	}

	private void OnHistoryNextKey(CallbackContext ctx)
	{
		TerminalApi.SetTerminalInput("");
		try
		{
			if (_commandsHistory.Count >= 1 && _historyIndex >= 1)
			{
				_historyIndex--;
				TerminalApi.SetTerminalInput(_commandsHistory[_historyIndex]);
			}
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"Failed on history next key performed. Error: {arg}");
			Logger.LogInfo((object)$"_commandsHistory.Count={_commandsHistory.Count}");
			Logger.LogInfo((object)$"historyIndex={_historyIndex}");
		}
	}

	private void OnHistoryPrevKey(CallbackContext ctx)
	{
		TerminalApi.SetTerminalInput("");
		try
		{
			if (_commandsHistory.Count >= 1)
			{
				if (_historyIndex + 1 >= _commandsHistory.Count)
				{
					_historyIndex = _commandsHistory.Count;
					TerminalApi.SetTerminalInput("");
					Logger.LogInfo((object)("INPUT: " + TerminalApi.GetTerminalInput()));
				}
				else
				{
					_historyIndex++;
					TerminalApi.SetTerminalInput(_commandsHistory[_historyIndex]);
				}
			}
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"Failed on history prev key performed. Error: {arg}");
			Logger.LogInfo((object)$"_commandsHistory.Count={_commandsHistory.Count}");
			Logger.LogInfo((object)$"historyIndex={_historyIndex}");
		}
	}

	private void OnAutocompleteKey(CallbackContext ctx)
	{
		try
		{
			if (_startedAutocomplete)
			{
				NextAutocomplete();
			}
			else
			{
				StartAutocomplete();
			}
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"Failed on autocomplete key performed. Error: {arg}");
			Logger.LogInfo((object)$"_startedAutocomplete={_startedAutocomplete}");
		}
	}

	private void StartAutocomplete()
	{
		try
		{
			List<string> autocomplete = _autocomplete.GetAutocomplete(_input);
			if (Plugin.IsDebug)
			{
				Logger.LogInfo((object)"Autocomplete options:");
				foreach (string item in autocomplete)
				{
					Logger.LogInfo((object)(item ?? ""));
				}
			}
			if (autocomplete != null && autocomplete.Count > 0)
			{
				_autocompleteOptions = new List<string>(autocomplete);
				_startedAutocomplete = true;
				_lastAutocomplete = _autocompleteOptions.First();
				Logger.LogMessage((object)("Set Autocomplete " + _lastAutocomplete));
				TerminalApi.SetTerminalInput(_lastAutocomplete);
			}
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"Failed on autocomplete new options search. Error: {arg}");
		}
	}

	private void NextAutocomplete()
	{
		try
		{
			if (Plugin.IsDebug)
			{
				Logger.LogInfo((object)"Autocomplete Options:");
				for (int i = 0; i < _autocompleteOptions.Count; i++)
				{
					Logger.LogInfo((object)_autocompleteOptions[i]);
				}
				Logger.LogInfo((object)$"Autocomplete Index: {_autocompleteOptionIndex + 1}");
			}
			_autocompleteOptionIndex++;
			if (_autocompleteOptionIndex >= _autocompleteOptions.Count)
			{
				_autocompleteOptionIndex = 0;
			}
			_lastAutocomplete = _autocompleteOptions[_autocompleteOptionIndex];
			TerminalApi.SetTerminalInput(_lastAutocomplete);
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"Failed on autocomplete next options search. Error: {arg}");
		}
	}

	private void ResetAutocomplete()
	{
		try
		{
			if (Plugin.IsDebug)
			{
				Logger.LogInfo((object)"Reset autocomplete state");
			}
			_startedAutocomplete = false;
			_autocompleteOptionIndex = 0;
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"Failed on autocomplete reset. Error: {arg}");
		}
	}

	public void SaveToJson()
	{
		string contents = JsonConvert.SerializeObject((object)new
		{
			Words = _autocomplete.GetWords(),
			History = new Dictionary<string, List<string>> { ["value"] = _commandsHistory }
		}, (Formatting)1);
		File.WriteAllText(saveFilePath, contents);
	}

	private void LoadFromJson()
	{
		try
		{
			if (!File.Exists(saveFilePath))
			{
				return;
			}
			string text = File.ReadAllText(saveFilePath);
			if (!string.IsNullOrEmpty(text))
			{
				SaveData saveData = JsonConvert.DeserializeObject<SaveData>(text);
				_commandsHistory = new List<string>(saveData.History["value"]);
				_historyIndex = _commandsHistory.Count;
				for (int i = 0; i < _commandsHistory.Count; i++)
				{
					Logger.LogInfo((object)_commandsHistory[i]);
				}
				Logger.LogInfo((object)$"_historyIndex={_historyIndex}");
				_autocomplete.SetWords(saveData.Words);
				Logger.LogMessage((object)"Loaded save from JSON!");
			}
		}
		catch (Exception arg)
		{
			Logger.LogError((object)$"Failed on loading json save file. Error: {arg}");
		}
	}
}
internal class Keybinds : LcInputActions
{
	public InputAction AutocompleteAction => ((LcInputActions)this).Asset["Autocomplete"];

	public InputAction HistoryNextAction => ((LcInputActions)this).Asset["HistoryNext"];

	public InputAction HistoryPrevAction => ((LcInputActions)this).Asset["HistoryPrev"];

	public override void CreateInputActions(in InputActionMapBuilder builder)
	{
		((LcInputActions)this).CreateInputActions(ref builder);
		builder.NewActionBinding().WithActionId("Autocomplete").WithActionType((InputActionType)1)
			.WithKbmPath(AutocompleteManager.autocompleteKey)
			.WithBindingName("Autocomplete Key")
			.Finish();
		builder.NewActionBinding().WithActionId("HistoryNext").WithActionType((InputActionType)1)
			.WithKbmPath(AutocompleteManager.historyNextKey)
			.WithBindingName("HistoryNext Key")
			.Finish();
		builder.NewActionBinding().WithActionId("HistoryPrev").WithActionType((InputActionType)1)
			.WithKbmPath(AutocompleteManager.historyPrevKey)
			.WithBindingName("HistoryPrev Key")
			.Finish();
	}
}
[BepInPlugin("redeye.lethalautocomplete", "Lethal Autocomplete", "0.4.1")]
[BepInDependency("atomic.terminalapi", "1.3.0")]
[BepInDependency("com.rune580.LethalCompanyInputUtils", "0.4.2")]
public class Plugin : BaseUnityPlugin
{
	private const string _GUID = "redeye.lethalautocomplete";

	private const string _Name = "Lethal Autocomplete";

	private const string _Version = "0.4.1";

	public static bool IsDebug;

	private AutocompleteManager _autocomplete;

	public string PluginPath = "";

	private void Awake()
	{
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Lethal Autocomplete Plugin is loaded!");
		Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), (string)null);
		try
		{
			PluginPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
		}
		try
		{
			_autocomplete = new AutocompleteManager();
			AutocompleteManager.Logger = ((BaseUnityPlugin)this).Logger;
			ConfigFile();
			AutocompleteManager.keybinds = new Keybinds();
			_autocomplete.Awake();
		}
		catch (Exception ex2)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)ex2);
		}
	}

	private void OnApplicationQuit()
	{
		_autocomplete.SaveToJson();
	}

	private void ConfigFile()
	{
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Expected O, but got Unknown
		string path = "save.json";
		string text = Path.Combine(PluginPath, path);
		string text2 = ((BaseUnityPlugin)this).Config.Bind<string>("Basic", "Save Data Path", "", "Absolute path to the json file with autocomplete words and commands history. By default save.json generated in plugins/red_eye-LethalAutocomplete folder.").Value;
		if (!File.Exists(text2) && text2 != "")
		{
			text2 = text;
			((BaseUnityPlugin)this).Config.Remove(new ConfigDefinition("Basic", "Save Data Path"));
			((BaseUnityPlugin)this).Config.Bind<string>("Basic", "Save Data Path", text, "Absolute path to the json file with autocomplete words and commands history. By default save.json generated in plugins/red_eye-LethalAutocomplete folder.");
			((BaseUnityPlugin)this).Logger.LogWarning((object)"The save file wasn't found in the directory specified by the configuration file! Using default path.");
		}
		AutocompleteManager.saveFilePath = ((text2 == "") ? text : text2);
		ConfigEntry<string> val = ((BaseUnityPlugin)this).Config.Bind<string>("Keyboard Bindings", "Autocomplete", "<Keyboard>/tab", "Get autocomplete for current input");
		AutocompleteManager.autocompleteKey = (val.Value.ToLower().StartsWith("<keyboard>") ? val.Value : ("<Keyboard>/" + val.Value));
		ConfigEntry<string> val2 = ((BaseUnityPlugin)this).Config.Bind<string>("Keyboard Bindings", "History Next", "<Keyboard>/upArrow", "Get current terminal session next command");
		AutocompleteManager.historyNextKey = (val2.Value.ToLower().StartsWith("<keyboard>") ? val2.Value : ("<Keyboard>/" + val2.Value));
		ConfigEntry<string> val3 = ((BaseUnityPlugin)this).Config.Bind<string>("Keyboard Bindings", "History Prev", "<Keyboard>/downArrow", "Get current terminal session prev command");
		AutocompleteManager.historyPrevKey = (val3.Value.ToLower().StartsWith("<keyboard>") ? val3.Value : ("<Keyboard>/" + val3.Value));
		AutocompleteManager.saveHistory = ((BaseUnityPlugin)this).Config.Bind<bool>("History", "Save History", true, "Regulates if the history be saved after the re-entry").Value;
		AutocompleteManager.historyMaxCount = ((BaseUnityPlugin)this).Config.Bind<int>("History", "Buffer Length", 20, "Max amount of commands to remember during terminal session").Value;
		IsDebug = ((BaseUnityPlugin)this).Config.Bind<bool>("Other", "Enable Debug", false, "").Value;
	}
}

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.InteropServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("BetterItemScan")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BetterItemScan")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("04cd6816-7aba-4c14-a9a7-bf328df25692")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BetterItemScan
{
	[BepInPlugin("PopleZoo.BetterItemScan", "Better Item Scan", "2.1.0.0")]
	public class BetterItemScanModBase : BaseUnityPlugin
	{
		private const string modGUID = "PopleZoo.BetterItemScan";

		private const string modName = "Better Item Scan";

		private const string modVersion = "2.1.0.0";

		private readonly Harmony harmony = new Harmony("PopleZoo.BetterItemScan");

		public static BetterItemScanModBase Instance;

		public ManualLogSource mls;

		public static ConfigEntry<float> ItemScanRadius;

		public static ConfigEntry<float> AdjustScreenPositionXaxis;

		public static ConfigEntry<float> AdjustScreenPositionYaxis;

		public static ConfigEntry<float> ItemScaningUICooldown;

		public static ConfigEntry<float> FontSize;

		public static ConfigEntry<bool> ShowDebugMode;

		public static ConfigEntry<bool> ShowShipTotalOnShipOnly;

		public static ConfigEntry<bool> ShowTotalOnShipOnly;

		public static ConfigEntry<bool> CalculateForQuota;

		public static ConfigEntry<string> ItemTextColorHex;

		public static ConfigEntry<string> ItemTextCalculatorColorHex;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("PopleZoo.BetterItemScan");
			mls.LogInfo((object)"Plugin BetterItemScan is loaded!");
			LoadConfigs();
			harmony.PatchAll();
		}

		private void LoadConfigs()
		{
			ShowDebugMode = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "ShowDebugMode", false, "Shows the change in width of the area to scan");
			ShowShipTotalOnShipOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "ShowShipTotalOnShipOnly", false, "Whether or not to show the ship's total only in the ship");
			ShowTotalOnShipOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "ShowTotalOnShipOnly", false, "Whether or not to show the total scanned in the ship only");
			CalculateForQuota = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "CalculateForQuota", true, "Whether or not to calculate scanned items to see which meet the quota and if any do");
			ItemScanRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "ItemScanRadius", 20f, "The default width is 20");
			FontSize = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "FontSize", 20f, "The default font size is 20, to make/see this change you may have to do this manually in the config file itself in the bepinex folder");
			ItemTextColorHex = ((BaseUnityPlugin)this).Config.Bind<string>("Settings", "ItemTextColorHex", "#78FFAE", "The default text color for items that have been scanned, value must be a hexadecimal");
			ItemTextCalculatorColorHex = ((BaseUnityPlugin)this).Config.Bind<string>("Settings", "ItemTextCalculatorColorHex", "#FF3333", "The default text color for items that meet the criteria, value must be a hexadecimal");
			ItemScaningUICooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "ItemScaningUICooldown", 3f, "The default value is 5f, how long the ui stays on screen");
			AdjustScreenPositionXaxis = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "AdjustScreenPositionXaxis", 0f, "The default value is 0, you will add or take away from its original position");
			AdjustScreenPositionYaxis = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "AdjustScreenPositionYaxis", 0f, "The default value is 0, you will add or take away from its original position");
		}
	}
}
namespace BetterItemScan.Patches
{
	[HarmonyPatch]
	internal class HudManagerPatch_UI
	{
		private static GameObject _totalCounter;

		private static TextMeshProUGUI _textMesh;

		private static float _displayTimeLeft = BetterItemScanModBase.ItemScaningUICooldown.Value;

		private static float Totalsum = 0f;

		private static float Totalship = 0f;

		public static List<ScanNodeProperties> scannedNodeObjects = new List<ScanNodeProperties>();

		public static Dictionary<string, (float, int)> meetQuotaItemNames = new Dictionary<string, (float, int)>();

		public static Dictionary<string, (float, int)> NotmeetQuotaItemNames = new Dictionary<string, (float, int)>();

		public static Dictionary<ScanNodeProperties, int> ItemsDictionary = new Dictionary<ScanNodeProperties, int>();

		private static List<ScanNodeProperties> items;

		public static int MeetQuota(List<int> items, int quota)
		{
			items = items.Where((int item) => item >= quota).ToList();
			if (!items.Any())
			{
				return -1;
			}
			return items.Aggregate((int a, int b) => (Math.Abs(quota - a) < Math.Abs(quota - b)) ? a : b);
		}

		public static List<List<int>> FindCombinations(List<int> items, int quota)
		{
			List<List<int>> list = new List<List<int>>();
			int count = items.Count;
			int num = int.MaxValue;
			for (int i = 0; i < 1 << count; i++)
			{
				List<int> list2 = new List<int>();
				for (int j = 0; j < count; j++)
				{
					if ((i & (1 << j)) > 0)
					{
						list2.Add(items[j]);
					}
				}
				int num2 = list2.Sum();
				int num3 = Math.Abs(quota - num2);
				if (num3 < num)
				{
					num = num3;
					list.Clear();
					list.Add(list2);
				}
				else if (num3 == num)
				{
					list.Add(list2);
				}
			}
			list.Sort((List<int> a, List<int> b) => a.Count.CompareTo(b.Count));
			return list;
		}

		private static bool IsHexColor(string value)
		{
			string pattern = "^#(?:[0-9a-fA-F]{3}){1,2}$";
			return Regex.IsMatch(value, pattern);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(HUDManager), "PingScan_performed")]
		private static void OnScan(HUDManager __instance, CallbackContext context)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			Debug.Log((object)"Scan initiated!");
			FieldInfo field = typeof(HUDManager).GetField("playerPingingScan", BindingFlags.Instance | BindingFlags.NonPublic);
			float num = (float)field.GetValue(__instance);
			MethodInfo method = typeof(HUDManager).GetMethod("CanPlayerScan", BindingFlags.Instance | BindingFlags.NonPublic);
			if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null || !((CallbackContext)(ref context)).performed || !(bool)method.Invoke(__instance, null) || (double)num > -1.0)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)_totalCounter))
			{
				CopyValueCounter();
			}
			if (!Object.op_Implicit((Object)(object)_textMesh))
			{
				_textMesh = new TextMeshProUGUI();
			}
			meetQuotaItemNames.Clear();
			NotmeetQuotaItemNames.Clear();
			items = CalculateLootItems();
			foreach (ScanNodeProperties item in items)
			{
				ItemsDictionary.Add(item, item.scrapValue);
			}
			int num2 = TimeOfDay.Instance.profitQuota - TimeOfDay.Instance.quotaFulfilled;
			List<int> list = ItemsDictionary.Values.ToList();
			list.Sort();
			list.Reverse();
			int bestIndividualItem = MeetQuota(list, num2);
			List<List<int>> source = FindCombinations(list, num2);
			if (source.Any())
			{
				int num3 = source.First().Sum();
				if (Math.Abs(num2 - bestIndividualItem) <= Math.Abs(num2 - num3))
				{
					if (bestIndividualItem != -1)
					{
						ScanNodeProperties key = ItemsDictionary.FirstOrDefault((KeyValuePair<ScanNodeProperties, int> x) => x.Value == bestIndividualItem).Key;
						if ((Object)(object)key != (Object)null)
						{
							if (!meetQuotaItemNames.ContainsKey(key.headerText))
							{
								meetQuotaItemNames.Add(key.headerText, (key.scrapValue, 1));
							}
							else
							{
								(float, int) tuple = meetQuotaItemNames[key.headerText];
								meetQuotaItemNames[key.headerText] = (tuple.Item1 + (float)key.scrapValue, tuple.Item2 + 1);
								items.Remove(key);
							}
						}
					}
				}
				else
				{
					foreach (int combination in source.First())
					{
						ScanNodeProperties key2 = ItemsDictionary.FirstOrDefault((KeyValuePair<ScanNodeProperties, int> x) => x.Value == combination).Key;
						if ((Object)(object)key2 != (Object)null)
						{
							if (!meetQuotaItemNames.ContainsKey(key2.headerText))
							{
								meetQuotaItemNames.Add(key2.headerText, (key2.scrapValue, 1));
								continue;
							}
							(float, int) tuple2 = meetQuotaItemNames[key2.headerText];
							meetQuotaItemNames[key2.headerText] = (tuple2.Item1 + (float)key2.scrapValue, tuple2.Item2 + 1);
							items.Remove(key2);
						}
					}
				}
			}
			foreach (KeyValuePair<ScanNodeProperties, int> item2 in ItemsDictionary)
			{
				if (!NotmeetQuotaItemNames.ContainsKey(item2.Key.headerText))
				{
					NotmeetQuotaItemNames.Add(item2.Key.headerText, (item2.Key.scrapValue, 1));
					continue;
				}
				(float, int) tuple3 = NotmeetQuotaItemNames[item2.Key.headerText];
				NotmeetQuotaItemNames[item2.Key.headerText] = (tuple3.Item1 + (float)item2.Key.scrapValue, tuple3.Item2 + 1);
				items.Remove(item2.Key);
			}
			ItemsDictionary.Clear();
			string text = "";
			string text2 = "";
			foreach (ScanNodeProperties item3 in items)
			{
				if (meetQuotaItemNames.ContainsKey(item3.headerText))
				{
					if (meetQuotaItemNames.TryGetValue(item3.headerText, out var value))
					{
						text2 = $"{value.Item2}-{item3.headerText}: ${value.Item1}";
					}
					if (BetterItemScanModBase.CalculateForQuota.Value)
					{
						if (IsHexColor(BetterItemScanModBase.ItemTextCalculatorColorHex.Value))
						{
							text2 = "<color=" + BetterItemScanModBase.ItemTextCalculatorColorHex.Value + ">* " + text2 + "</color>";
						}
						else
						{
							Debug.LogError((object)(BetterItemScanModBase.ItemTextCalculatorColorHex.Value + " is an invalid colour. Please remember the '#'"));
							text2 = "<color=#FF3333>* " + text2 + "</color>";
						}
					}
					else if (IsHexColor(BetterItemScanModBase.ItemTextColorHex.Value))
					{
						text2 = "<color=" + BetterItemScanModBase.ItemTextColorHex.Value + ">" + text2 + "</color>";
					}
					else
					{
						Debug.LogError((object)(BetterItemScanModBase.ItemTextColorHex.Value + " is an invalid colour. Please remember the '#'"));
						text2 = "<color=#FF3333>* " + text2 + "</color>";
					}
				}
				else if (NotmeetQuotaItemNames.ContainsKey(item3.headerText))
				{
					if (NotmeetQuotaItemNames.TryGetValue(item3.headerText, out var value2))
					{
						text2 = $"{value2.Item2}-{item3.headerText}: ${value2.Item1}";
					}
					if (IsHexColor(BetterItemScanModBase.ItemTextColorHex.Value))
					{
						text2 = "<color=" + BetterItemScanModBase.ItemTextColorHex.Value + ">" + text2 + "</color>";
					}
					else
					{
						Debug.LogError((object)(BetterItemScanModBase.ItemTextColorHex.Value + " is an invalid colour. Please remember the '#'"));
						text2 = "<color=#FF3333>* " + text2 + "</color>";
					}
				}
				text = text + text2 + "\n";
			}
			((TMP_Text)_textMesh).text = text;
			if (BetterItemScanModBase.ShowShipTotalOnShipOnly.Value)
			{
				if (!GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom)
				{
					TextMeshProUGUI textMesh = _textMesh;
					((TMP_Text)textMesh).text = ((TMP_Text)textMesh).text + "\nTotal Scanned: " + Totalsum;
				}
				else
				{
					TextMeshProUGUI textMesh2 = _textMesh;
					((TMP_Text)textMesh2).text = ((TMP_Text)textMesh2).text + "\nTotal Scanned: " + Totalsum + "\nShip Total: " + Totalship;
				}
			}
			else
			{
				TextMeshProUGUI textMesh2 = _textMesh;
				((TMP_Text)textMesh2).text = ((TMP_Text)textMesh2).text + "\nTotal Scanned: " + Totalsum + "\nShip Total: " + Totalship;
			}
			if (BetterItemScanModBase.ShowTotalOnShipOnly.Value)
			{
				if (!GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom)
				{
					((Component)_textMesh).gameObject.SetActive(false);
					((Component)((TMP_Text)__instance.totalValueText).transform.parent).gameObject.SetActive(true);
				}
				else
				{
					((Component)_textMesh).gameObject.SetActive(true);
					((Component)((TMP_Text)__instance.totalValueText).transform.parent).gameObject.SetActive(false);
				}
			}
			_displayTimeLeft = BetterItemScanModBase.ItemScaningUICooldown.Value;
			if (!_totalCounter.activeSelf)
			{
				((MonoBehaviour)GameNetworkManager.Instance).StartCoroutine(ValueCoroutine());
			}
		}

		private static List<ScanNodeProperties> CalculateLootItems()
		{
			List<GrabbableObject> source = (from obj in GameObject.Find("/Environment/HangarShip").GetComponentsInChildren<GrabbableObject>()
				where ((Object)obj).name != "ClipboardManual" && ((Object)obj).name != "StickyNoteItem"
				select obj).ToList();
			List<ScanNodeProperties> list = scannedNodeObjects.Where((ScanNodeProperties obj) => obj.headerText != "ClipboardManual" && obj.headerText != "StickyNoteItem" && obj.scrapValue != 0).ToList();
			Totalsum = list.Sum((ScanNodeProperties scrap) => scrap.scrapValue);
			Totalship = source.Sum((GrabbableObject scrap) => scrap.scrapValue);
			return list;
		}

		private static IEnumerator ValueCoroutine()
		{
			_totalCounter.SetActive(true);
			while ((double)_displayTimeLeft > 0.0)
			{
				float displayTimeLeft = _displayTimeLeft;
				_displayTimeLeft = 0f;
				Debug.Log((object)$"Waiting for {displayTimeLeft} seconds...");
				yield return (object)new WaitForSeconds(displayTimeLeft);
			}
			_totalCounter.SetActive(false);
			Debug.Log((object)"Cooldown complete. Hiding UI.");
		}

		private static void CopyValueCounter()
		{
			//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)
			//IL_005c: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: 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_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: 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_0191: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("/Systems/UI/Canvas/IngamePlayerHUD/BottomMiddle/ValueCounter");
			if (!Object.op_Implicit((Object)(object)val))
			{
				BetterItemScanModBase.Instance.mls.LogError((object)"Failed to find ValueCounter object to copy!");
			}
			_totalCounter = Object.Instantiate<GameObject>(val.gameObject, val.transform.parent, false);
			Vector3 localPosition = _totalCounter.transform.localPosition;
			float num = Mathf.Clamp(localPosition.x + BetterItemScanModBase.AdjustScreenPositionXaxis.Value + 50f, -6000f, (float)Screen.width);
			float num2 = Mathf.Clamp(localPosition.y + BetterItemScanModBase.AdjustScreenPositionYaxis.Value - 80f, -6000f, (float)Screen.height);
			_totalCounter.transform.localPosition = new Vector3(num, num2, localPosition.z);
			_textMesh = _totalCounter.GetComponentInChildren<TextMeshProUGUI>();
			((TMP_Text)_textMesh).fontSizeMin = 5f;
			((TMP_Text)_textMesh).fontSize = BetterItemScanModBase.FontSize.Value;
			((TMP_Text)_textMesh).ForceMeshUpdate(false, false);
			((TMP_Text)_textMesh).alignment = (TextAlignmentOptions)1025;
			RectTransform rectTransform = ((TMP_Text)_textMesh).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 2f);
			rectTransform.anchorMax = new Vector2(0.5f, 2f);
			rectTransform.pivot = new Vector2(0.5f, 0f);
			Vector3 localPosition2 = ((Transform)rectTransform).localPosition;
			((Transform)rectTransform).localPosition = new Vector3(localPosition2.x, localPosition2.y - 140f, localPosition2.z);
		}
	}
	[HarmonyPatch]
	public class PlayerControllerBPatch_A
	{
		private static LineRenderer lineRenderer;

		private static GameObject lineObject;

		private static float maxDistance = 80f;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(HUDManager), "AssignNewNodes")]
		private static bool AssignNewNodes_patch(HUDManager __instance, PlayerControllerB playerScript)
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			HudManagerPatch_UI.scannedNodeObjects.Clear();
			if ((Object)(object)lineRenderer == (Object)null)
			{
				lineObject = new GameObject("LineObject");
				lineRenderer = lineObject.AddComponent<LineRenderer>();
				lineRenderer.positionCount = 2;
				lineObject.SetActive(false);
			}
			FieldInfo field = typeof(HUDManager).GetField("nodesOnScreen", BindingFlags.Instance | BindingFlags.NonPublic);
			List<ScanNodeProperties> list = field.GetValue(__instance) as List<ScanNodeProperties>;
			FieldInfo field2 = typeof(HUDManager).GetField("scannedScrapNum", BindingFlags.Instance | BindingFlags.NonPublic);
			object value = field2.GetValue(__instance);
			FieldInfo field3 = typeof(HUDManager).GetField("scanNodesHit", BindingFlags.Instance | BindingFlags.NonPublic);
			RaycastHit[] array = field3.GetValue(__instance) as RaycastHit[];
			MethodInfo method = typeof(HUDManager).GetMethod("AttemptScanNode", BindingFlags.Instance | BindingFlags.NonPublic);
			int num = Physics.SphereCastNonAlloc(new Ray(((Component)playerScript.gameplayCamera).transform.position + ((Component)playerScript.gameplayCamera).transform.forward * 20f, ((Component)playerScript.gameplayCamera).transform.forward), BetterItemScanModBase.ItemScanRadius.Value, array, maxDistance, 4194304);
			Vector3 val = new Vector3(((Component)playerScript.gameplayCamera).transform.position.x, ((Component)playerScript.gameplayCamera).transform.position.y - 2f, ((Component)playerScript.gameplayCamera).transform.position.z) + ((Component)playerScript.gameplayCamera).transform.forward;
			Vector3 forward = ((Component)playerScript.gameplayCamera).transform.forward;
			if (BetterItemScanModBase.ShowDebugMode.Value)
			{
				lineObject.SetActive(true);
				lineRenderer.SetPosition(0, val);
				lineRenderer.SetPosition(1, val + forward * maxDistance);
				LineRenderer obj = lineRenderer;
				float startWidth = (lineRenderer.endWidth = BetterItemScanModBase.ItemScanRadius.Value);
				obj.startWidth = startWidth;
			}
			if (num > __instance.scanElements.Length)
			{
				num = __instance.scanElements.Length;
			}
			list.Clear();
			value = 0;
			if (num > __instance.scanElements.Length)
			{
				for (int i = 0; i < num; i++)
				{
					ScanNodeProperties component = ((Component)((RaycastHit)(ref array[i])).transform).gameObject.GetComponent<ScanNodeProperties>();
					GrabbableObject component2 = ((Component)((RaycastHit)(ref array[i])).transform.parent).gameObject.GetComponent<GrabbableObject>();
					if (component2.itemProperties.isScrap)
					{
						HudManagerPatch_UI.scannedNodeObjects.Add(component);
					}
					if (component.nodeType == 1 || component.nodeType == 2)
					{
						object[] parameters = new object[3] { component, i, playerScript };
						method.Invoke(__instance, parameters);
					}
				}
			}
			if (list.Count < __instance.scanElements.Length)
			{
				for (int j = 0; j < num; j++)
				{
					ScanNodeProperties component3 = ((Component)((RaycastHit)(ref array[j])).transform).gameObject.GetComponent<ScanNodeProperties>();
					object[] parameters2 = new object[3] { component3, j, playerScript };
					method.Invoke(__instance, parameters2);
				}
			}
			return false;
		}
	}
	[HarmonyPatch]
	public class PlayerControllerBPatch_B
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(HUDManager), "AttemptScanNode")]
		private static bool AttemptScanNode_patch(HUDManager __instance, ScanNodeProperties node, int i, PlayerControllerB playerScript)
		{
			MethodInfo method = typeof(HUDManager).GetMethod("MeetsScanNodeRequirements", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method2 = typeof(HUDManager).GetMethod("AssignNodeToUIElement", BindingFlags.Instance | BindingFlags.NonPublic);
			FieldInfo field = typeof(HUDManager).GetField("nodesOnScreen", BindingFlags.Instance | BindingFlags.NonPublic);
			List<ScanNodeProperties> list = field.GetValue(__instance) as List<ScanNodeProperties>;
			FieldInfo field2 = typeof(HUDManager).GetField("scannedScrapNum", BindingFlags.Instance | BindingFlags.NonPublic);
			int num = (int)field2.GetValue(__instance);
			FieldInfo field3 = typeof(HUDManager).GetField("playerPingingScan", BindingFlags.Instance | BindingFlags.NonPublic);
			float num2 = (float)field3.GetValue(__instance);
			object[] parameters = new object[2] { node, playerScript };
			object[] parameters2 = new object[1] { node };
			if (!(bool)method.Invoke(__instance, parameters))
			{
				return false;
			}
			if (node.nodeType == 2)
			{
				num++;
			}
			if (!list.Contains(node))
			{
				list.Add(node);
			}
			if (node.creatureScanID == -1)
			{
				HudManagerPatch_UI.scannedNodeObjects.Add(node);
			}
			if ((double)num2 < 0.0)
			{
				return false;
			}
			method2.Invoke(__instance, parameters2);
			return false;
		}
	}
	[HarmonyPatch]
	public class PlayerControllerBPatch_C
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(HUDManager), "Update")]
		private static void Update_patch(HUDManager __instance)
		{
			FieldInfo field = typeof(HUDManager).GetField("addingToDisplayTotal", BindingFlags.Instance | BindingFlags.NonPublic);
			object value = field.GetValue(__instance);
			((Component)((TMP_Text)__instance.totalValueText).transform.parent).gameObject.SetActive(false);
			value = false;
		}
	}
}