Decompiled source of OrbitalPawnshop v1.0.0

OrbitalPawnshop.dll

Decompiled 2 weeks ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("OrbitalPawnshop")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("OrbitalPawnshop")]
[assembly: AssemblyTitle("OrbitalPawnshop")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 OrbitalPawnshop
{
	internal static class Net
	{
		private delegate void Writer(ref FastBufferWriter w);

		[CompilerGenerated]
		private static class <>O
		{
			public static HandleNamedMessageDelegate <0>__OnHello;

			public static HandleNamedMessageDelegate <1>__OnRequest;

			public static HandleNamedMessageDelegate <2>__OnSettings;

			public static HandleNamedMessageDelegate <3>__OnResult;

			public static HandleNamedMessageDelegate <4>__OnQuota;

			public static Writer <5>__WriteSettings;
		}

		private const string Prefix = "OrbitalPawnshop.";

		private const string MsgHello = "OrbitalPawnshop.Hello";

		private const string MsgSettings = "OrbitalPawnshop.Settings";

		private const string MsgRequest = "OrbitalPawnshop.Request";

		private const string MsgResult = "OrbitalPawnshop.Result";

		private const string MsgQuota = "OrbitalPawnshop.Quota";

		private const int MaxItemsPerRequest = 1024;

		private static bool registered;

		private static bool registeredAsServer;

		private static NetworkManager NM => NetworkManager.Singleton;

		public static void Register()
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//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_006f: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			if (registered)
			{
				Unregister();
			}
			if ((Object)(object)NM == (Object)null || !NM.IsListening || NM.CustomMessagingManager == null)
			{
				return;
			}
			CustomMessagingManager customMessagingManager = NM.CustomMessagingManager;
			Pawnshop.ResetSession();
			if (NM.IsServer)
			{
				object obj = <>O.<0>__OnHello;
				if (obj == null)
				{
					HandleNamedMessageDelegate val = OnHello;
					<>O.<0>__OnHello = val;
					obj = (object)val;
				}
				customMessagingManager.RegisterNamedMessageHandler("OrbitalPawnshop.Hello", (HandleNamedMessageDelegate)obj);
				object obj2 = <>O.<1>__OnRequest;
				if (obj2 == null)
				{
					HandleNamedMessageDelegate val2 = OnRequest;
					<>O.<1>__OnRequest = val2;
					obj2 = (object)val2;
				}
				customMessagingManager.RegisterNamedMessageHandler("OrbitalPawnshop.Request", (HandleNamedMessageDelegate)obj2);
				registeredAsServer = true;
				BroadcastSettings();
			}
			else
			{
				object obj3 = <>O.<2>__OnSettings;
				if (obj3 == null)
				{
					HandleNamedMessageDelegate val3 = OnSettings;
					<>O.<2>__OnSettings = val3;
					obj3 = (object)val3;
				}
				customMessagingManager.RegisterNamedMessageHandler("OrbitalPawnshop.Settings", (HandleNamedMessageDelegate)obj3);
				object obj4 = <>O.<3>__OnResult;
				if (obj4 == null)
				{
					HandleNamedMessageDelegate val4 = OnResult;
					<>O.<3>__OnResult = val4;
					obj4 = (object)val4;
				}
				customMessagingManager.RegisterNamedMessageHandler("OrbitalPawnshop.Result", (HandleNamedMessageDelegate)obj4);
				object obj5 = <>O.<4>__OnQuota;
				if (obj5 == null)
				{
					HandleNamedMessageDelegate val5 = OnQuota;
					<>O.<4>__OnQuota = val5;
					obj5 = (object)val5;
				}
				customMessagingManager.RegisterNamedMessageHandler("OrbitalPawnshop.Quota", (HandleNamedMessageDelegate)obj5);
				registeredAsServer = false;
				SendHello();
			}
			registered = true;
		}

		public static void Unregister()
		{
			if (!registered)
			{
				return;
			}
			registered = false;
			Pawnshop.ResetSession();
			CustomMessagingManager val = (((Object)(object)NM != (Object)null) ? NM.CustomMessagingManager : null);
			if (val == null)
			{
				return;
			}
			try
			{
				if (registeredAsServer)
				{
					val.UnregisterNamedMessageHandler("OrbitalPawnshop.Hello");
					val.UnregisterNamedMessageHandler("OrbitalPawnshop.Request");
				}
				else
				{
					val.UnregisterNamedMessageHandler("OrbitalPawnshop.Settings");
					val.UnregisterNamedMessageHandler("OrbitalPawnshop.Result");
					val.UnregisterNamedMessageHandler("OrbitalPawnshop.Quota");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("Unregister: " + ex.Message));
			}
		}

		private static void Send(string name, ulong target, int size, Writer write)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NM == (Object)null || NM.CustomMessagingManager == null)
			{
				return;
			}
			FastBufferWriter w = default(FastBufferWriter);
			((FastBufferWriter)(ref w))..ctor(size, (Allocator)2, 65536);
			try
			{
				write(ref w);
				NM.CustomMessagingManager.SendNamedMessage(name, target, w, (NetworkDelivery)4);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Failed to send {name}: {arg}");
			}
			finally
			{
				((FastBufferWriter)(ref w)).Dispose();
			}
		}

		private static void SendToOtherClients(string name, int size, Writer write)
		{
			if ((Object)(object)NM == (Object)null || !NM.IsServer)
			{
				return;
			}
			foreach (ulong connectedClientsId in NM.ConnectedClientsIds)
			{
				if (connectedClientsId != 0L)
				{
					Send(name, connectedClientsId, size, write);
				}
			}
		}

		public static void SendHello()
		{
			if (!((Object)(object)NM == (Object)null) && !NM.IsServer)
			{
				Send("OrbitalPawnshop.Hello", 0uL, 8, delegate(ref FastBufferWriter w)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					int num = 1;
					((FastBufferWriter)(ref w)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				});
			}
		}

		private static void WriteSettings(ref FastBufferWriter w)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			HostSettings local = Plugin.Cfg.Local;
			((FastBufferWriter)(ref w)).WriteValueSafe<int>(ref local.PayoutPercent, default(ForPrimitives));
			((FastBufferWriter)(ref w)).WriteValueSafe<bool>(ref local.CountsTowardsQuota, default(ForPrimitives));
			((FastBufferWriter)(ref w)).WriteValueSafe<bool>(ref local.OnlyInOrbit, default(ForPrimitives));
			((FastBufferWriter)(ref w)).WriteValueSafe<bool>(ref local.AnnounceInChat, default(ForPrimitives));
			((FastBufferWriter)(ref w)).WriteValueSafe(local.Blacklist ?? "", false);
		}

		public static void BroadcastSettings()
		{
			if (registered && !((Object)(object)NM == (Object)null) && NM.IsServer)
			{
				SendToOtherClients("OrbitalPawnshop.Settings", 512, WriteSettings);
			}
		}

		private static void OnHello(ulong sender, FastBufferReader reader)
		{
			if (!((Object)(object)NM == (Object)null) && NM.IsServer)
			{
				Send("OrbitalPawnshop.Settings", sender, 512, WriteSettings);
			}
		}

		private static void OnSettings(ulong sender, FastBufferReader reader)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				int num = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				bool announceInChat = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref announceInChat, default(ForPrimitives));
				string text = default(string);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref text, false);
				Pawnshop.Remote = new HostSettings
				{
					PayoutPercent = num,
					CountsTowardsQuota = flag,
					OnlyInOrbit = flag2,
					AnnounceInChat = announceInChat,
					Blacklist = (text ?? "")
				};
				Pawnshop.HasRemoteSettings = true;
				Plugin.Log.LogInfo((object)string.Format("Host pawnshop rules: {0}% payout, quota {1}, orbit only: {2}.", num, flag ? "counted" : "not counted", flag2));
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Bad settings message from host: {arg}");
			}
		}

		public static void SendRequest(ulong[] ids)
		{
			Send("OrbitalPawnshop.Request", 0uL, 16 + ids.Length * 8, delegate(ref FastBufferWriter w)
			{
				//IL_000e: 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_002e: 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)
				int num = ids.Length;
				((FastBufferWriter)(ref w)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				ulong[] array = ids;
				for (num = 0; num < array.Length; num++)
				{
					ulong num2 = array[num];
					((FastBufferWriter)(ref w)).WriteValueSafe<ulong>(ref num2, default(ForPrimitives));
				}
			});
		}

		private static void OnRequest(ulong sender, FastBufferReader reader)
		{
			//IL_0027: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NM == (Object)null || !NM.IsServer)
			{
				return;
			}
			SaleResult saleResult;
			try
			{
				int num = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
				if (num < 0 || num > 1024)
				{
					throw new InvalidOperationException($"bad item count {num}");
				}
				ulong[] array = new ulong[num];
				for (int i = 0; i < num; i++)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref array[i], default(ForPrimitives));
				}
				saleResult = Pawnshop.ServerSell(array, sender);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Bad pawn request from client {sender}: {arg}");
				saleResult = new SaleResult
				{
					Error = "The pawnbroker couldn't read your offer."
				};
			}
			SaleResult r = saleResult;
			Send("OrbitalPawnshop.Result", sender, 512, delegate(ref FastBufferWriter w)
			{
				//IL_000e: 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_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: 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_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: 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)
				((FastBufferWriter)(ref w)).WriteValueSafe<bool>(ref r.Ok, default(ForPrimitives));
				((FastBufferWriter)(ref w)).WriteValueSafe<int>(ref r.Items, default(ForPrimitives));
				((FastBufferWriter)(ref w)).WriteValueSafe<int>(ref r.Value, default(ForPrimitives));
				((FastBufferWriter)(ref w)).WriteValueSafe<int>(ref r.Payout, default(ForPrimitives));
				((FastBufferWriter)(ref w)).WriteValueSafe<int>(ref r.NewCredits, default(ForPrimitives));
				((FastBufferWriter)(ref w)).WriteValueSafe<bool>(ref r.CountedTowardsQuota, default(ForPrimitives));
				((FastBufferWriter)(ref w)).WriteValueSafe(r.Error ?? "", false);
			});
		}

		private static void OnResult(ulong sender, FastBufferReader reader)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				SaleResult result = default(SaleResult);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref result.Ok, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref result.Items, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref result.Value, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref result.Payout, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref result.NewCredits, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref result.CountedTowardsQuota, default(ForPrimitives));
				string text = default(string);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref text, false);
				result.Error = (string.IsNullOrEmpty(text) ? null : text);
				Pawnshop.OnResult(result);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Bad result message from host: {arg}");
				Pawnshop.AwaitingResult = false;
			}
		}

		public static void BroadcastQuota(int quotaFulfilled)
		{
			SendToOtherClients("OrbitalPawnshop.Quota", 8, delegate(ref FastBufferWriter w)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref w)).WriteValueSafe<int>(ref quotaFulfilled, default(ForPrimitives));
			});
		}

		private static void OnQuota(ulong sender, FastBufferReader reader)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				int quotaFulfilled = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref quotaFulfilled, default(ForPrimitives));
				if (!((Object)(object)TimeOfDay.Instance == (Object)null))
				{
					TimeOfDay.Instance.quotaFulfilled = quotaFulfilled;
					TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
				}
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Bad quota message from host: {arg}");
			}
		}
	}
	[HarmonyPatch]
	internal static class Patches
	{
		[HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")]
		[HarmonyPrefix]
		[HarmonyPriority(600)]
		private static bool ParsePlayerSentencePrefix(Terminal __instance, ref TerminalNode __result)
		{
			try
			{
				string text = (((Object)(object)__instance.screenText != (Object)null) ? __instance.screenText.text : null);
				int textAdded = __instance.textAdded;
				if (text == null || textAdded <= 0 || textAdded > text.Length)
				{
					return true;
				}
				TerminalNode val = TerminalUI.Handle(text.Substring(text.Length - textAdded));
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				__result = val;
				return false;
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Terminal command failed: {arg}");
				return true;
			}
		}

		[HarmonyPatch(typeof(Terminal), "Start")]
		[HarmonyPostfix]
		private static void TerminalStartPostfix(Terminal __instance)
		{
			TerminalUI.AddToOtherCommands(__instance);
		}

		[HarmonyPatch(typeof(Terminal), "QuitTerminal")]
		[HarmonyPostfix]
		private static void QuitTerminalPostfix()
		{
			Pawnshop.Pending = null;
		}

		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPostfix]
		private static void StartOfRoundStartPostfix()
		{
			try
			{
				Net.Register();
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Network setup failed: {arg}");
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "OnDestroy")]
		[HarmonyPrefix]
		private static void StartOfRoundOnDestroyPrefix()
		{
			try
			{
				Net.Unregister();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("Network teardown: " + ex.Message));
			}
		}
	}
	internal struct HostSettings
	{
		public int PayoutPercent;

		public bool CountsTowardsQuota;

		public bool OnlyInOrbit;

		public bool AnnounceInChat;

		public string Blacklist;
	}
	internal sealed class PawnConfig
	{
		private readonly ConfigEntry<int> payoutPercent;

		private readonly ConfigEntry<bool> countsTowardsQuota;

		private readonly ConfigEntry<bool> onlyInOrbit;

		private readonly ConfigEntry<bool> announceInChat;

		private readonly ConfigEntry<string> blacklist;

		private readonly ConfigEntry<string> command;

		public HostSettings Local => new HostSettings
		{
			PayoutPercent = Math.Max(0, Math.Min(100, payoutPercent.Value)),
			CountsTowardsQuota = countsTowardsQuota.Value,
			OnlyInOrbit = onlyInOrbit.Value,
			AnnounceInChat = announceInChat.Value,
			Blacklist = (blacklist.Value ?? "")
		};

		public string CommandWord
		{
			get
			{
				string text = Normalize(command.Value);
				if (text.Length != 0)
				{
					return text;
				}
				return "pawn";
			}
		}

		public event Action AnyHostSettingChanged;

		public PawnConfig(ConfigFile cfg)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			payoutPercent = cfg.Bind<int>("Pawnshop", "PayoutPercent", 50, new ConfigDescription("How much of an item's scrap value the pawnbroker pays, in percent.\nHOST SETTING: the host's value is used for everyone.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			countsTowardsQuota = cfg.Bind<bool>("Pawnshop", "CountsTowardsQuota", false, "If true, the credits you get from the pawnbroker also count towards the profit quota,\njust like selling at the Company desk. If false, pawning only gives credits.\nHOST SETTING.");
			onlyInOrbit = cfg.Bind<bool>("Pawnshop", "OnlyInOrbit", true, "If true, the pawnbroker only deals with ships in orbit (between days).\nSet to false to also allow pawning while landed on a moon.\nHOST SETTING.");
			announceInChat = cfg.Bind<bool>("Pawnshop", "AnnounceInChat", true, "Post a chat message for the whole crew whenever something is pawned.\nHOST SETTING.");
			blacklist = cfg.Bind<string>("Pawnshop", "Blacklist", "", "Comma-separated item names the pawnbroker refuses to buy (e.g. \"Apparatus, Golden cup\").\nCase and spaces don't matter. HOST SETTING.");
			command = cfg.Bind<string>("Terminal", "Command", "pawn", "The terminal word that opens the pawnshop. LOCAL SETTING: each player can pick their own.");
			payoutPercent.SettingChanged += delegate
			{
				this.AnyHostSettingChanged?.Invoke();
			};
			countsTowardsQuota.SettingChanged += delegate
			{
				this.AnyHostSettingChanged?.Invoke();
			};
			onlyInOrbit.SettingChanged += delegate
			{
				this.AnyHostSettingChanged?.Invoke();
			};
			announceInChat.SettingChanged += delegate
			{
				this.AnyHostSettingChanged?.Invoke();
			};
			blacklist.SettingChanged += delegate
			{
				this.AnyHostSettingChanged?.Invoke();
			};
		}

		public static string Normalize(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(s.Length);
			foreach (char c in s)
			{
				if (char.IsLetterOrDigit(c))
				{
					stringBuilder.Append(char.ToLowerInvariant(c));
				}
			}
			return stringBuilder.ToString();
		}

		public static HashSet<string> ParseBlacklist(string list)
		{
			HashSet<string> hashSet = new HashSet<string>();
			if (string.IsNullOrEmpty(list))
			{
				return hashSet;
			}
			string[] array = list.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text = Normalize(array[i]);
				if (text.Length > 0)
				{
					hashSet.Add(text);
				}
			}
			return hashSet;
		}
	}
	internal struct SaleResult
	{
		public bool Ok;

		public int Items;

		public int Value;

		public int Payout;

		public int NewCredits;

		public bool CountedTowardsQuota;

		public string Error;
	}
	internal sealed class PendingDeal
	{
		public ulong[] Ids;

		public int Value;

		public int Payout;
	}
	internal static class Pawnshop
	{
		public static HostSettings Remote;

		public static bool HasRemoteSettings;

		public static PendingDeal Pending;

		public static bool AwaitingResult;

		private static float awaitingSince;

		private static NetworkManager NM => NetworkManager.Singleton;

		public static bool IsServer
		{
			get
			{
				if ((Object)(object)NM != (Object)null)
				{
					return NM.IsServer;
				}
				return false;
			}
		}

		public static bool InSession
		{
			get
			{
				if ((Object)(object)NM != (Object)null)
				{
					return NM.IsListening;
				}
				return false;
			}
		}

		public static bool HostHasMod
		{
			get
			{
				if (!IsServer)
				{
					return HasRemoteSettings;
				}
				return true;
			}
		}

		public static HostSettings Settings
		{
			get
			{
				if (!IsServer)
				{
					return Remote;
				}
				return Plugin.Cfg.Local;
			}
		}

		public static void ResetSession()
		{
			HasRemoteSettings = false;
			Pending = null;
			AwaitingResult = false;
		}

		public static bool IsAwaitingResult()
		{
			if (AwaitingResult && Time.realtimeSinceStartup - awaitingSince > 10f)
			{
				AwaitingResult = false;
			}
			return AwaitingResult;
		}

		public static void MarkAwaiting()
		{
			AwaitingResult = true;
			awaitingSince = Time.realtimeSinceStartup;
		}

		public static string ItemName(GrabbableObject g)
		{
			string text = (((Object)(object)g.itemProperties != (Object)null) ? g.itemProperties.itemName : null);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text.Trim();
			}
			return ((Object)((Component)g).gameObject).name;
		}

		public static int PayoutFor(int value, int percent)
		{
			if (value <= 0 || percent <= 0)
			{
				return 0;
			}
			return (int)Math.Floor((double)value * ((double)percent / 100.0));
		}

		public static bool IsOpenForBusiness(out string reason)
		{
			reason = null;
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance == (Object)null || !InSession)
			{
				reason = "The pawnbroker only answers ships that are online.";
				return false;
			}
			if (Settings.OnlyInOrbit && !instance.inShipPhase)
			{
				reason = "The pawnbroker only deals with ships in orbit.\nCome back once you've left the moon.";
				return false;
			}
			return true;
		}

		private static bool InShip(GrabbableObject g)
		{
			//IL_002d: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			if (g.isInShipRoom)
			{
				return true;
			}
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.shipInnerRoomBounds != (Object)null)
			{
				Bounds bounds = instance.shipInnerRoomBounds.bounds;
				return ((Bounds)(ref bounds)).Contains(((Component)g).transform.position);
			}
			return false;
		}

		public static bool IsPawnable(GrabbableObject g, HashSet<string> blacklist)
		{
			if ((Object)(object)g == (Object)null || (Object)(object)g.itemProperties == (Object)null)
			{
				return false;
			}
			if (!g.itemProperties.isScrap || g.scrapValue <= 0)
			{
				return false;
			}
			if (g is RagdollGrabbableObject)
			{
				return false;
			}
			if (g.isHeld || g.isPocketed || (Object)(object)g.playerHeldBy != (Object)null || g.isHeldByEnemy)
			{
				return false;
			}
			if (g.deactivated || g.itemUsedUp)
			{
				return false;
			}
			NetworkObject networkObject = ((NetworkBehaviour)g).NetworkObject;
			if ((Object)(object)networkObject == (Object)null || !networkObject.IsSpawned)
			{
				return false;
			}
			if (!InShip(g))
			{
				return false;
			}
			if (blacklist.Count > 0 && blacklist.Contains(PawnConfig.Normalize(ItemName(g))))
			{
				return false;
			}
			return true;
		}

		public static List<GrabbableObject> GetPawnableItems()
		{
			HashSet<string> blacklist = PawnConfig.ParseBlacklist(Settings.Blacklist);
			List<GrabbableObject> list = new List<GrabbableObject>();
			GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
			foreach (GrabbableObject val in array)
			{
				if (IsPawnable(val, blacklist))
				{
					list.Add(val);
				}
			}
			list.Sort(delegate(GrabbableObject a, GrabbableObject b)
			{
				int num = string.Compare(ItemName(a), ItemName(b), StringComparison.OrdinalIgnoreCase);
				if (num != 0)
				{
					return num;
				}
				num = b.scrapValue.CompareTo(a.scrapValue);
				return (num != 0) ? num : ((NetworkBehaviour)a).NetworkObjectId.CompareTo(((NetworkBehaviour)b).NetworkObjectId);
			});
			return list;
		}

		public static PendingDeal MakeDeal(List<GrabbableObject> items)
		{
			int value = items.Sum((GrabbableObject i) => i.scrapValue);
			return new PendingDeal
			{
				Ids = items.Select((GrabbableObject i) => ((NetworkBehaviour)i).NetworkObjectId).ToArray(),
				Value = value,
				Payout = PayoutFor(value, Settings.PayoutPercent)
			};
		}

		public static SaleResult ServerSell(ulong[] ids, ulong requesterClientId)
		{
			SaleResult result = default(SaleResult);
			HostSettings local = Plugin.Cfg.Local;
			if (!IsServer)
			{
				result.Error = "Only the host can close a deal.";
				return result;
			}
			if (!IsOpenForBusiness(out var reason))
			{
				result.Error = reason;
				return result;
			}
			Terminal val = Object.FindObjectOfType<Terminal>();
			if ((Object)(object)val == (Object)null)
			{
				result.Error = "The ship's terminal is offline.";
				return result;
			}
			HashSet<string> blacklist = PawnConfig.ParseBlacklist(local.Blacklist);
			HashSet<ulong> hashSet = new HashSet<ulong>();
			List<GrabbableObject> list = new List<GrabbableObject>();
			foreach (ulong num in ids)
			{
				if (hashSet.Add(num) && NM.SpawnManager.SpawnedObjects.TryGetValue(num, out var value) && !((Object)(object)value == (Object)null))
				{
					GrabbableObject component = ((Component)value).GetComponent<GrabbableObject>();
					if (IsPawnable(component, blacklist))
					{
						list.Add(component);
					}
				}
			}
			if (list.Count == 0)
			{
				result.Error = "Those items aren't on the ship's floor anymore.\nType '" + Plugin.Cfg.CommandWord + "' to see what's left.";
				return result;
			}
			int num2 = list.Sum((GrabbableObject g) => g.scrapValue);
			int num3 = PayoutFor(num2, local.PayoutPercent);
			foreach (GrabbableObject item in list)
			{
				try
				{
					((NetworkBehaviour)item).NetworkObject.Despawn(true);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("Could not remove " + ItemName(item) + ": " + ex.Message));
				}
			}
			long val2 = (long)val.groupCredits + (long)num3;
			val.groupCredits = (int)Math.Min(val2, 2147483647L);
			val.SyncGroupCreditsClientRpc(val.groupCredits, val.numberOfItemsInDropship);
			if (local.CountsTowardsQuota && (Object)(object)TimeOfDay.Instance != (Object)null)
			{
				TimeOfDay instance = TimeOfDay.Instance;
				instance.quotaFulfilled += num3;
				TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
				Net.BroadcastQuota(TimeOfDay.Instance.quotaFulfilled);
			}
			if (local.AnnounceInChat && (Object)(object)HUDManager.Instance != (Object)null)
			{
				string arg = PlayerName(requesterClientId);
				string arg2 = ((list.Count == 1) ? ItemName(list[0]) : $"{list.Count} items");
				HUDManager.Instance.AddTextToChatOnServer($"<color=#E8A33D>[Pawnshop]</color> {arg} pawned {arg2} for ${num3}", -1);
			}
			Plugin.Log.LogInfo((object)$"{PlayerName(requesterClientId)} pawned {list.Count} item(s) worth {num2} for ${num3} (quota: {local.CountsTowardsQuota}).");
			result.Ok = true;
			result.Items = list.Count;
			result.Value = num2;
			result.Payout = num3;
			result.NewCredits = val.groupCredits;
			result.CountedTowardsQuota = local.CountsTowardsQuota;
			return result;
		}

		private static string PlayerName(ulong clientId)
		{
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance != (Object)null && instance.allPlayerScripts != null)
			{
				PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
				foreach (PlayerControllerB val in allPlayerScripts)
				{
					if ((Object)(object)val != (Object)null && val.actualClientId == clientId && (val.isPlayerControlled || val.isPlayerDead))
					{
						return val.playerUsername;
					}
				}
			}
			return "Someone";
		}

		public static void OnResult(SaleResult result)
		{
			AwaitingResult = false;
			Terminal val = Object.FindObjectOfType<Terminal>();
			PlayerControllerB val2 = (((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null && val2.inTerminalMenu)
			{
				val.LoadNewNode(TerminalUI.ResultNode(result));
			}
			else if ((Object)(object)HUDManager.Instance != (Object)null)
			{
				HUDManager.Instance.DisplayTip("Orbital Pawnshop", result.Ok ? $"Pawned {result.Items} item(s) for ${result.Payout}." : result.Error, !result.Ok, false, "LC_Tip1");
			}
		}
	}
	[BepInPlugin("moyu.OrbitalPawnshop", "Orbital Pawnshop", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Guid = "moyu.OrbitalPawnshop";

		public const string Name = "Orbital Pawnshop";

		public const string Version = "1.0.0";

		internal static ManualLogSource Log;

		internal static PawnConfig Cfg;

		private void Awake()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			Cfg = new PawnConfig(((BaseUnityPlugin)this).Config);
			Cfg.AnyHostSettingChanged += Net.BroadcastSettings;
			new Harmony("moyu.OrbitalPawnshop").PatchAll(typeof(Plugin).Assembly);
			Log.LogInfo((object)("Orbital Pawnshop 1.0.0 loaded. Terminal command: '" + Cfg.CommandWord + "'."));
		}
	}
	internal static class TerminalUI
	{
		private const int IndexWidth = 8;

		private const int NameWidth = 23;

		private static readonly string Rule = new string('-', 47);

		private static readonly HashSet<string> ConfirmWords = new HashSet<string> { "confirm", "c", "yes", "y" };

		private static readonly HashSet<string> DenyWords = new HashSet<string> { "deny", "d", "no", "n", "cancel" };

		public static TerminalNode Node(string text, bool clear = true)
		{
			TerminalNode obj = ScriptableObject.CreateInstance<TerminalNode>();
			obj.displayText = text.TrimEnd() + "\n\n";
			obj.clearPreviousText = clear;
			obj.maxCharactersToType = 35;
			return obj;
		}

		public static TerminalNode Handle(string rawInput)
		{
			string text = (rawInput ?? "").Trim().ToLowerInvariant();
			if (Pawnshop.Pending != null)
			{
				string item = PawnConfig.Normalize(text);
				if (ConfirmWords.Contains(item))
				{
					return Confirm();
				}
				if (DenyWords.Contains(item))
				{
					Pawnshop.Pending = null;
					return Node("Deal cancelled.\nThe pawnbroker shrugs and goes back to counting coins.");
				}
				Pawnshop.Pending = null;
			}
			string[] array = text.Split(new char[5] { ' ', ',', '\t', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 0 || PawnConfig.Normalize(array[0]) != Plugin.Cfg.CommandWord)
			{
				return null;
			}
			string[] array2 = array.Skip(1).ToArray();
			if (array2.Length == 1 && (array2[0] == "help" || array2[0] == "?"))
			{
				return HelpNode();
			}
			if (!Pawnshop.HostHasMod)
			{
				Net.SendHello();
				return Node("ORBITAL PAWNSHOP\n\nNo answer from the pawnbroker.\nThe host needs Orbital Pawnshop installed to make deals.\n(If they do, try again in a moment.)");
			}
			if (Pawnshop.IsAwaitingResult())
			{
				return Node("Hold on, the pawnbroker is still counting your last deal...");
			}
			if (!Pawnshop.IsOpenForBusiness(out var reason))
			{
				return Node("ORBITAL PAWNSHOP\n\n" + reason);
			}
			List<GrabbableObject> pawnableItems = Pawnshop.GetPawnableItems();
			if (array2.Length == 0)
			{
				return ListNode(pawnableItems);
			}
			if (pawnableItems.Count == 0)
			{
				return EmptyNode();
			}
			string error;
			List<GrabbableObject> list = Select(pawnableItems, array2, out error);
			if (list == null)
			{
				return Node(error);
			}
			Pawnshop.Pending = Pawnshop.MakeDeal(list);
			return OfferNode(list, Pawnshop.Pending);
		}

		private static TerminalNode Confirm()
		{
			PendingDeal pending = Pawnshop.Pending;
			Pawnshop.Pending = null;
			if (Pawnshop.IsServer)
			{
				ulong localClientId = NetworkManager.Singleton.LocalClientId;
				return ResultNode(Pawnshop.ServerSell(pending.Ids, localClientId));
			}
			Pawnshop.MarkAwaiting();
			Net.SendRequest(pending.Ids);
			return Node("Calling the pawnbroker...\nThe line crackles. Someone is counting.");
		}

		private static List<GrabbableObject> Select(List<GrabbableObject> items, string[] args, out string error)
		{
			error = null;
			string commandWord = Plugin.Cfg.CommandWord;
			if (args.Length == 1 && args[0] == "all")
			{
				return new List<GrabbableObject>(items);
			}
			SortedSet<int> sortedSet = new SortedSet<int>();
			bool flag = true;
			for (int i = 0; i < args.Length; i++)
			{
				if (!TryParseIndices(args[i], sortedSet))
				{
					flag = false;
					break;
				}
			}
			if (flag)
			{
				foreach (int item in sortedSet)
				{
					if (item < 1 || item > items.Count)
					{
						error = $"There's no item #{item}.\nType '{commandWord}' to see the numbered list.";
						return null;
					}
				}
				return sortedSet.Select((int num) => items[num - 1]).ToList();
			}
			string query = PawnConfig.Normalize(string.Join(" ", args));
			List<GrabbableObject> list = items.Where((GrabbableObject g) => PawnConfig.Normalize(Pawnshop.ItemName(g)).Contains(query)).ToList();
			if (list.Count == 0)
			{
				error = "Nothing in the ship matches \"" + string.Join(" ", args) + "\".\nType '" + commandWord + "' to see the list.";
				return null;
			}
			return list;
		}

		private static bool TryParseIndices(string token, SortedSet<int> into)
		{
			string text = token.Replace("..", "-");
			int num = text.IndexOf('-');
			if (num < 0)
			{
				if (!int.TryParse(text, out var result))
				{
					return false;
				}
				into.Add(result);
				return true;
			}
			if (!int.TryParse(text.Substring(0, num), out var result2) || !int.TryParse(text.Substring(num + 1), out var result3))
			{
				return false;
			}
			if (result2 > result3)
			{
				int num2 = result2;
				result2 = result3;
				result3 = num2;
			}
			if (result3 - result2 > 2000)
			{
				return false;
			}
			for (int i = result2; i <= result3; i++)
			{
				into.Add(i);
			}
			return true;
		}

		private static string Header()
		{
			HostSettings settings = Pawnshop.Settings;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("ORBITAL PAWNSHOP");
			stringBuilder.AppendLine(settings.CountsTowardsQuota ? "No desk. No questions asked." : "No desk. No quota. No questions asked.");
			stringBuilder.AppendLine(string.Format("Payout: {0}% of scrap value | Quota: {1}", settings.PayoutPercent, settings.CountsTowardsQuota ? "counted" : "not counted"));
			return stringBuilder.ToString();
		}

		private static TerminalNode EmptyNode()
		{
			return Node(Header() + "\nNothing to pawn.\nDrop your scrap on the ship's floor first.\n(Items in someone's hands or pockets don't count.)");
		}

		private static string Fit(string s, int width)
		{
			if (s.Length <= width)
			{
				return s.PadRight(width);
			}
			return s.Substring(0, width - 1) + ".";
		}

		private static TerminalNode ListNode(List<GrabbableObject> items)
		{
			if (items.Count == 0)
			{
				return EmptyNode();
			}
			int payoutPercent = Pawnshop.Settings.PayoutPercent;
			string commandWord = Plugin.Cfg.CommandWord;
			StringBuilder stringBuilder = new StringBuilder(Header());
			stringBuilder.AppendLine();
			stringBuilder.AppendLine(string.Format("{0}{1}{2,6}{3,10}", Fit("#", 8), Fit("ITEM", 23), "VALUE", "YOU GET"));
			int num = 1;
			int num2 = 0;
			while (num2 < items.Count)
			{
				string text = Pawnshop.ItemName(items[num2]);
				int i = num2;
				int num3 = 0;
				for (; i < items.Count && string.Equals(Pawnshop.ItemName(items[i]), text, StringComparison.OrdinalIgnoreCase); i++)
				{
					num3 += items[i].scrapValue;
				}
				int num4 = i - num2;
				string s = ((num4 == 1) ? $"{num}" : $"{num}-{num + num4 - 1}");
				string text2 = ((num4 == 1) ? text : $"{text} x{num4}");
				if (num4 > 1 && text2.Length > 23)
				{
					text2 = text.Substring(0, Math.Max(1, 18 - $"{num4}".Length)) + $". x{num4}";
				}
				stringBuilder.AppendLine(string.Format("{0} {1}{2,6}{3,10}", Fit(s, 7), Fit(text2, 23), num3, "$" + Pawnshop.PayoutFor(num3, payoutPercent)));
				num += num4;
				num2 = i;
			}
			int num5 = items.Sum((GrabbableObject g) => g.scrapValue);
			stringBuilder.AppendLine(Rule);
			stringBuilder.AppendLine(string.Format("{0}{1}{2,6}{3,10}", Fit("", 8), Fit(string.Format("{0} item{1}", items.Count, (items.Count == 1) ? "" : "s"), 23), num5, "$" + Pawnshop.PayoutFor(num5, payoutPercent)));
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("> " + commandWord + " 5        sell item #5");
			stringBuilder.AppendLine("> " + commandWord + " 1-4 7    sell several");
			stringBuilder.AppendLine("> " + commandWord + " bolt     sell by name");
			stringBuilder.AppendLine("> " + commandWord + " all      sell everything listed");
			return Node(stringBuilder.ToString());
		}

		private static TerminalNode OfferNode(List<GrabbableObject> items, PendingDeal deal)
		{
			HostSettings settings = Pawnshop.Settings;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(string.Format("PAWN {0} ITEM{1}?", items.Count, (items.Count == 1) ? "" : "S"));
			stringBuilder.AppendLine();
			var list = (from grp in items.GroupBy<GrabbableObject, string>((GrabbableObject g) => Pawnshop.ItemName(g), StringComparer.OrdinalIgnoreCase)
				select new
				{
					Name = grp.Key,
					Count = grp.Count(),
					Value = grp.Sum((GrabbableObject g) => g.scrapValue)
				}).ToList();
			foreach (var item in list.Take(30))
			{
				stringBuilder.AppendLine($"  {Fit($"{item.Count}x {item.Name}", 30),-30}{item.Value,8}");
			}
			if (list.Count > 30)
			{
				var source = list.Skip(30).ToList();
				stringBuilder.AppendLine($"  {Fit($"...and {source.Sum(r => r.Count)} more", 30),-30}{source.Sum(r => r.Value),8}");
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"Scrap value:  {deal.Value}");
			stringBuilder.AppendLine($"You get:      ${deal.Payout}  ({settings.PayoutPercent}%)");
			stringBuilder.AppendLine("Quota:        " + (settings.CountsTowardsQuota ? "counts towards the quota" : "not counted"));
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("Please CONFIRM or DENY.");
			return Node(stringBuilder.ToString());
		}

		public static TerminalNode ResultNode(SaleResult r)
		{
			if (!r.Ok)
			{
				return Node("NO DEAL.\n\n" + (r.Error ?? "Something went wrong."));
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("DEAL!");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine(string.Format("The pawnbroker takes {0} item{1} (worth {2})", r.Items, (r.Items == 1) ? "" : "s", r.Value));
			stringBuilder.AppendLine($"and slides ${r.Payout} across the counter.");
			if (r.CountedTowardsQuota)
			{
				stringBuilder.AppendLine($"${r.Payout} added to the quota.");
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"Balance: ${r.NewCredits}");
			TerminalNode obj = Node(stringBuilder.ToString());
			obj.playSyncedClip = 0;
			return obj;
		}

		private static TerminalNode HelpNode()
		{
			string commandWord = Plugin.Cfg.CommandWord;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("ORBITAL PAWNSHOP - HELP");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine(commandWord + "            list the scrap on the ship's floor");
			stringBuilder.AppendLine(commandWord + " 5          sell item #5 from the list");
			stringBuilder.AppendLine(commandWord + " 1-4 7      sell items 1 to 4, and 7");
			stringBuilder.AppendLine(commandWord + " bolt       sell every item whose name has 'bolt'");
			stringBuilder.AppendLine(commandWord + " all        sell everything on the list");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("Every deal asks you to CONFIRM or DENY first.");
			stringBuilder.AppendLine("Items in hands or pockets are never touched.");
			return Node(stringBuilder.ToString());
		}

		public static void AddToOtherCommands(Terminal terminal)
		{
			try
			{
				TerminalKeyword val = (((Object)(object)terminal.terminalNodes != (Object)null) ? terminal.terminalNodes.allKeywords : null)?.FirstOrDefault((Func<TerminalKeyword, bool>)((TerminalKeyword k) => (Object)(object)k != (Object)null && k.word == "other"));
				TerminalNode val2 = (((Object)(object)val != (Object)null) ? val.specialKeywordResult : null);
				if (!((Object)(object)val2 == (Object)null) && val2.displayText != null)
				{
					string text = Plugin.Cfg.CommandWord.ToUpperInvariant();
					string text2 = ">" + text + "\nSell scrap from the ship's floor to a shady pawnbroker.";
					if (!val2.displayText.Contains(text2))
					{
						val2.displayText = val2.displayText.TrimEnd() + "\n\n" + text2 + "\n\n";
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("Could not add to OTHER page: " + ex.Message));
			}
		}
	}
}