LethalCompany/Lethal Company/ExportedProject/Assets/Scripts/Assembly-CSharp/Terminal.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using GameNetcodeStuff;
using Steamworks;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.UI;
using UnityEngine.Video;

public class Terminal : NetworkBehaviour
{
	public Canvas terminalUIScreen;

	public PlayerActions playerActions;

	public bool terminalInUse;

	public float timeSinceTerminalInUse;

	private InteractTrigger terminalTrigger;

	public RawImage terminalImage;

	public RectMask2D terminalImageMask;

	public RenderTexture videoTexture;

	public VideoPlayer videoPlayer;

	public TMP_InputField screenText;

	public int textAdded;

	public string currentText;

	public TerminalNode currentNode;

	public TerminalNodesList terminalNodes;

	[Space(3f)]
	public Animator terminalUIAnimator;

	public PlaceableShipObject placeableObject;

	private bool usedTerminalThisSession;

	private bool modifyingText;

	public int playerDefinedAmount;

	private RoundManager roundManager;

	public int groupCredits;

	private int totalCostOfItems;

	public AudioSource terminalAudio;

	public AudioClip[] keyboardClips;

	public AudioClip[] syncedAudios;

	private float timeSinceLastKeyboardPress;

	public bool useCreditsCooldown;

	private Coroutine loadImageCoroutine;

	private bool hasGottenNoun;

	private bool hasGottenVerb;

	[Space(7f)]
	private bool broadcastedCodeThisFrame;

	public Animator codeBroadcastAnimator;

	public AudioClip codeBroadcastSFX;

	[Space(5f)]
	public List<int> scannedEnemyIDs = new List<int>();

	public List<TerminalNode> enemyFiles = new List<TerminalNode>();

	public List<int> newlyScannedEnemyIDs = new List<int>();

	[Space(3f)]
	public List<int> unlockedStoryLogs = new List<int>();

	public List<TerminalNode> logEntryFiles = new List<TerminalNode>();

	public List<int> newlyUnlockedStoryLogs = new List<int>();

	[Space(7f)]
	public List<TerminalNode> ShipDecorSelection = new List<TerminalNode>();

	private bool syncedTerminalValues;

	public int numberOfItemsInDropship;

	public Scrollbar scrollBarVertical;

	public TextMeshProUGUI inputFieldText;

	public CanvasGroup scrollBarCanvasGroup;

	public RenderTexture playerScreenTex;

	public RenderTexture playerScreenTexHighRes;

	public TextMeshProUGUI topRightText;

	public SelectableLevel[] moonsCatalogueList;

	[Header("Store-bought player items")]
	public Item[] buyableItemsList;

	public int[] itemSalesPercentages;

	[Space(3f)]
	public List<int> orderedItemsFromTerminal;

	[Space(5f)]
	private Coroutine selectTextFieldCoroutine;

	public AudioClip enterTerminalSFX;

	public AudioClip leaveTerminalSFX;

	public Light terminalLight;

	private Coroutine forceScrollbarCoroutine;

	public bool displayingSteamKeyboard;

	public Texture displayingPersistentImage;

	private void Update()
	{
		if (HUDManager.Instance == null || GameNetworkManager.Instance == null || GameNetworkManager.Instance.localPlayerController == null)
		{
			return;
		}
		if (terminalInUse)
		{
			topRightText.text = $"${groupCredits}";
			screenText.caretPosition = screenText.text.Length;
			HUDManager.Instance.playerScreenTexture.texture = playerScreenTexHighRes;
			GameNetworkManager.Instance.localPlayerController.gameplayCamera.targetTexture = playerScreenTexHighRes;
			if (Keyboard.current.anyKey.wasPressedThisFrame)
			{
				if (timeSinceLastKeyboardPress > 0.07f)
				{
					timeSinceLastKeyboardPress = 0f;
					RoundManager.PlayRandomClip(terminalAudio, keyboardClips);
				}
				if (scrollBarVertical.value != 0f)
				{
					scrollBarVertical.value = 0f;
					if (forceScrollbarCoroutine != null)
					{
						StopCoroutine(forceScrollbarCoroutine);
					}
					forceScrollbarCoroutine = StartCoroutine(forceScrollbarDown());
				}
			}
			timeSinceLastKeyboardPress += Time.deltaTime;
			if (scrollBarVertical.value < 0.95f)
			{
				scrollBarCanvasGroup.alpha = Mathf.Lerp(scrollBarCanvasGroup.alpha, 1f, 10f * Time.deltaTime);
			}
			else
			{
				scrollBarCanvasGroup.alpha = 0f;
			}
		}
		else
		{
			timeSinceTerminalInUse += Time.deltaTime;
			HUDManager.Instance.playerScreenTexture.texture = playerScreenTex;
			GameNetworkManager.Instance.localPlayerController.gameplayCamera.targetTexture = playerScreenTex;
		}
	}

	private IEnumerator forceScrollbarDown()
	{
		for (int i = 0; i < 5; i++)
		{
			yield return null;
			scrollBarVertical.value = 0f;
		}
	}

	private IEnumerator forceScrollbarUp()
	{
		for (int i = 0; i < 5; i++)
		{
			yield return null;
			scrollBarVertical.value = 1f;
		}
	}

	public void LoadNewNode(TerminalNode node)
	{
		modifyingText = true;
		RunTerminalEvents(node);
		screenText.interactable = true;
		string text = "";
		if (node.clearPreviousText)
		{
			text = "\n\n\n" + node.displayText.ToString();
		}
		else
		{
			text = "\n\n" + screenText.text.ToString() + "\n\n" + node.displayText.ToString();
			int value = text.Length - 250;
			text = text.Substring(Mathf.Clamp(value, 0, text.Length)).ToString();
		}
		try
		{
			text = TextPostProcess(text, node);
		}
		catch (Exception arg)
		{
			Debug.LogError($"An error occured while post processing terminal text: {arg}");
		}
		screenText.text = text;
		currentText = screenText.text;
		textAdded = 0;
		if (node.playSyncedClip != -1)
		{
			PlayTerminalAudioServerRpc(node.playSyncedClip);
		}
		else if (node.playClip != null)
		{
			terminalAudio.PlayOneShot(node.playClip);
		}
		LoadTerminalImage(node);
		currentNode = node;
	}

	[ServerRpc(RequireOwnership = false)]
	public void PlayTerminalAudioServerRpc(int clipIndex)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			if (__rpc_exec_stage != __RpcExecStage.Server && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams serverRpcParams = default(ServerRpcParams);
				FastBufferWriter bufferWriter = __beginSendServerRpc(1713627637u, serverRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, clipIndex);
				__endSendServerRpc(ref bufferWriter, 1713627637u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				PlayTerminalAudioClientRpc(clipIndex);
			}
		}
	}

	[ClientRpc]
	public void PlayTerminalAudioClientRpc(int clipIndex)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			if (__rpc_exec_stage != __RpcExecStage.Client && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams clientRpcParams = default(ClientRpcParams);
				FastBufferWriter bufferWriter = __beginSendClientRpc(1118892272u, clientRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, clipIndex);
				__endSendClientRpc(ref bufferWriter, 1118892272u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !(GameNetworkManager.Instance.localPlayerController == null))
			{
				terminalAudio.PlayOneShot(syncedAudios[clipIndex]);
			}
		}
	}

	private IEnumerator loadTextAnimation()
	{
		screenText.textComponent.maxVisibleLines = 0;
		for (int i = 0; i < 30; i++)
		{
			screenText.textComponent.maxVisibleLines += 2;
			yield return null;
		}
		screenText.textComponent.maxVisibleLines = 100;
	}

	private string TextPostProcess(string modifiedDisplayText, TerminalNode node)
	{
		int num = modifiedDisplayText.Split("[planetTime]").Length - 1;
		if (num > 0)
		{
			Regex regex = new Regex(Regex.Escape("[planetTime]"));
			for (int i = 0; i < num && moonsCatalogueList.Length > i; i++)
			{
				Debug.Log($"isDemo:{GameNetworkManager.Instance.isDemo} ; {moonsCatalogueList[i].lockedForDemo}");
				string replacement = ((GameNetworkManager.Instance.isDemo && moonsCatalogueList[i].lockedForDemo) ? "(Locked)" : ((moonsCatalogueList[i].currentWeather != LevelWeatherType.None) ? ("(" + moonsCatalogueList[i].currentWeather.ToString() + ")") : ""));
				modifiedDisplayText = regex.Replace(modifiedDisplayText, replacement, 1);
			}
		}
		try
		{
			if (node.displayPlanetInfo != -1)
			{
				string replacement = ((StartOfRound.Instance.levels[node.displayPlanetInfo].currentWeather != LevelWeatherType.None) ? (StartOfRound.Instance.levels[node.displayPlanetInfo].currentWeather.ToString().ToLower() ?? "") : "mild weather");
				modifiedDisplayText = modifiedDisplayText.Replace("[currentPlanetTime]", replacement);
			}
		}
		catch
		{
			Debug.Log($"Exception occured on terminal while setting node planet info; current node displayPlanetInfo:{node.displayPlanetInfo}");
		}
		if (modifiedDisplayText.Contains("[currentScannedEnemiesList]"))
		{
			if (scannedEnemyIDs == null || scannedEnemyIDs.Count <= 0)
			{
				modifiedDisplayText = modifiedDisplayText.Replace("[currentScannedEnemiesList]", "No data collected on wildlife. Scans are required.");
			}
			else
			{
				StringBuilder stringBuilder = new StringBuilder();
				for (int j = 0; j < scannedEnemyIDs.Count; j++)
				{
					Debug.Log($"scanID # {j}: {scannedEnemyIDs[j]}; {enemyFiles[scannedEnemyIDs[j]].creatureName}");
					Debug.Log($"scanID # {j}: {scannedEnemyIDs[j]}");
					stringBuilder.Append("\n" + enemyFiles[scannedEnemyIDs[j]].creatureName);
					if (newlyScannedEnemyIDs.Contains(scannedEnemyIDs[j]))
					{
						stringBuilder.Append(" (NEW)");
					}
				}
				modifiedDisplayText = modifiedDisplayText.Replace("[currentScannedEnemiesList]", stringBuilder.ToString());
			}
		}
		if (modifiedDisplayText.Contains("[buyableItemsList]"))
		{
			if (buyableItemsList == null || buyableItemsList.Length == 0)
			{
				modifiedDisplayText = modifiedDisplayText.Replace("[buyableItemsList]", "[No items in stock!]");
			}
			else
			{
				StringBuilder stringBuilder2 = new StringBuilder();
				for (int k = 0; k < buyableItemsList.Length; k++)
				{
					if (GameNetworkManager.Instance.isDemo && buyableItemsList[k].lockedInDemo)
					{
						stringBuilder2.Append("\n* " + buyableItemsList[k].itemName + " (Locked)");
					}
					else
					{
						stringBuilder2.Append("\n* " + buyableItemsList[k].itemName + "  //  Price: $" + (float)buyableItemsList[k].creditsWorth * ((float)itemSalesPercentages[k] / 100f));
					}
					if (itemSalesPercentages[k] != 100)
					{
						stringBuilder2.Append($"   ({100 - itemSalesPercentages[k]}% OFF!)");
					}
				}
				modifiedDisplayText = modifiedDisplayText.Replace("[buyableItemsList]", stringBuilder2.ToString());
			}
		}
		if (modifiedDisplayText.Contains("[currentUnlockedLogsList]"))
		{
			if (unlockedStoryLogs == null || unlockedStoryLogs.Count <= 0)
			{
				modifiedDisplayText = modifiedDisplayText.Replace("[currentUnlockedLogsList]", "[ALL DATA HAS BEEN CORRUPTED OR OVERWRITTEN]");
			}
			else
			{
				StringBuilder stringBuilder3 = new StringBuilder();
				for (int l = 0; l < unlockedStoryLogs.Count; l++)
				{
					stringBuilder3.Append("\n" + logEntryFiles[unlockedStoryLogs[l]].creatureName);
					if (newlyUnlockedStoryLogs.Contains(unlockedStoryLogs[l]))
					{
						stringBuilder3.Append(" (NEW)");
					}
				}
				modifiedDisplayText = modifiedDisplayText.Replace("[currentUnlockedLogsList]", stringBuilder3.ToString());
			}
		}
		if (modifiedDisplayText.Contains("[unlockablesSelectionList]"))
		{
			if (ShipDecorSelection == null || ShipDecorSelection.Count <= 0)
			{
				modifiedDisplayText = modifiedDisplayText.Replace("[unlockablesSelectionList]", "[No items available]");
			}
			else
			{
				StringBuilder stringBuilder4 = new StringBuilder();
				for (int m = 0; m < ShipDecorSelection.Count; m++)
				{
					stringBuilder4.Append($"\n{ShipDecorSelection[m].creatureName}  //  ${ShipDecorSelection[m].itemCost}");
				}
				modifiedDisplayText = modifiedDisplayText.Replace("[unlockablesSelectionList]", stringBuilder4.ToString());
			}
		}
		if (modifiedDisplayText.Contains("[storedUnlockablesList]"))
		{
			StringBuilder stringBuilder5 = new StringBuilder();
			bool flag = false;
			for (int n = 0; n < StartOfRound.Instance.unlockablesList.unlockables.Count; n++)
			{
				if (StartOfRound.Instance.unlockablesList.unlockables[n].inStorage)
				{
					flag = true;
					stringBuilder5.Append("\n" + StartOfRound.Instance.unlockablesList.unlockables[n].unlockableName);
				}
			}
			modifiedDisplayText = (flag ? modifiedDisplayText.Replace("[storedUnlockablesList]", stringBuilder5.ToString()) : modifiedDisplayText.Replace("[storedUnlockablesList]", "[No items stored. While moving an object with B, press X to store it.]"));
		}
		if (modifiedDisplayText.Contains("[scanForItems]"))
		{
			System.Random random = new System.Random(StartOfRound.Instance.randomMapSeed + 91);
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			GrabbableObject[] array = UnityEngine.Object.FindObjectsOfType<GrabbableObject>();
			for (int num5 = 0; num5 < array.Length; num5++)
			{
				if (array[num5].itemProperties.isScrap && !array[num5].isInShipRoom && !array[num5].isInElevator)
				{
					num4 += array[num5].itemProperties.maxValue - array[num5].itemProperties.minValue;
					num3 += Mathf.Clamp(random.Next(array[num5].itemProperties.minValue, array[num5].itemProperties.maxValue), array[num5].scrapValue - 6 * num5, array[num5].scrapValue + 9 * num5);
					num2++;
				}
			}
			modifiedDisplayText = modifiedDisplayText.Replace("[scanForItems]", $"There are {num2} objects outside the ship, totalling at an approximate value of ${num3}.");
		}
		modifiedDisplayText = ((numberOfItemsInDropship > 0) ? modifiedDisplayText.Replace("[numberOfItemsOnRoute]", $"{numberOfItemsInDropship} purchased items on route.") : modifiedDisplayText.Replace("[numberOfItemsOnRoute]", ""));
		modifiedDisplayText = modifiedDisplayText.Replace("[currentDay]", DateTime.Now.DayOfWeek.ToString());
		modifiedDisplayText = modifiedDisplayText.Replace("[variableAmount]", playerDefinedAmount.ToString());
		modifiedDisplayText = modifiedDisplayText.Replace("[playerCredits]", "$" + groupCredits);
		modifiedDisplayText = modifiedDisplayText.Replace("[totalCost]", "$" + totalCostOfItems);
		modifiedDisplayText = modifiedDisplayText.Replace("[companyBuyingPercent]", $"{Mathf.RoundToInt(StartOfRound.Instance.companyBuyingRate * 100f)}%");
		if ((bool)displayingPersistentImage)
		{
			modifiedDisplayText = "\n\n\n\n\n\n\n\n\n\n\n\n\n\nn\n\n\n\n\n\n" + modifiedDisplayText;
		}
		return modifiedDisplayText;
	}

	public void RunTerminalEvents(TerminalNode node)
	{
		if (!string.IsNullOrWhiteSpace(node.terminalEvent))
		{
			if (node.terminalEvent == "setUpTerminal")
			{
				ES3.Save("HasUsedTerminal", value: true, "LCGeneralSaveData");
			}
			if (node.terminalEvent == "cheat_ResetCredits" && (GameNetworkManager.Instance.localPlayerController.playerUsername == "Zeekerss" || GameNetworkManager.Instance.localPlayerController.playerUsername == "Blueray" || GameNetworkManager.Instance.localPlayerController.playerUsername == "Puffo") && GameNetworkManager.Instance.localPlayerController.IsServer)
			{
				useCreditsCooldown = true;
				groupCredits = 2500;
				SyncGroupCreditsServerRpc(groupCredits, numberOfItemsInDropship);
			}
			if (node.terminalEvent == "switchCamera")
			{
				StartOfRound.Instance.mapScreen.SwitchRadarTargetForward(callRPC: true);
			}
			if (base.IsServer && node.terminalEvent == "ejectPlayers" && !StartOfRound.Instance.isChallengeFile && StartOfRound.Instance.inShipPhase && !StartOfRound.Instance.firingPlayersCutsceneRunning)
			{
				StartOfRound.Instance.ManuallyEjectPlayersServerRpc();
			}
		}
	}

	public void LoadTerminalImage(TerminalNode node)
	{
		if ((bool)node.displayVideo)
		{
			terminalImage.enabled = true;
			terminalImage.texture = videoTexture;
			displayingPersistentImage = null;
			videoPlayer.clip = node.displayVideo;
			videoPlayer.enabled = true;
			if (node.loadImageSlowly)
			{
				if (loadImageCoroutine != null)
				{
					StopCoroutine(loadImageCoroutine);
				}
				loadImageCoroutine = StartCoroutine(loadImageSlowly());
			}
			return;
		}
		videoPlayer.enabled = false;
		if (node.displayTexture != null)
		{
			terminalImage.enabled = true;
			terminalImage.texture = node.displayTexture;
			if (node.persistentImage)
			{
				if (StartOfRound.Instance.inShipPhase || displayingPersistentImage == node.displayTexture)
				{
					displayingPersistentImage = null;
					terminalImage.enabled = false;
					return;
				}
				displayingPersistentImage = node.displayTexture;
			}
			if (node.loadImageSlowly)
			{
				if (loadImageCoroutine != null)
				{
					StopCoroutine(loadImageCoroutine);
				}
				loadImageCoroutine = StartCoroutine(loadImageSlowly());
			}
		}
		else if (!displayingPersistentImage)
		{
			terminalImage.enabled = false;
		}
	}

	private IEnumerator loadImageSlowly()
	{
		float paddingValue = 300f;
		while (paddingValue > 0f)
		{
			paddingValue -= Time.deltaTime * 100f * UnityEngine.Random.Range(0.3f, 1.7f);
			terminalImageMask.padding = new Vector4(0f, paddingValue, 0f, 0f);
			yield return null;
		}
		terminalImageMask.padding = Vector4.zero;
	}

	public void OnSubmit()
	{
		if (!terminalInUse)
		{
			return;
		}
		if (textAdded == 0)
		{
			screenText.ActivateInputField();
			screenText.Select();
			return;
		}
		if (currentNode != null && currentNode.acceptAnything)
		{
			LoadNewNode(currentNode.terminalOptions[0].result);
		}
		else
		{
			TerminalNode terminalNode = ParsePlayerSentence();
			if (terminalNode != null)
			{
				if (terminalNode.itemCost != 0 || terminalNode.buyRerouteToMoon == -2)
				{
					totalCostOfItems = terminalNode.itemCost * playerDefinedAmount;
				}
				if (terminalNode.buyItemIndex != -1 || (terminalNode.buyRerouteToMoon != -1 && terminalNode.buyRerouteToMoon != -2) || terminalNode.shipUnlockableID != -1)
				{
					LoadNewNodeIfAffordable(terminalNode);
				}
				else if (terminalNode.creatureFileID != -1)
				{
					AttemptLoadCreatureFileNode(terminalNode);
				}
				else if (terminalNode.storyLogFileID != -1)
				{
					AttemptLoadStoryLogFileNode(terminalNode);
				}
				else
				{
					LoadNewNode(terminalNode);
				}
			}
			else
			{
				modifyingText = true;
				screenText.text = screenText.text.Substring(0, screenText.text.Length - textAdded);
				currentText = screenText.text;
				textAdded = 0;
			}
		}
		screenText.ActivateInputField();
		screenText.Select();
		if (forceScrollbarCoroutine != null)
		{
			StopCoroutine(forceScrollbarCoroutine);
		}
		forceScrollbarCoroutine = StartCoroutine(forceScrollbarUp());
	}

	private void AttemptLoadCreatureFileNode(TerminalNode node)
	{
		if (scannedEnemyIDs.Contains(node.creatureFileID))
		{
			newlyScannedEnemyIDs.Remove(node.creatureFileID);
			LoadNewNode(node);
		}
		else
		{
			LoadNewNode(terminalNodes.specialNodes[6]);
		}
	}

	private void AttemptLoadStoryLogFileNode(TerminalNode node)
	{
		if (unlockedStoryLogs.Contains(node.storyLogFileID))
		{
			newlyUnlockedStoryLogs.Remove(node.storyLogFileID);
			LoadNewNode(node);
		}
		else
		{
			LoadNewNode(terminalNodes.specialNodes[9]);
		}
	}

	private void LoadNewNodeIfAffordable(TerminalNode node)
	{
		StartOfRound startOfRound = UnityEngine.Object.FindObjectOfType<StartOfRound>();
		if (node.buyRerouteToMoon != -1 && node.buyRerouteToMoon != -2)
		{
			if (!startOfRound.inShipPhase || startOfRound.travellingToNewLevel)
			{
				LoadNewNode(terminalNodes.specialNodes[3]);
				return;
			}
			playerDefinedAmount = 1;
		}
		else if (node.shipUnlockableID != -1)
		{
			playerDefinedAmount = 1;
		}
		if (node.buyItemIndex != -1)
		{
			if (node.buyItemIndex != -7)
			{
				totalCostOfItems = (int)((float)buyableItemsList[node.buyItemIndex].creditsWorth * ((float)itemSalesPercentages[node.buyItemIndex] / 100f) * (float)playerDefinedAmount);
			}
			else
			{
				totalCostOfItems = (int)((float)node.itemCost * ((float)itemSalesPercentages[node.buyItemIndex] / 100f) * (float)playerDefinedAmount);
			}
		}
		else if (node.buyRerouteToMoon != -1)
		{
			totalCostOfItems = node.itemCost;
		}
		else if (node.shipUnlockableID != -1)
		{
			totalCostOfItems = node.itemCost;
		}
		float num = 0f;
		if (node.buyItemIndex != -1)
		{
			for (int i = 0; i < playerDefinedAmount; i++)
			{
				num = ((node.buyItemIndex != -7) ? (num + 1f) : (num + 9f));
			}
		}
		if (useCreditsCooldown)
		{
			LoadNewNode(terminalNodes.specialNodes[5]);
			return;
		}
		if (node.shipUnlockableID != -1)
		{
			if (node.shipUnlockableID >= StartOfRound.Instance.unlockablesList.unlockables.Count)
			{
				LoadNewNode(terminalNodes.specialNodes[16]);
				return;
			}
			UnlockableItem unlockableItem = StartOfRound.Instance.unlockablesList.unlockables[node.shipUnlockableID];
			Debug.Log($"Is unlockable '{unlockableItem.unlockableName} in storage?: {unlockableItem.inStorage}");
			if (unlockableItem.inStorage && (unlockableItem.hasBeenUnlockedByPlayer || unlockableItem.alreadyUnlocked))
			{
				Debug.Log("Moving object out of storage 1");
				if (node.returnFromStorage || unlockableItem.maxNumber <= 1)
				{
					Debug.Log("Moving object out of storage 2");
					startOfRound.ReturnUnlockableFromStorageServerRpc(node.shipUnlockableID);
					LoadNewNode(terminalNodes.specialNodes[17]);
					return;
				}
			}
		}
		if (groupCredits < totalCostOfItems)
		{
			LoadNewNode(terminalNodes.specialNodes[2]);
			return;
		}
		if (playerDefinedAmount > 12 || num + (float)numberOfItemsInDropship > 12f)
		{
			LoadNewNode(terminalNodes.specialNodes[4]);
			return;
		}
		if (node.buyRerouteToMoon != -1 && node.buyRerouteToMoon != -2)
		{
			if (StartOfRound.Instance.isChallengeFile)
			{
				LoadNewNode(terminalNodes.specialNodes[24]);
				return;
			}
			if (StartOfRound.Instance.levels[node.buyRerouteToMoon] == StartOfRound.Instance.currentLevel)
			{
				LoadNewNode(terminalNodes.specialNodes[8]);
				return;
			}
		}
		else if (node.shipUnlockableID != -1)
		{
			UnlockableItem unlockableItem2 = StartOfRound.Instance.unlockablesList.unlockables[node.shipUnlockableID];
			if ((!StartOfRound.Instance.inShipPhase && !StartOfRound.Instance.shipHasLanded) || StartOfRound.Instance.shipAnimator.GetCurrentAnimatorStateInfo(0).tagHash != Animator.StringToHash("ShipIdle"))
			{
				LoadNewNode(terminalNodes.specialNodes[15]);
				return;
			}
			if (!ShipDecorSelection.Contains(node) && !unlockableItem2.alwaysInStock && (!node.buyUnlockable || unlockableItem2.shopSelectionNode == null))
			{
				Debug.Log("Not in stock, node: " + node.name);
				LoadNewNode(terminalNodes.specialNodes[16]);
				return;
			}
			if (unlockableItem2.hasBeenUnlockedByPlayer || unlockableItem2.alreadyUnlocked)
			{
				Debug.Log("Already unlocked, node: " + node.name);
				LoadNewNode(terminalNodes.specialNodes[14]);
				return;
			}
		}
		if ((GameNetworkManager.Instance.isDemo && node.itemCost > 0 && node.lockedInDemo) || (node.buyItemIndex != -1 && buyableItemsList[node.buyItemIndex].lockedInDemo))
		{
			LoadNewNode(terminalNodes.specialNodes[18]);
			return;
		}
		if (!node.isConfirmationNode)
		{
			if (node.shipUnlockableID != -1)
			{
				if (node.buyUnlockable)
				{
					groupCredits = Mathf.Clamp(groupCredits - totalCostOfItems, 0, 10000000);
				}
			}
			else
			{
				groupCredits = Mathf.Clamp(groupCredits - totalCostOfItems, 0, 10000000);
			}
		}
		if (!node.isConfirmationNode)
		{
			if (node.buyItemIndex != -1)
			{
				for (int j = 0; j < playerDefinedAmount; j++)
				{
					if (node.buyItemIndex == -7)
					{
						orderedItemsFromTerminal.Add(5);
						for (int k = 0; k < 4; k++)
						{
							orderedItemsFromTerminal.Add(1);
						}
						for (int l = 0; l < 4; l++)
						{
							orderedItemsFromTerminal.Add(6);
						}
						numberOfItemsInDropship += 9;
					}
					else
					{
						orderedItemsFromTerminal.Add(node.buyItemIndex);
						numberOfItemsInDropship++;
					}
				}
				if (!base.IsServer)
				{
					SyncBoughtItemsWithServer(orderedItemsFromTerminal.ToArray(), numberOfItemsInDropship);
				}
				else
				{
					SyncGroupCreditsClientRpc(groupCredits, numberOfItemsInDropship);
				}
			}
			else if (node.buyRerouteToMoon != -1 && node.buyRerouteToMoon != -2)
			{
				useCreditsCooldown = true;
				startOfRound.ChangeLevelServerRpc(node.buyRerouteToMoon, groupCredits);
			}
			else if (node.shipUnlockableID != -1 && node.buyUnlockable)
			{
				HUDManager.Instance.DisplayTip("Tip", "Press B to move and place objects in the ship, E to cancel.", isWarning: false, useSave: true, "LC_MoveObjectsTip");
				startOfRound.BuyShipUnlockableServerRpc(node.shipUnlockableID, groupCredits);
			}
		}
		LoadNewNode(node);
	}

	private void SyncBoughtItemsWithServer(int[] boughtItems, int numItemsInShip)
	{
		if (!base.IsServer && boughtItems.Length <= 12)
		{
			useCreditsCooldown = true;
			BuyItemsServerRpc(boughtItems, groupCredits, numItemsInShip);
			orderedItemsFromTerminal.Clear();
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void BuyItemsServerRpc(int[] boughtItems, int newGroupCredits, int numItemsInShip)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if (__rpc_exec_stage != __RpcExecStage.Server && (networkManager.IsClient || networkManager.IsHost))
		{
			ServerRpcParams serverRpcParams = default(ServerRpcParams);
			FastBufferWriter bufferWriter = __beginSendServerRpc(4003509079u, serverRpcParams, RpcDelivery.Reliable);
			bool value = boughtItems != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(boughtItems, default(FastBufferWriter.ForPrimitives));
			}
			BytePacker.WriteValueBitPacked(bufferWriter, newGroupCredits);
			BytePacker.WriteValueBitPacked(bufferWriter, numItemsInShip);
			__endSendServerRpc(ref bufferWriter, 4003509079u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost) && boughtItems.Length <= 12 && newGroupCredits <= groupCredits)
		{
			orderedItemsFromTerminal.AddRange(boughtItems.ToList());
			groupCredits = newGroupCredits;
			SyncGroupCreditsClientRpc(newGroupCredits, numItemsInShip);
		}
	}

	[ServerRpc]
	public void SyncGroupCreditsServerRpc(int newGroupCredits, int numItemsInShip)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if (__rpc_exec_stage != __RpcExecStage.Server && (networkManager.IsClient || networkManager.IsHost))
		{
			if (base.OwnerClientId != networkManager.LocalClientId)
			{
				if (networkManager.LogLevel <= LogLevel.Normal)
				{
					Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			ServerRpcParams serverRpcParams = default(ServerRpcParams);
			FastBufferWriter bufferWriter = __beginSendServerRpc(3085407145u, serverRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, newGroupCredits);
			BytePacker.WriteValueBitPacked(bufferWriter, numItemsInShip);
			__endSendServerRpc(ref bufferWriter, 3085407145u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
		{
			if (newGroupCredits < 0)
			{
				newGroupCredits = groupCredits;
			}
			else
			{
				groupCredits = newGroupCredits;
			}
			SyncGroupCreditsClientRpc(newGroupCredits, numItemsInShip);
		}
	}

	[ClientRpc]
	public void SyncGroupCreditsClientRpc(int newGroupCredits, int numItemsInShip)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			if (__rpc_exec_stage != __RpcExecStage.Client && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams clientRpcParams = default(ClientRpcParams);
				FastBufferWriter bufferWriter = __beginSendClientRpc(2039928764u, clientRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, newGroupCredits);
				BytePacker.WriteValueBitPacked(bufferWriter, numItemsInShip);
				__endSendClientRpc(ref bufferWriter, 2039928764u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				numberOfItemsInDropship = numItemsInShip;
				useCreditsCooldown = false;
				groupCredits = newGroupCredits;
			}
		}
	}

	private TerminalNode ParsePlayerSentence()
	{
		broadcastedCodeThisFrame = false;
		string s = screenText.text.Substring(screenText.text.Length - textAdded);
		s = RemovePunctuation(s);
		string[] array = s.Split(" ", StringSplitOptions.RemoveEmptyEntries);
		TerminalKeyword terminalKeyword = null;
		if (currentNode != null && currentNode.overrideOptions)
		{
			for (int i = 0; i < array.Length; i++)
			{
				TerminalNode terminalNode = ParseWordOverrideOptions(array[i], currentNode.terminalOptions);
				if (terminalNode != null)
				{
					return terminalNode;
				}
			}
			return null;
		}
		if (array.Length > 1)
		{
			switch (array[0])
			{
			case "switch":
			{
				int num = CheckForPlayerNameCommand(array[0], array[1]);
				if (num != -1)
				{
					StartOfRound.Instance.mapScreen.SwitchRadarTargetAndSync(num);
					return terminalNodes.specialNodes[20];
				}
				break;
			}
			case "flash":
			{
				int num = CheckForPlayerNameCommand(array[0], array[1]);
				if (num != -1)
				{
					StartOfRound.Instance.mapScreen.FlashRadarBooster(num);
					return terminalNodes.specialNodes[23];
				}
				if (StartOfRound.Instance.mapScreen.radarTargets[StartOfRound.Instance.mapScreen.targetTransformIndex].isNonPlayer)
				{
					StartOfRound.Instance.mapScreen.FlashRadarBooster(StartOfRound.Instance.mapScreen.targetTransformIndex);
					return terminalNodes.specialNodes[23];
				}
				break;
			}
			case "ping":
			{
				int num = CheckForPlayerNameCommand(array[0], array[1]);
				if (num != -1)
				{
					StartOfRound.Instance.mapScreen.PingRadarBooster(num);
					return terminalNodes.specialNodes[21];
				}
				break;
			}
			case "transmit":
			{
				SignalTranslator signalTranslator = UnityEngine.Object.FindObjectOfType<SignalTranslator>();
				if (!(signalTranslator != null) || !(Time.realtimeSinceStartup - signalTranslator.timeLastUsingSignalTranslator > 8f) || array.Length < 2)
				{
					break;
				}
				string text = s.Substring(8);
				if (!string.IsNullOrEmpty(text))
				{
					if (!base.IsServer)
					{
						signalTranslator.timeLastUsingSignalTranslator = Time.realtimeSinceStartup;
					}
					HUDManager.Instance.UseSignalTranslatorServerRpc(text.Substring(0, Mathf.Min(text.Length, 10)));
					return terminalNodes.specialNodes[22];
				}
				break;
			}
			}
		}
		terminalKeyword = CheckForExactSentences(s);
		if (terminalKeyword != null)
		{
			if (terminalKeyword.accessTerminalObjects)
			{
				CallFunctionInAccessibleTerminalObject(terminalKeyword.word);
				PlayBroadcastCodeEffect();
				return null;
			}
			if (terminalKeyword.specialKeywordResult != null)
			{
				return terminalKeyword.specialKeywordResult;
			}
		}
		string value = Regex.Match(s, "\\d+").Value;
		if (!string.IsNullOrWhiteSpace(value))
		{
			playerDefinedAmount = Mathf.Clamp(int.Parse(value), 0, 10);
		}
		else
		{
			playerDefinedAmount = 1;
		}
		if (array.Length > 5)
		{
			return null;
		}
		TerminalKeyword terminalKeyword2 = null;
		TerminalKeyword terminalKeyword3 = null;
		new List<TerminalKeyword>();
		bool flag = false;
		hasGottenNoun = false;
		hasGottenVerb = false;
		for (int j = 0; j < array.Length; j++)
		{
			terminalKeyword = ParseWord(array[j]);
			if (terminalKeyword != null)
			{
				Debug.Log("Parsed word: " + array[j]);
				if (terminalKeyword.isVerb)
				{
					if (hasGottenVerb)
					{
						continue;
					}
					hasGottenVerb = true;
					terminalKeyword2 = terminalKeyword;
				}
				else
				{
					if (hasGottenNoun)
					{
						continue;
					}
					hasGottenNoun = true;
					terminalKeyword3 = terminalKeyword;
					if (terminalKeyword.accessTerminalObjects)
					{
						broadcastedCodeThisFrame = true;
						CallFunctionInAccessibleTerminalObject(terminalKeyword.word);
						flag = true;
					}
				}
				if (!flag && hasGottenNoun && hasGottenVerb)
				{
					break;
				}
			}
			else
			{
				Debug.Log("Could not parse word: " + array[j]);
			}
		}
		if (broadcastedCodeThisFrame)
		{
			PlayBroadcastCodeEffect();
			return terminalNodes.specialNodes[19];
		}
		hasGottenNoun = false;
		hasGottenVerb = false;
		if (terminalKeyword3 == null)
		{
			return terminalNodes.specialNodes[10];
		}
		if (terminalKeyword2 == null)
		{
			if (!(terminalKeyword3.defaultVerb != null))
			{
				return terminalNodes.specialNodes[11];
			}
			terminalKeyword2 = terminalKeyword3.defaultVerb;
		}
		for (int k = 0; k < terminalKeyword2.compatibleNouns.Length; k++)
		{
			if (terminalKeyword2.compatibleNouns[k].noun == terminalKeyword3)
			{
				Debug.Log($"noun keyword: {terminalKeyword3.word} ; verb keyword: {terminalKeyword2.word} ; result null? : {terminalKeyword2.compatibleNouns[k].result == null}");
				Debug.Log("result: " + terminalKeyword2.compatibleNouns[k].result.name);
				return terminalKeyword2.compatibleNouns[k].result;
			}
		}
		return terminalNodes.specialNodes[12];
	}

	private int CheckForPlayerNameCommand(string firstWord, string secondWord)
	{
		if (firstWord == "radar")
		{
			return -1;
		}
		if (secondWord.Length <= 2)
		{
			return -1;
		}
		Debug.Log("first word: " + firstWord + "; second word: " + secondWord);
		List<string> list = new List<string>();
		for (int i = 0; i < StartOfRound.Instance.mapScreen.radarTargets.Count; i++)
		{
			list.Add(StartOfRound.Instance.mapScreen.radarTargets[i].name);
			Debug.Log($"name {i}: {list[i]}");
		}
		secondWord = secondWord.ToLower();
		for (int j = 0; j < list.Count; j++)
		{
			string text = list[j].ToLower();
			if (text == secondWord)
			{
				return j;
			}
		}
		Debug.Log($"Target names length: {list.Count}");
		for (int k = 0; k < list.Count; k++)
		{
			Debug.Log("A");
			string text = list[k].ToLower();
			Debug.Log($"Word #{k}: {text}; length: {text.Length}");
			for (int num = secondWord.Length; num > 2; num--)
			{
				Debug.Log($"c: {num}");
				Debug.Log(secondWord.Substring(0, num));
				if (text.StartsWith(secondWord.Substring(0, num)))
				{
					return k;
				}
			}
		}
		return -1;
	}

	private TerminalKeyword CheckForExactSentences(string playerWord)
	{
		for (int i = 0; i < terminalNodes.allKeywords.Length; i++)
		{
			if (terminalNodes.allKeywords[i].word == playerWord)
			{
				return terminalNodes.allKeywords[i];
			}
		}
		return null;
	}

	private TerminalKeyword ParseWord(string playerWord, int specificityRequired = 2)
	{
		if (playerWord.Length < specificityRequired)
		{
			return null;
		}
		TerminalKeyword terminalKeyword = null;
		for (int i = 0; i < terminalNodes.allKeywords.Length; i++)
		{
			if (terminalNodes.allKeywords[i].isVerb && hasGottenVerb)
			{
				continue;
			}
			_ = terminalNodes.allKeywords[i].accessTerminalObjects;
			if (terminalNodes.allKeywords[i].word == playerWord)
			{
				return terminalNodes.allKeywords[i];
			}
			if (!(terminalKeyword == null))
			{
				continue;
			}
			for (int num = playerWord.Length; num > specificityRequired; num--)
			{
				if (terminalNodes.allKeywords[i].word.StartsWith(playerWord.Substring(0, num)))
				{
					terminalKeyword = terminalNodes.allKeywords[i];
				}
			}
		}
		return terminalKeyword;
	}

	private TerminalNode ParseWordOverrideOptions(string playerWord, CompatibleNoun[] options)
	{
		for (int i = 0; i < options.Length; i++)
		{
			for (int num = playerWord.Length; num > 0; num--)
			{
				if (options[i].noun.word.StartsWith(playerWord.Substring(0, num)))
				{
					return options[i].result;
				}
			}
		}
		return null;
	}

	public void TextChanged(string newText)
	{
		if (currentNode == null)
		{
			return;
		}
		if (modifyingText)
		{
			modifyingText = false;
			return;
		}
		textAdded += newText.Length - currentText.Length;
		if (textAdded < 0)
		{
			screenText.text = currentText;
			textAdded = 0;
		}
		else if (textAdded > currentNode.maxCharactersToType)
		{
			screenText.text = currentText;
			textAdded = currentNode.maxCharactersToType;
		}
		else
		{
			currentText = newText;
		}
	}

	private string RemovePunctuation(string s)
	{
		StringBuilder stringBuilder = new StringBuilder();
		foreach (char c in s)
		{
			if (!char.IsPunctuation(c))
			{
				stringBuilder.Append(c);
			}
		}
		return stringBuilder.ToString().ToLower();
	}

	private void CallFunctionInAccessibleTerminalObject(string word)
	{
		TerminalAccessibleObject[] array = UnityEngine.Object.FindObjectsOfType<TerminalAccessibleObject>();
		for (int i = 0; i < array.Length; i++)
		{
			if (array[i].objectCode == word)
			{
				Debug.Log("Found accessible terminal object with corresponding string, calling function");
				broadcastedCodeThisFrame = true;
				array[i].CallFunctionFromTerminal();
			}
		}
	}

	private void PlayBroadcastCodeEffect()
	{
		codeBroadcastAnimator.SetTrigger("display");
		terminalAudio.PlayOneShot(codeBroadcastSFX, 1f);
	}

	private void Awake()
	{
		playerActions = new PlayerActions();
		playerActions.Movement.Enable();
	}

	private void Start()
	{
		InitializeItemSalesPercentages();
		terminalTrigger = base.gameObject.GetComponent<InteractTrigger>();
		roundManager = UnityEngine.Object.FindObjectOfType<RoundManager>();
		if (base.IsServer)
		{
			syncedTerminalValues = true;
			int num = 0;
			if (StartOfRound.Instance.isChallengeFile)
			{
				if (!ES3.Load("SetChallengeFileMoney", GameNetworkManager.Instance.currentSaveFileName, defaultValue: false))
				{
					groupCredits = new System.Random(StartOfRound.Instance.randomMapSeed).Next(30, 900);
					Debug.Log($"Set challenge file money; {StartOfRound.Instance.randomMapSeed}; {groupCredits}");
				}
				else
				{
					groupCredits = ES3.Load("GroupCredits", GameNetworkManager.Instance.currentSaveFileName, TimeOfDay.Instance.quotaVariables.startingCredits) + num;
				}
			}
			else
			{
				num = ES3.Load("Reimburse", GameNetworkManager.Instance.currentSaveFileName, 0);
				groupCredits = ES3.Load("GroupCredits", GameNetworkManager.Instance.currentSaveFileName, TimeOfDay.Instance.quotaVariables.startingCredits) + num;
			}
			Debug.Log($"Group credits: {groupCredits}");
			if (ES3.KeyExists("EnemyScans", GameNetworkManager.Instance.currentSaveFileName))
			{
				scannedEnemyIDs = ES3.Load<int[]>("EnemyScans", GameNetworkManager.Instance.currentSaveFileName).ToList();
			}
			if (ES3.KeyExists("StoryLogs", GameNetworkManager.Instance.currentSaveFileName))
			{
				unlockedStoryLogs = ES3.Load<int[]>("StoryLogs", GameNetworkManager.Instance.currentSaveFileName).ToList();
			}
			else
			{
				unlockedStoryLogs.Add(0);
			}
			if (num > 0)
			{
				StartCoroutine(displayReimbursedTipDelay());
			}
		}
		StartCoroutine(waitUntilFrameEndToSetActive(active: false));
	}

	private IEnumerator waitUntilFrameEndToSetActive(bool active)
	{
		yield return new WaitForEndOfFrame();
		terminalUIScreen.gameObject.SetActive(active);
	}

	private IEnumerator displayReimbursedTipDelay()
	{
		yield return new WaitForSeconds(3.5f);
		QuickMenuManager quickMenu = UnityEngine.Object.FindObjectOfType<QuickMenuManager>();
		yield return new WaitUntil(() => !quickMenu.isMenuOpen);
		HUDManager.Instance.DisplayTip("Welcome back!", "You have been reimbursed for your previously bought tools. If you want them back, you will have to buy them.", isWarning: false, useSave: true, "LCTip_Reimbursed");
	}

	[ServerRpc(RequireOwnership = false)]
	public void SyncTerminalValuesServerRpc()
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if (__rpc_exec_stage != __RpcExecStage.Server && (networkManager.IsClient || networkManager.IsHost))
		{
			ServerRpcParams serverRpcParams = default(ServerRpcParams);
			FastBufferWriter bufferWriter = __beginSendServerRpc(1261428289u, serverRpcParams, RpcDelivery.Reliable);
			__endSendServerRpc(ref bufferWriter, 1261428289u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
		{
			if (scannedEnemyIDs.Count > 0)
			{
				SyncTerminalValuesClientRpc(groupCredits, numberOfItemsInDropship, scannedEnemyIDs.ToArray(), unlockedStoryLogs.ToArray());
			}
			else
			{
				SyncTerminalValuesClientRpc(groupCredits, numberOfItemsInDropship);
			}
		}
	}

	[ClientRpc]
	public void SyncTerminalValuesClientRpc(int newGroupCredits = 0, int numItemsInDropship = 0, int[] scannedEnemies = null, int[] storyLogs = null)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if (__rpc_exec_stage != __RpcExecStage.Client && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams clientRpcParams = default(ClientRpcParams);
			FastBufferWriter bufferWriter = __beginSendClientRpc(1148560877u, clientRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, newGroupCredits);
			BytePacker.WriteValueBitPacked(bufferWriter, numItemsInDropship);
			bool value = scannedEnemies != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(scannedEnemies, default(FastBufferWriter.ForPrimitives));
			}
			bool value2 = storyLogs != null;
			bufferWriter.WriteValueSafe(in value2, default(FastBufferWriter.ForPrimitives));
			if (value2)
			{
				bufferWriter.WriteValueSafe(storyLogs, default(FastBufferWriter.ForPrimitives));
			}
			__endSendClientRpc(ref bufferWriter, 1148560877u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost) || syncedTerminalValues)
		{
			return;
		}
		syncedTerminalValues = true;
		numberOfItemsInDropship = numItemsInDropship;
		groupCredits = newGroupCredits;
		if (base.IsServer)
		{
			return;
		}
		if (scannedEnemies != null)
		{
			for (int i = 0; i < scannedEnemies.Length; i++)
			{
				scannedEnemyIDs.Add(scannedEnemies[i]);
				Debug.Log("Syncing scanned enemies list with clients");
			}
		}
		if (storyLogs != null)
		{
			for (int j = 0; j < storyLogs.Length; j++)
			{
				unlockedStoryLogs.Add(storyLogs[j]);
			}
		}
	}

	public void BeginUsingTerminal()
	{
		terminalInUse = true;
		try
		{
			StartCoroutine(waitUntilFrameEndToSetActive(active: true));
			GameNetworkManager.Instance.localPlayerController.inTerminalMenu = true;
			Debug.Log($"Set interminalmenu to true: {GameNetworkManager.Instance.localPlayerController.inTerminalMenu}");
			if (selectTextFieldCoroutine != null)
			{
				StopCoroutine(selectTextFieldCoroutine);
			}
			selectTextFieldCoroutine = StartCoroutine(selectTextFieldDelayed());
			HUDManager.Instance.PingHUDElement(HUDManager.Instance.Inventory, 0f, 0.13f, 0.13f);
			HUDManager.Instance.PingHUDElement(HUDManager.Instance.PlayerInfo, 0f, 0.13f, 0.13f);
			HUDManager.Instance.PingHUDElement(HUDManager.Instance.Chat, 0f, 0.35f, 0.13f);
			HUDManager.Instance.PingHUDElement(HUDManager.Instance.Tooltips, 1f, 0f, 0.6f);
			inputFieldText.enableWordWrapping = true;
			if (!ES3.Load("HasUsedTerminal", "LCGeneralSaveData", defaultValue: false))
			{
				LoadNewNode(terminalNodes.specialNodes[0]);
			}
			else if (!usedTerminalThisSession)
			{
				LoadNewNode(terminalNodes.specialNodes[1]);
			}
			else
			{
				LoadNewNode(terminalNodes.specialNodes[13]);
			}
			if (!usedTerminalThisSession)
			{
				usedTerminalThisSession = true;
				if (!syncedTerminalValues)
				{
					SyncTerminalValuesServerRpc();
				}
			}
			SetTerminalInUseLocalClient(inUse: true);
			if (StartOfRound.Instance.localPlayerUsingController && !GameNetworkManager.Instance.disableSteam)
			{
				SteamUtils.ShowGamepadTextInput(GamepadTextInputMode.Normal, GamepadTextInputLineMode.SingleLine, "Type command", currentNode.maxCharactersToType);
				SteamUtils.OnGamepadTextInputDismissed += OnGamepadTextInputDismissed_t;
				displayingSteamKeyboard = true;
			}
			terminalAudio.PlayOneShot(enterTerminalSFX);
			if (StartOfRound.Instance.localPlayerUsingController)
			{
				HUDManager.Instance.ChangeControlTip(0, "Quit terminal : [Start]", clearAllOther: true);
			}
			else
			{
				HUDManager.Instance.ChangeControlTip(0, "Quit terminal : [TAB]", clearAllOther: true);
			}
		}
		catch (Exception arg)
		{
			Debug.Log($"Caught error while entering computer terminal. Exiting player from terminal. Error: {arg}");
			QuitTerminal();
		}
	}

	public void OnGamepadTextInputDismissed_t(bool submitted)
	{
		if (submitted)
		{
			int maxCharactersToType = currentNode.maxCharactersToType;
			string enteredGamepadText = SteamUtils.GetEnteredGamepadText();
			if (string.IsNullOrEmpty(enteredGamepadText) || enteredGamepadText.Length <= maxCharactersToType)
			{
				screenText.text += textAdded;
				OnSubmit();
			}
		}
	}

	private IEnumerator selectTextFieldDelayed()
	{
		screenText.ActivateInputField();
		yield return new WaitForSeconds(1f);
		screenText.Select();
	}

	public void QuitTerminal()
	{
		PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
		terminalTrigger.StopSpecialAnimation();
		terminalInUse = false;
		StartCoroutine(waitUntilFrameEndToSetActive(active: false));
		localPlayerController.inTerminalMenu = false;
		timeSinceTerminalInUse = 0f;
		Debug.Log("Quit terminal; inTerminalMenu true?: {playerScript.inTerminalMenu}");
		if (selectTextFieldCoroutine != null)
		{
			StopCoroutine(selectTextFieldCoroutine);
		}
		screenText.ReleaseSelection();
		screenText.DeactivateInputField();
		if (EventSystem.current != null)
		{
			EventSystem.current.SetSelectedGameObject(null);
		}
		scrollBarVertical.value = 0f;
		HUDManager.Instance.PingHUDElement(HUDManager.Instance.Inventory, 0f, 0.5f, 0.5f);
		HUDManager.Instance.PingHUDElement(HUDManager.Instance.PlayerInfo, 0f, 1f, 1f);
		HUDManager.Instance.PingHUDElement(HUDManager.Instance.Chat, 0f, 1f, 1f);
		HUDManager.Instance.PingHUDElement(HUDManager.Instance.Tooltips, 0f, 1f, 1f);
		if (displayingSteamKeyboard)
		{
			SteamUtils.OnGamepadTextInputDismissed -= OnGamepadTextInputDismissed_t;
		}
		if (localPlayerController.isHoldingObject && localPlayerController.currentlyHeldObjectServer != null)
		{
			localPlayerController.currentlyHeldObjectServer.SetControlTipsForItem();
		}
		else
		{
			HUDManager.Instance.ClearControlTips();
		}
		SetTerminalInUseLocalClient(inUse: false);
		terminalAudio.PlayOneShot(leaveTerminalSFX);
	}

	private void OnEnable()
	{
		playerActions.Movement.OpenMenu.performed += PressESC;
	}

	private void OnDisable()
	{
		Debug.Log("Terminal disabled, disabling ESC key listener");
		playerActions.Movement.OpenMenu.performed -= PressESC;
	}

	private void PressESC(InputAction.CallbackContext context)
	{
		if (context.performed && terminalInUse)
		{
			QuitTerminal();
		}
	}

	public void RotateShipDecorSelection()
	{
		System.Random random = new System.Random(StartOfRound.Instance.randomMapSeed + 65);
		ShipDecorSelection.Clear();
		List<TerminalNode> list = new List<TerminalNode>();
		for (int i = 0; i < StartOfRound.Instance.unlockablesList.unlockables.Count; i++)
		{
			if (StartOfRound.Instance.unlockablesList.unlockables[i].shopSelectionNode != null && !StartOfRound.Instance.unlockablesList.unlockables[i].alwaysInStock)
			{
				list.Add(StartOfRound.Instance.unlockablesList.unlockables[i].shopSelectionNode);
			}
		}
		int num = random.Next(4, 6);
		for (int j = 0; j < num; j++)
		{
			if (list.Count <= 0)
			{
				break;
			}
			TerminalNode item = list[random.Next(0, list.Count)];
			ShipDecorSelection.Add(item);
			list.Remove(item);
		}
	}

	private void InitializeItemSalesPercentages()
	{
		itemSalesPercentages = new int[buyableItemsList.Length];
		for (int i = 0; i < itemSalesPercentages.Length; i++)
		{
			Debug.Log($"Item sales percentages #{i}: {itemSalesPercentages[i]}");
			itemSalesPercentages[i] = 100;
		}
	}

	public void SetItemSales()
	{
		if (itemSalesPercentages == null || itemSalesPercentages.Length == 0)
		{
			InitializeItemSalesPercentages();
		}
		System.Random random = new System.Random(StartOfRound.Instance.randomMapSeed + 90);
		int num = Mathf.Clamp(random.Next(-10, 5), 0, 5);
		if (num <= 0)
		{
			return;
		}
		List<int> list = new List<int>();
		for (int i = 0; i < buyableItemsList.Length; i++)
		{
			list.Add(i);
			itemSalesPercentages[i] = 100;
		}
		for (int j = 0; j < num; j++)
		{
			if (list.Count <= 0)
			{
				break;
			}
			int num2 = random.Next(0, list.Count);
			int maxValue = Mathf.Clamp(buyableItemsList[num2].highestSalePercentage, 0, 90);
			int i2 = 100 - random.Next(0, maxValue);
			i2 = RoundToNearestTen(i2);
			itemSalesPercentages[num2] = i2;
			list.RemoveAt(num2);
		}
	}

	private int RoundToNearestTen(int i)
	{
		return (int)Math.Round((double)i / 10.0) * 10;
	}

	public void SetTerminalInUseLocalClient(bool inUse)
	{
		SetTerminalInUseServerRpc(inUse);
	}

	[ServerRpc(RequireOwnership = false)]
	public void SetTerminalInUseServerRpc(bool inUse)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			if (__rpc_exec_stage != __RpcExecStage.Server && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams serverRpcParams = default(ServerRpcParams);
				FastBufferWriter bufferWriter = __beginSendServerRpc(4047492032u, serverRpcParams, RpcDelivery.Reliable);
				bufferWriter.WriteValueSafe(in inUse, default(FastBufferWriter.ForPrimitives));
				__endSendServerRpc(ref bufferWriter, 4047492032u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				SetTerminalInUseClientRpc(inUse);
			}
		}
	}

	[ClientRpc]
	public void SetTerminalInUseClientRpc(bool inUse)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			if (__rpc_exec_stage != __RpcExecStage.Client && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams clientRpcParams = default(ClientRpcParams);
				FastBufferWriter bufferWriter = __beginSendClientRpc(2420057819u, clientRpcParams, RpcDelivery.Reliable);
				bufferWriter.WriteValueSafe(in inUse, default(FastBufferWriter.ForPrimitives));
				__endSendClientRpc(ref bufferWriter, 2420057819u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				placeableObject.inUse = inUse;
				terminalLight.enabled = inUse;
			}
		}
	}

	public void SetTerminalNoLongerInUse()
	{
		placeableObject.inUse = false;
		terminalLight.enabled = false;
	}

	protected override void __initializeVariables()
	{
		base.__initializeVariables();
	}

	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeRPCS_Terminal()
	{
		NetworkManager.__rpc_func_table.Add(1713627637u, __rpc_handler_1713627637);
		NetworkManager.__rpc_func_table.Add(1118892272u, __rpc_handler_1118892272);
		NetworkManager.__rpc_func_table.Add(4003509079u, __rpc_handler_4003509079);
		NetworkManager.__rpc_func_table.Add(3085407145u, __rpc_handler_3085407145);
		NetworkManager.__rpc_func_table.Add(2039928764u, __rpc_handler_2039928764);
		NetworkManager.__rpc_func_table.Add(1261428289u, __rpc_handler_1261428289);
		NetworkManager.__rpc_func_table.Add(1148560877u, __rpc_handler_1148560877);
		NetworkManager.__rpc_func_table.Add(4047492032u, __rpc_handler_4047492032);
		NetworkManager.__rpc_func_table.Add(2420057819u, __rpc_handler_2420057819);
	}

	private static void __rpc_handler_1713627637(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			ByteUnpacker.ReadValueBitPacked(reader, out int value);
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((Terminal)target).PlayTerminalAudioServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1118892272(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			ByteUnpacker.ReadValueBitPacked(reader, out int value);
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((Terminal)target).PlayTerminalAudioClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_4003509079(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			int[] value2 = null;
			if (value)
			{
				reader.ReadValueSafe(out value2, default(FastBufferWriter.ForPrimitives));
			}
			ByteUnpacker.ReadValueBitPacked(reader, out int value3);
			ByteUnpacker.ReadValueBitPacked(reader, out int value4);
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((Terminal)target).BuyItemsServerRpc(value2, value3, value4);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_3085407145(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
		{
			if (networkManager.LogLevel <= LogLevel.Normal)
			{
				Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
			}
		}
		else
		{
			ByteUnpacker.ReadValueBitPacked(reader, out int value);
			ByteUnpacker.ReadValueBitPacked(reader, out int value2);
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((Terminal)target).SyncGroupCreditsServerRpc(value, value2);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_2039928764(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			ByteUnpacker.ReadValueBitPacked(reader, out int value);
			ByteUnpacker.ReadValueBitPacked(reader, out int value2);
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((Terminal)target).SyncGroupCreditsClientRpc(value, value2);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1261428289(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((Terminal)target).SyncTerminalValuesServerRpc();
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1148560877(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			ByteUnpacker.ReadValueBitPacked(reader, out int value);
			ByteUnpacker.ReadValueBitPacked(reader, out int value2);
			reader.ReadValueSafe(out bool value3, default(FastBufferWriter.ForPrimitives));
			int[] value4 = null;
			if (value3)
			{
				reader.ReadValueSafe(out value4, default(FastBufferWriter.ForPrimitives));
			}
			reader.ReadValueSafe(out bool value5, default(FastBufferWriter.ForPrimitives));
			int[] value6 = null;
			if (value5)
			{
				reader.ReadValueSafe(out value6, default(FastBufferWriter.ForPrimitives));
			}
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((Terminal)target).SyncTerminalValuesClientRpc(value, value2, value4, value6);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_4047492032(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((Terminal)target).SetTerminalInUseServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_2420057819(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((Terminal)target).SetTerminalInUseClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	protected internal override string __getTypeName()
	{
		return "Terminal";
	}
}