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.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CustomMoonPrices;
using CustomMoonPrices.Patches;
using GameNetcodeStuff;
using HarmonyLib;
using LCCustomMoonPrices;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalLevelLoader;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("CustomMoonPrices")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CustomMoonPrices")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9a728026-3819-4911-81cd-1be3f886290a")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace LCCustomMoonPrices
{
	[Serializable]
	public class SyncedInstance<T>
	{
		private static readonly DataContractSerializer serializer = new DataContractSerializer(typeof(T));

		[NonSerialized]
		protected static int IntSize = 4;

		internal static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;

		internal static bool IsClient => NetworkManager.Singleton.IsClient;

		internal static bool IsHost => NetworkManager.Singleton.IsHost;

		public static T Default { get; private set; }

		public static T Instance { get; private set; }

		public static bool Synced { get; internal set; }

		protected void InitInstance(T instance)
		{
			Default = instance;
			Instance = instance;
			IntSize = 4;
		}

		internal static void SyncInstance(byte[] data)
		{
			Instance = DeserializeFromBytes(data);
			Synced = true;
		}

		internal static void RevertSync()
		{
			Instance = Default;
			Synced = false;
		}

		public static byte[] SerializeToBytes(T val)
		{
			using MemoryStream memoryStream = new MemoryStream();
			try
			{
				((XmlObjectSerializer)serializer).WriteObject((Stream)memoryStream, (object)val);
				return memoryStream.ToArray();
			}
			catch (Exception ex)
			{
				CustomMoonPricesMain.CMPLogger.LogError((object)("Error serializing instance: " + ex));
				return null;
			}
		}

		public static T DeserializeFromBytes(byte[] data)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			using MemoryStream memoryStream = new MemoryStream(data);
			try
			{
				return (T)((XmlObjectSerializer)serializer).ReadObject((Stream)memoryStream);
			}
			catch (Exception ex)
			{
				CustomMoonPricesMain.CMPLogger.LogError((object)("Error deserializing instance: " + ex));
				return default(T);
			}
		}
	}
}
namespace CustomMoonPrices
{
	[Serializable]
	public class Config : SyncedInstance<Config>
	{
		public Dictionary<string, moonData> moonData;

		public Config()
		{
			InitInstance(this);
			moonData = new Dictionary<string, moonData>();
		}

		public void updateMoonEnabled(string moonname, bool enabled)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<Config>.IsHost)
			{
				return;
			}
			SyncedInstance<Config>.Instance.moonData[moonname].setEnabled(enabled);
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(30000, (Allocator)2, -1);
			try
			{
				SyncedInstance<Config>.MessageManager.SendNamedMessageToAll("CMP_OSC", val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public void updateMoonPrice(string moonname, int price)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<Config>.IsHost)
			{
				return;
			}
			SyncedInstance<Config>.Instance.moonData[moonname].setPrice(price);
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(30000, (Allocator)2, -1);
			try
			{
				SyncedInstance<Config>.MessageManager.SendNamedMessageToAll("CMP_OSC", val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		internal static void RequestSync()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<Config>.IsClient)
			{
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(30000, (Allocator)2, -1);
			try
			{
				SyncedInstance<Config>.MessageManager.SendNamedMessage("CMP_ORS", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		internal static void OnRequestSync(ulong clientId, FastBufferReader _)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<Config>.IsHost)
			{
				return;
			}
			CustomMoonPricesMain.CMPLogger.LogDebug((object)$"Config sync request received from client: {clientId}");
			byte[] array = SyncedInstance<Config>.SerializeToBytes(SyncedInstance<Config>.Instance);
			int num = array.Length;
			int num2 = num + SyncedInstance<Config>.IntSize;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(num2, (Allocator)2, -1);
			try
			{
				bool flag = ((FastBufferWriter)(ref val)).Capacity > 1000;
				NetworkDelivery val2 = (NetworkDelivery)(flag ? 4 : 2);
				if (flag)
				{
					CustomMoonPricesMain.CMPLogger.LogDebug((object)($"Size of stream ({((FastBufferWriter)(ref val)).Capacity}) was past the max buffer size.\n" + "Config instance will be sent in fragments to avoid overflowing the buffer."));
				}
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteBytesSafe(array, num, 0);
				SyncedInstance<Config>.MessageManager.SendNamedMessage("CMP_ORCS", clientId, val, val2);
			}
			catch (Exception arg)
			{
				CustomMoonPricesMain.CMPLogger.LogDebug((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		internal static void OnReceiveSync(ulong _, FastBufferReader reader)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			CustomMoonPricesMain.CMPLogger.LogDebug((object)"Config sync received from host.");
			if (!((FastBufferReader)(ref reader)).TryBeginRead(SyncedInstance<Config>.IntSize))
			{
				CustomMoonPricesMain.CMPLogger.LogError((object)"Config sync error: Could not begin reading buffer.");
				return;
			}
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
			{
				CustomMoonPricesMain.CMPLogger.LogError((object)"Config sync error: Host could not sync.");
				return;
			}
			byte[] data = new byte[num];
			((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
			try
			{
				SyncedInstance<Config>.SyncInstance(data);
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(30000, (Allocator)2, -1);
				try
				{
					SyncedInstance<Config>.MessageManager.SendNamedMessage("CMP_SC", 0uL, val, (NetworkDelivery)3);
				}
				finally
				{
					((IDisposable)(FastBufferWriter)(ref val)).Dispose();
				}
			}
			catch (Exception arg)
			{
				CustomMoonPricesMain.CMPLogger.LogError((object)$"Error syncing config instance!\n{arg}");
			}
		}

		internal static void OnSettingChange(ulong _, FastBufferReader reader)
		{
			if (SyncedInstance<Config>.IsClient)
			{
				RequestSync();
			}
		}

		internal static void OnReceivedSync(ulong senderClientId, FastBufferReader messagePayload)
		{
			if (SyncedInstance<Config>.IsHost)
			{
				CustomMoonPricesMain.CMPLogger.LogDebug((object)("Client " + senderClientId + " Succesfully Synced."));
			}
		}
	}
	[BepInPlugin("zz.cursedbreath.custommoonprices", "Custom Moon Prices", "1.1.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("Lethal Company.exe")]
	public class CustomMoonPricesMain : BaseUnityPlugin
	{
		public const string UMID = "zz.cursedbreath.custommoonprices";

		public const string NAME = "Custom Moon Prices";

		public const string VERSION = "1.1.2";

		private Harmony harmony;

		public static CustomMoonPricesMain CustomMoonPricesMainInstance;

		public static ConfigFile LethalConfigSettings;

		public static bool existLethalLevelLoader;

		public static ManualLogSource CMPLogger;

		private void Awake()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			CMPLogger = ((BaseUnityPlugin)this).Logger;
			harmony = new Harmony("zz.cursedbreath.custommoonprices");
			LethalConfigSettings = ((BaseUnityPlugin)this).Config;
			new Config();
			harmony.PatchAll(typeof(MoonPricePatches));
			harmony.PatchAll(typeof(ConfigSyncPatch));
			foreach (PluginInfo item in Chainloader.PluginInfos.Values.ToList())
			{
				if (item.Metadata.GUID == "imabatby.lethallevelloader")
				{
					existLethalLevelLoader = true;
				}
			}
		}
	}
	[Serializable]
	public class moonData
	{
		private bool enabled;

		private int price;

		public moonData(bool enabled, int price)
		{
			this.enabled = enabled;
			this.price = price;
		}

		public bool getEnabled()
		{
			return enabled;
		}

		public int getPrice()
		{
			return price;
		}

		public void setEnabled(bool enabled)
		{
			this.enabled = enabled;
		}

		public void setPrice(int price)
		{
			this.price = price;
		}
	}
}
namespace CustomMoonPrices.Patches
{
	public class ConfigSyncPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		public static void InitializeLocalPlayer()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			if (SyncedInstance<Config>.IsHost)
			{
				SyncedInstance<Config>.MessageManager.RegisterNamedMessageHandler("CMP_ORS", new HandleNamedMessageDelegate(Config.OnRequestSync));
				SyncedInstance<Config>.MessageManager.RegisterNamedMessageHandler("CMP_SC", new HandleNamedMessageDelegate(Config.OnReceivedSync));
				SyncedInstance<Config>.Synced = true;
			}
			else
			{
				SyncedInstance<Config>.Synced = false;
				SyncedInstance<Config>.MessageManager.RegisterNamedMessageHandler("CMP_OSC", new HandleNamedMessageDelegate(Config.OnSettingChange));
				SyncedInstance<Config>.MessageManager.RegisterNamedMessageHandler("CMP_ORCS", new HandleNamedMessageDelegate(Config.OnReceiveSync));
				Config.RequestSync();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
		public static void PlayerLeave()
		{
			SyncedInstance<Config>.RevertSync();
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	public class MoonPricePatches
	{
		public static Terminal terminal;

		private static int totalCostOfItems = -5;

		private static Dictionary<string, int> defaultMoonPrices = new Dictionary<string, int>();

		internal static string GetNumberlessPlanetName(SelectableLevel selectableLevel)
		{
			if ((Object)(object)selectableLevel != (Object)null)
			{
				return new string(selectableLevel.PlanetName.SkipWhile((char c) => !char.IsLetter(c)).ToArray());
			}
			return string.Empty;
		}

		private static string GetMoonName(string id)
		{
			return id switch
			{
				"8" => "titan", 
				"7" => "dine", 
				"85" => "rend", 
				"61" => "march", 
				"56" => "vow", 
				"220" => "assurance", 
				"41" => "experimentation", 
				"21" => "offense", 
				"5" => "embrion", 
				"68" => "artifice", 
				null => null, 
				_ => null, 
			};
		}

		[HarmonyPriority(100)]
		[HarmonyPatch(typeof(RoundManager), "Start")]
		[HarmonyPostfix]
		internal static void RoundManagerStart_Prefix()
		{
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			if (!CustomMoonPricesMain.existLethalLevelLoader)
			{
				return;
			}
			try
			{
				foreach (ExtendedLevel customExtendedLevel in PatchedContent.CustomExtendedLevels)
				{
					string configname = customExtendedLevel.NumberlessPlanetName;
					configname = configname.Replace(" ", "").ToLower();
					if (!configname.Contains("gordion"))
					{
						ConfigEntry<bool> val = CustomMoonPricesMain.LethalConfigSettings.Bind<bool>(configname, "Enable", false, "Setting if custom Price for: " + configname + " should be applied.");
						ConfigEntry<int> val2 = CustomMoonPricesMain.LethalConfigSettings.Bind<int>(configname, "Price", 0, "Setting the custom Price for: " + configname + ".");
						val.SettingChanged += delegate
						{
							bool value4 = CustomMoonPricesMain.LethalConfigSettings.Bind<bool>(configname, "Enable", false, "Setting if custom Price for: " + configname + " should be applied.").Value;
							SyncedInstance<Config>.Instance.updateMoonEnabled(configname, value4);
						};
						val2.SettingChanged += delegate
						{
							int value3 = CustomMoonPricesMain.LethalConfigSettings.Bind<int>(configname, "Price", 0, "Setting the custom Price for: " + configname + ".").Value;
							SyncedInstance<Config>.Instance.updateMoonPrice(configname, value3);
						};
						if (SyncedInstance<Config>.Instance.moonData.ContainsKey(configname))
						{
							bool value = CustomMoonPricesMain.LethalConfigSettings.Bind<bool>(configname, "Enable", false, "Setting if custom Price for: " + configname + " should be applied.").Value;
							int value2 = CustomMoonPricesMain.LethalConfigSettings.Bind<int>(configname, "Price", 0, "Setting the custom Price for: " + configname + ".").Value;
							SyncedInstance<Config>.Instance.updateMoonEnabled(configname, value);
							SyncedInstance<Config>.Instance.updateMoonPrice(configname, value2);
						}
						else
						{
							SyncedInstance<Config>.Instance.moonData[configname] = new moonData(val.Value, val2.Value);
						}
						BoolCheckBoxConfigItem val3 = new BoolCheckBoxConfigItem(val);
						IntInputFieldConfigItem val4 = new IntInputFieldConfigItem(val2);
						LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val3);
						LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
						if (!defaultMoonPrices.ContainsKey(configname))
						{
							defaultMoonPrices.Add(configname, customExtendedLevel.RoutePrice);
						}
					}
				}
				CustomMoonPricesMain.LethalConfigSettings.Save();
			}
			catch (Exception ex)
			{
				CustomMoonPricesMain.CMPLogger.LogError((object)("Error in finding Adding Moons to Dictionary: " + ex));
			}
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void FindTerminal()
		{
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			terminal = Object.FindObjectOfType<Terminal>();
			if ((Object)(object)terminal == (Object)null)
			{
				CustomMoonPricesMain.CMPLogger.LogDebug((object)"Terminal not found!");
			}
			else
			{
				CustomMoonPricesMain.CMPLogger.LogDebug((object)"Terminal found!");
			}
			try
			{
				SelectableLevel[] levels = StartOfRound.Instance.levels;
				foreach (SelectableLevel val in levels)
				{
					if (!((Object)val).name.Contains("Company"))
					{
						string configname = GetNumberlessPlanetName(val).ToLower();
						CustomMoonPricesMain.CMPLogger.LogDebug((object)("ConfigName: " + configname));
						ConfigEntry<bool> val2 = CustomMoonPricesMain.LethalConfigSettings.Bind<bool>(configname, "Enable", false, "Setting if custom Price for: " + configname + " should be applied.");
						ConfigEntry<int> val3 = CustomMoonPricesMain.LethalConfigSettings.Bind<int>(configname, "Price", 0, "Setting the custom Price for: " + configname + ".");
						val2.SettingChanged += delegate
						{
							bool value4 = CustomMoonPricesMain.LethalConfigSettings.Bind<bool>(configname, "Enable", false, "Setting if custom Price for: " + configname + " should be applied.").Value;
							SyncedInstance<Config>.Instance.updateMoonEnabled(configname, value4);
						};
						val3.SettingChanged += delegate
						{
							int value3 = CustomMoonPricesMain.LethalConfigSettings.Bind<int>(configname, "Price", 0, "Setting the custom Price for: " + configname + ".").Value;
							SyncedInstance<Config>.Instance.updateMoonPrice(configname, value3);
						};
						if (SyncedInstance<Config>.Instance.moonData.ContainsKey(configname))
						{
							bool value = CustomMoonPricesMain.LethalConfigSettings.Bind<bool>(configname, "Enable", false, "Setting if custom Price for: " + configname + " should be applied.").Value;
							int value2 = CustomMoonPricesMain.LethalConfigSettings.Bind<int>(configname, "Price", 0, "Setting the custom Price for: " + configname + ".").Value;
							SyncedInstance<Config>.Instance.updateMoonEnabled(configname, value);
							SyncedInstance<Config>.Instance.updateMoonPrice(configname, value2);
						}
						else
						{
							SyncedInstance<Config>.Instance.moonData[configname] = new moonData(val2.Value, val3.Value);
						}
						BoolCheckBoxConfigItem val4 = new BoolCheckBoxConfigItem(val2);
						IntInputFieldConfigItem val5 = new IntInputFieldConfigItem(val3);
						LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
						LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val5);
						if (!defaultMoonPrices.ContainsKey(configname))
						{
							defaultMoonPrices.Add(configname, 0);
						}
						if (!SyncedInstance<Config>.Instance.moonData.ContainsKey(configname))
						{
							SyncedInstance<Config>.Instance.moonData[configname] = new moonData(val2.Value, val3.Value);
						}
					}
				}
				CustomMoonPricesMain.LethalConfigSettings.Save();
			}
			catch (Exception ex)
			{
				CustomMoonPricesMain.CMPLogger.LogError((object)("Error in finding Adding Moons to Dictionary: " + ex));
			}
		}

		[HarmonyPatch("LoadNewNode")]
		[HarmonyPrefix]
		private static void LoadNewNodePatchBefore(ref TerminalNode node)
		{
			if (node.buyRerouteToMoon != -2)
			{
				return;
			}
			Traverse val = Traverse.Create((object)terminal).Field("totalCostOfItems");
			string text = ((Object)node).name;
			if (text.Contains("route"))
			{
				text = text.Replace("route", "");
			}
			if (text.Contains("Route") || text.Contains("Confirm"))
			{
				text = text.Replace("Route", "");
				text = text.Replace("Confirm", "");
			}
			text = ((GetMoonName(text) == null) ? new string(text.SkipWhile((char c) => !char.IsLetter(c)).ToArray()) : GetMoonName(text));
			CustomMoonPricesMain.CMPLogger.LogDebug((object)("Moonname: " + text));
			if (text == null)
			{
				CustomMoonPricesMain.CMPLogger.LogDebug((object)"Moon not found (Just a Reminder when not a moon node)!");
				return;
			}
			if (text.Equals("CompanyMoon"))
			{
				CustomMoonPricesMain.CMPLogger.LogDebug((object)"Company Moon no Costs Possible!");
				return;
			}
			try
			{
				if (defaultMoonPrices[text] == 0)
				{
					defaultMoonPrices[text] = node.itemCost;
				}
				if (SyncedInstance<Config>.Instance.moonData[text].getEnabled())
				{
					totalCostOfItems = (int)val.GetValue();
					val.SetValue((object)SyncedInstance<Config>.Instance.moonData[text].getPrice());
				}
				else
				{
					val.SetValue((object)defaultMoonPrices[text]);
				}
			}
			catch (Exception)
			{
			}
		}

		[HarmonyPatch("LoadNewNode")]
		[HarmonyPostfix]
		private static void LoadNewNodePatchAfter(ref TerminalNode node)
		{
			Traverse val = Traverse.Create((object)terminal).Field("totalCostOfItems");
			if (totalCostOfItems == -5)
			{
				return;
			}
			string text = ((Object)node).name;
			if (text.Contains("route"))
			{
				text = text.Replace("route", "");
			}
			if (text.Contains("Route") || text.Contains("Confirm"))
			{
				text = text.Replace("Route", "");
				text = text.Replace("Confirm", "");
			}
			text = ((GetMoonName(text) == null) ? new string(text.SkipWhile((char c) => !char.IsLetter(c)).ToArray()) : GetMoonName(text));
			CustomMoonPricesMain.CMPLogger.LogDebug((object)("Moonname: " + text));
			if (text == null)
			{
				CustomMoonPricesMain.CMPLogger.LogDebug((object)"Moon not found (Just a Reminder when not a moon node)!");
				return;
			}
			if (text.Equals("CompanyMoon"))
			{
				CustomMoonPricesMain.CMPLogger.LogDebug((object)"Company Moon no Costs Possible!");
				return;
			}
			try
			{
				if (SyncedInstance<Config>.Instance.moonData[text].getEnabled())
				{
					val.SetValue((object)SyncedInstance<Config>.Instance.moonData[text].getPrice());
				}
				else
				{
					val.SetValue((object)defaultMoonPrices[text]);
				}
				totalCostOfItems = -5;
			}
			catch (Exception)
			{
			}
		}

		[HarmonyPatch("LoadNewNodeIfAffordable")]
		[HarmonyPrefix]
		private static void LoadNewNodeIfAffordablePatch(ref TerminalNode node)
		{
			if ((Object)(object)node == (Object)null || node.buyRerouteToMoon == -1)
			{
				return;
			}
			string text = ((Object)node).name;
			if (text.Contains("route"))
			{
				text = text.Replace("route", "");
			}
			if (text.Contains("Route") || text.Contains("Confirm"))
			{
				text = text.Replace("Route", "");
				text = text.Replace("Confirm", "");
			}
			text = ((GetMoonName(text) == null) ? new string(text.SkipWhile((char c) => !char.IsLetter(c)).ToArray()) : GetMoonName(text));
			CustomMoonPricesMain.CMPLogger.LogDebug((object)("Moonname: " + text));
			if (text == null)
			{
				CustomMoonPricesMain.CMPLogger.LogDebug((object)"Moon not found (Just a Reminder when not a moon node)!");
				return;
			}
			if (text.Equals("CompanyMoon"))
			{
				CustomMoonPricesMain.CMPLogger.LogDebug((object)"Company Moon no Costs Possible!");
				return;
			}
			try
			{
				if (SyncedInstance<Config>.Instance.moonData[text].getEnabled())
				{
					node.itemCost = SyncedInstance<Config>.Instance.moonData[text].getPrice();
				}
				else
				{
					node.itemCost = defaultMoonPrices[text];
				}
			}
			catch (Exception)
			{
			}
		}
	}
}