using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Dissonance;
using GameNetcodeStuff;
using Steamworks;
using Steamworks.Data;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.UI;

public class HUDManager : NetworkBehaviour
{
	public HUDElement Inventory;

	public HUDElement Chat;

	public HUDElement PlayerInfo;

	public HUDElement Tooltips;

	public HUDElement InstabilityCounter;

	public HUDElement Clock;

	private HUDElement[] HUDElements;

	public GameObject HUDContainer;

	public Animator playerScreenShakeAnimator;

	public RawImage playerScreenTexture;

	public Volume playerGraphicsVolume;

	public TextMeshProUGUI weightCounter;

	public Animator weightCounterAnimator;

	[Header("Item UI")]
	public UnityEngine.UI.Image[] itemSlotIcons;

	public UnityEngine.UI.Image[] itemSlotIconFrames;

	[Header("Tooltips")]
	public TextMeshProUGUI[] controlTipLines;

	[Header("Object Scanner")]
	private RaycastHit[] scanNodesHit;

	public RectTransform[] scanElements;

	private bool scanElementsHidden;

	private float playerPingingScan;

	private float updateScanInterval;

	private Dictionary<RectTransform, ScanNodeProperties> scanNodes = new Dictionary<RectTransform, ScanNodeProperties>();

	private List<ScanNodeProperties> nodesOnScreen = new List<ScanNodeProperties>();

	private TextMeshProUGUI[] scanElementText = new TextMeshProUGUI[2];

	public Animator scanEffectAnimator;

	public AudioClip scanSFX;

	public AudioClip addToScrapTotalSFX;

	public AudioClip finishAddingToTotalSFX;

	private float addToDisplayTotalInterval;

	private bool addingToDisplayTotal;

	[Space(3f)]
	public TextMeshProUGUI totalValueText;

	public Animator scanInfoAnimator;

	public int totalScrapScanned;

	private int totalScrapScannedDisplayNum;

	private int scannedScrapNum;

	private bool addedToScrapCounterThisFrame;

	[Header("Batteries")]
	public UnityEngine.UI.Image batteryIcon;

	public TextMeshProUGUI batteryInventoryNumber;

	public UnityEngine.UI.Image batteryMeter;

	[Header("Audio")]
	public AudioSource UIAudio;

	public AudioClip criticalInjury;

	public AudioLowPassFilter audioListenerLowPass;

	public AudioClip globalNotificationSFX;

	[Header("Misc UI elements")]
	public GameObject errorLogPanel;

	public TextMeshProUGUI errorLogText;

	private string previousErrorReceived;

	public UnityEngine.UI.Image PTTIcon;

	public Animator batteryBlinkUI;

	public TextMeshProUGUI holdingTwoHandedItem;

	public CanvasGroup selfRedCanvasGroup;

	public UnityEngine.UI.Image holdInteractionFillAmount;

	public CanvasGroup holdInteractionCanvasGroup;

	public float holdFillAmount;

	public EndOfGameStatUIElements statsUIElements;

	public Animator gameOverAnimator;

	public Animator quotaAnimator;

	public TextMeshProUGUI HUDQuotaNumerator;

	public TextMeshProUGUI HUDQuotaDenominator;

	public Animator planetIntroAnimator;

	public Animator endgameStatsAnimator;

	public TextMeshProUGUI loadingText;

	public UnityEngine.UI.Image loadingDarkenScreen;

	public TextMeshProUGUI planetInfoSummaryText;

	public TextMeshProUGUI planetInfoHeaderText;

	public TextMeshProUGUI planetRiskLevelText;

	[Header("Text chat")]
	public TextMeshProUGUI chatText;

	public TextMeshProUGUI typingIndicator;

	public TMP_InputField chatTextField;

	public string lastChatMessage = "";

	public List<string> ChatMessageHistory = new List<string>();

	public Animator playerCouldRecieveTextChatAnimator;

	public StartOfRound playersManager;

	public PlayerActions playerActions;

	public PlayerControllerB localPlayer;

	private bool playerIsCriticallyInjured;

	public TextMeshProUGUI instabilityCounterNumber;

	public TextMeshProUGUI instabilityCounterText;

	private int previousInstability;

	private Terminal terminalScript;

	[Header("Special Graphics")]
	public Animator alarmHornEffect;

	public AudioClip shipAlarmHornSFX;

	public Animator deviceChangeAnimator;

	public TextMeshProUGUI deviceChangeText;

	public Animator saveDataIconAnimatorB;

	public Animator HUDAnimator;

	public Animator radiationGraphicAnimator;

	public AudioClip radiationWarningAudio;

	public UnityEngine.UI.Image shipLeavingEarlyIcon;

	private float timeSinceDisplayingStatusEffect;

	public Animator statusEffectAnimator;

	public TextMeshProUGUI statusEffectText;

	[Space(3f)]
	public bool increaseHelmetCondensation;

	public Material helmetCondensationMaterial;

	[Space(3f)]
	public Animator moneyRewardsAnimator;

	public TextMeshProUGUI moneyRewardsTotalText;

	public TextMeshProUGUI moneyRewardsListText;

	private Coroutine scrollRewardTextCoroutine;

	public Scrollbar rewardsScrollbar;

	[Space(3f)]
	public CanvasGroup shockTutorialLeftAlpha;

	[Space(3f)]
	public CanvasGroup shockTutorialRightAlpha;

	public int tutorialArrowState;

	public bool setTutorialArrow;

	[Space(3f)]
	public Animator tipsPanelAnimator;

	public TextMeshProUGUI tipsPanelBody;

	public TextMeshProUGUI tipsPanelHeader;

	public AudioClip[] tipsSFX;

	public AudioClip[] warningSFX;

	private Coroutine tipsPanelCoroutine;

	private bool isDisplayingWarning;

	public Animator globalNotificationAnimator;

	public TextMeshProUGUI globalNotificationText;

	public bool sinkingCoveredFace;

	public Animator sinkingUnderAnimator;

	[Header("Dialogue Box")]
	private Coroutine readDialogueCoroutine;

	public TextMeshProUGUI dialogeBoxHeaderText;

	public TextMeshProUGUI dialogeBoxText;

	public Animator dialogueBoxAnimator;

	public AudioSource dialogueBoxSFX;

	public AudioClip[] dialogueBleeps;

	private Coroutine forceChangeTextCoroutine;

	private bool hudHidden;

	[Header("Spectate UI")]
	private bool hasLoadedSpectateUI;

	private bool hasGottenPlayerSteamProfilePictures;

	public GameObject spectatingPlayerBoxPrefab;

	public Transform SpectateBoxesContainer;

	private Dictionary<Animator, PlayerControllerB> spectatingPlayerBoxes = new Dictionary<Animator, PlayerControllerB>();

	private float updateSpectateBoxesInterval;

	private float yOffsetAmount;

	private int boxesAdded;

	public TextMeshProUGUI spectatingPlayerText;

	private bool displayedSpectatorAFKTip;

	public TextMeshProUGUI spectatorTipText;

	public TextMeshProUGUI holdButtonToEndGameEarlyText;

	public TextMeshProUGUI holdButtonToEndGameEarlyVotesText;

	public UnityEngine.UI.Image holdButtonToEndGameEarlyMeter;

	private float holdButtonToEndGameEarlyHoldTime;

	[Header("Time of day UI")]
	public TextMeshProUGUI clockNumber;

	public UnityEngine.UI.Image clockIcon;

	public Sprite[] clockIcons;

	private string amPM;

	private string newLine;

	[Space(5f)]
	public Animator gasHelmetAnimator;

	public Volume drunknessFilter;

	public CanvasGroup gasImageAlpha;

	public Volume insanityScreenFilter;

	public Volume flashbangScreenFilter;

	public Volume underwaterScreenFilter;

	public bool setUnderwaterFilter;

	public AudioSource breathingUnderwaterAudio;

	[Header("Player levelling")]
	public PlayerLevel[] playerLevels;

	public int localPlayerLevel;

	public int localPlayerXP;

	public TextMeshProUGUI playerLevelText;

	public TextMeshProUGUI playerLevelXPCounter;

	public UnityEngine.UI.Image playerLevelMeter;

	public AudioClip levelIncreaseSFX;

	public AudioClip levelDecreaseSFX;

	public AudioClip decreaseXPSFX;

	public AudioClip increaseXPSFX;

	public Animator playerLevelBoxAnimator;

	public AudioSource LevellingAudio;

	[Header("Profit quota/deadline")]
	public Animator reachedProfitQuotaAnimator;

	public TextMeshProUGUI newProfitQuotaText;

	public TextMeshProUGUI reachedProfitQuotaBonusText;

	public TextMeshProUGUI profitQuotaDaysLeftText;

	public TextMeshProUGUI profitQuotaDaysLeftText2;

	public AudioClip newProfitQuotaSFX;

	public AudioClip reachedQuotaSFX;

	public AudioClip OneDayToMeetQuotaSFX;

	public AudioClip profitQuotaDaysLeftCalmSFX;

	[Space(3f)]
	public Animator playersFiredAnimator;

	public TextMeshProUGUI EndOfRunStatsText;

	public bool displayingNewQuota;

	[Header("Displaying collected scrap")]
	public List<GrabbableObject> itemsToBeDisplayed = new List<GrabbableObject>();

	public ScrapItemHUDDisplay[] ScrapItemBoxes;

	private int boxesDisplaying;

	public Coroutine displayingItemCoroutine;

	private int bottomBoxIndex;

	public int bottomBoxYPosition;

	public Material hologramMaterial;

	public AudioClip displayCollectedScrapSFX;

	public AudioClip displayCollectedScrapSFXSmall;

	private int nextBoxIndex;

	[Space(5f)]
	public TextMeshProUGUI buildModeControlTip;

	private bool hasSetSavedValues;

	private float noLivingPlayersAtKeyboardTimer;

	public static HUDManager Instance { get; private set; }

	private void OnEnable()
	{
		playerActions.Movement.EnableChat.performed += EnableChat_performed;
		playerActions.Movement.OpenMenu.performed += OpenMenu_performed;
		playerActions.Movement.SubmitChat.performed += SubmitChat_performed;
		playerActions.Movement.PingScan.performed += PingScan_performed;
		InputSystem.onDeviceChange += OnDeviceChange;
		playerActions.Movement.Enable();
	}

	private void OnDisable()
	{
		playerActions.Movement.EnableChat.performed -= EnableChat_performed;
		playerActions.Movement.OpenMenu.performed -= OpenMenu_performed;
		playerActions.Movement.SubmitChat.performed -= SubmitChat_performed;
		playerActions.Movement.PingScan.performed -= PingScan_performed;
		InputSystem.onDeviceChange -= OnDeviceChange;
		playerActions.Movement.Disable();
	}

	private void Awake()
	{
		if (Instance == null)
		{
			Instance = this;
			playerActions = new PlayerActions();
			playersManager = UnityEngine.Object.FindObjectOfType<StartOfRound>();
			HUDElements = new HUDElement[6] { Inventory, Chat, PlayerInfo, Tooltips, InstabilityCounter, Clock };
			scanNodesHit = new RaycastHit[13];
			StartCoroutine(waitUntilLocalPlayerControllerInitialized());
		}
		else
		{
			if (Instance.gameObject != null)
			{
				UnityEngine.Object.Destroy(Instance.gameObject);
			}
			else
			{
				UnityEngine.Object.Destroy(Instance);
			}
			Instance = this;
		}
	}

	private void Start()
	{
		terminalScript = UnityEngine.Object.FindObjectOfType<Terminal>();
	}

	private void OnDeviceChange(InputDevice device, InputDeviceChange deviceChange)
	{
		bool flag = false;
		switch (deviceChange)
		{
		case InputDeviceChange.Disconnected:
			flag = true;
			deviceChangeText.text = "Controller disconnected";
			break;
		case InputDeviceChange.Reconnected:
			flag = true;
			deviceChangeText.text = "Controller connected";
			break;
		}
		if (flag)
		{
			deviceChangeAnimator.SetTrigger("display");
		}
	}

	public void SetSavedValues(int playerObjectId = -1)
	{
		if (playerObjectId == -1)
		{
			playerObjectId = (int)GameNetworkManager.Instance.localPlayerController.playerClientId;
		}
		if (!hasSetSavedValues)
		{
			hasSetSavedValues = true;
			localPlayerLevel = ES3.Load("PlayerLevel", "LCGeneralSaveData", 0);
			localPlayerXP = ES3.Load("PlayerXPNum", "LCGeneralSaveData", 0);
			bool flag = ES3.Load("playedDuringBeta", "LCGeneralSaveData", defaultValue: true);
			StartOfRound.Instance.allPlayerScripts[playerObjectId].playerBetaBadgeMesh.enabled = flag;
			Debug.Log("Has beta?: {hasBeta}");
			Debug.Log(string.Format("Has beta save data: {0}", ES3.Load("playedDuringBeta", "LCGeneralSaveData", defaultValue: true)));
			if (ES3.Load("FinishedShockMinigame", "LCGeneralSaveData", 0) < 2)
			{
				setTutorialArrow = true;
			}
		}
	}

	private IEnumerator waitUntilLocalPlayerControllerInitialized()
	{
		yield return new WaitUntil(() => GameNetworkManager.Instance.localPlayerController != null);
		SetSavedValues();
	}

	public void SetNearDepthOfFieldEnabled(bool enabled)
	{
		float value = ((!enabled) ? 0.2f : 0.5f);
		if (playerGraphicsVolume.sharedProfile.TryGet<DepthOfField>(out var component))
		{
			component.nearFocusEnd.SetValue(new MinFloatParameter(value, 0f, overrideState: true));
		}
	}

	public void UpdateHealthUI(int health, bool hurtPlayer = true)
	{
		if (health < 100)
		{
			selfRedCanvasGroup.alpha = (float)(100 - health) / 100f;
			if (health >= 20 && playerIsCriticallyInjured)
			{
				playerIsCriticallyInjured = false;
				HUDAnimator.SetTrigger("HealFromCritical");
			}
		}
		else
		{
			selfRedCanvasGroup.alpha = 0f;
		}
		if (hurtPlayer && health > 0)
		{
			if (health < 20)
			{
				playerIsCriticallyInjured = true;
				HUDAnimator.SetTrigger("CriticalHit");
				UIAudio.PlayOneShot(criticalInjury, 1f);
			}
			else
			{
				HUDAnimator.SetTrigger("SmallHit");
			}
		}
	}

	private void AddChatMessage(string chatMessage, string nameOfUserWhoTyped = "")
	{
		if (!(lastChatMessage == chatMessage))
		{
			lastChatMessage = chatMessage;
			PingHUDElement(Chat, 4f);
			if (ChatMessageHistory.Count >= 4)
			{
				chatText.text.Remove(0, ChatMessageHistory[0].Length);
				ChatMessageHistory.Remove(ChatMessageHistory[0]);
			}
			StringBuilder stringBuilder = new StringBuilder(chatMessage);
			stringBuilder.Replace("[playerNum0]", StartOfRound.Instance.allPlayerScripts[0].playerUsername);
			stringBuilder.Replace("[playerNum1]", StartOfRound.Instance.allPlayerScripts[1].playerUsername);
			stringBuilder.Replace("[playerNum2]", StartOfRound.Instance.allPlayerScripts[2].playerUsername);
			stringBuilder.Replace("[playerNum3]", StartOfRound.Instance.allPlayerScripts[3].playerUsername);
			chatMessage = stringBuilder.ToString();
			string item = ((!string.IsNullOrEmpty(nameOfUserWhoTyped)) ? ("<color=#FF0000>" + nameOfUserWhoTyped + "</color>: <color=#FFFF00>'" + chatMessage + "'</color>") : ("<color=#7069ff>" + chatMessage + "</color>"));
			ChatMessageHistory.Add(item);
			chatText.text = "";
			for (int i = 0; i < ChatMessageHistory.Count; i++)
			{
				TextMeshProUGUI textMeshProUGUI = chatText;
				textMeshProUGUI.text = textMeshProUGUI.text + "\n" + ChatMessageHistory[i];
			}
		}
	}

	public void AddTextToChatOnServer(string chatMessage, int playerId = -1)
	{
		if (playerId != -1)
		{
			AddChatMessage(chatMessage, playersManager.allPlayerScripts[playerId].playerUsername);
			AddPlayerChatMessageServerRpc(chatMessage, playerId);
		}
		else
		{
			AddChatMessage(chatMessage);
			AddTextMessageServerRpc(chatMessage);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void AddPlayerChatMessageServerRpc(string chatMessage, int playerId)
	{
		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(2930587515u, serverRpcParams, RpcDelivery.Reliable);
			bool value = chatMessage != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(chatMessage);
			}
			BytePacker.WriteValueBitPacked(bufferWriter, playerId);
			__endSendServerRpc(ref bufferWriter, 2930587515u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost) && chatMessage.Length <= 50)
		{
			AddPlayerChatMessageClientRpc(chatMessage, playerId);
		}
	}

	[ClientRpc]
	private void AddPlayerChatMessageClientRpc(string chatMessage, int playerId)
	{
		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(168728662u, clientRpcParams, RpcDelivery.Reliable);
			bool value = chatMessage != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(chatMessage);
			}
			BytePacker.WriteValueBitPacked(bufferWriter, playerId);
			__endSendClientRpc(ref bufferWriter, 168728662u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && playersManager.allPlayerScripts[playerId].isPlayerDead == GameNetworkManager.Instance.localPlayerController.isPlayerDead)
		{
			bool flag = GameNetworkManager.Instance.localPlayerController.holdingWalkieTalkie && StartOfRound.Instance.allPlayerScripts[playerId].holdingWalkieTalkie;
			if (!(Vector3.Distance(GameNetworkManager.Instance.localPlayerController.transform.position, playersManager.allPlayerScripts[playerId].transform.position) > 25f || flag))
			{
				AddChatMessage(chatMessage, playersManager.allPlayerScripts[playerId].playerUsername);
			}
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void AddTextMessageServerRpc(string chatMessage)
	{
		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(2787681914u, serverRpcParams, RpcDelivery.Reliable);
			bool value = chatMessage != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(chatMessage);
			}
			__endSendServerRpc(ref bufferWriter, 2787681914u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
		{
			AddTextMessageClientRpc(chatMessage);
		}
	}

	[ClientRpc]
	private void AddTextMessageClientRpc(string chatMessage)
	{
		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(1568596901u, clientRpcParams, RpcDelivery.Reliable);
			bool value = chatMessage != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(chatMessage);
			}
			__endSendClientRpc(ref bufferWriter, 1568596901u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
		{
			AddChatMessage(chatMessage);
		}
	}

	private void SubmitChat_performed(InputAction.CallbackContext context)
	{
		localPlayer = GameNetworkManager.Instance.localPlayerController;
		if (!context.performed || localPlayer == null || !localPlayer.isTypingChat || ((!localPlayer.IsOwner || (base.IsServer && !localPlayer.isHostPlayerObject)) && !localPlayer.isTestingPlayer) || localPlayer.isPlayerDead)
		{
			return;
		}
		if (!string.IsNullOrEmpty(chatTextField.text) && chatTextField.text.Length < 50)
		{
			AddTextToChatOnServer(chatTextField.text, (int)localPlayer.playerClientId);
		}
		for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
		{
			if (StartOfRound.Instance.allPlayerScripts[i].isPlayerControlled && Vector3.Distance(GameNetworkManager.Instance.localPlayerController.transform.position, StartOfRound.Instance.allPlayerScripts[i].transform.position) > 24.4f)
			{
				playerCouldRecieveTextChatAnimator.SetTrigger("ping");
				break;
			}
		}
		localPlayer.isTypingChat = false;
		chatTextField.text = "";
		EventSystem.current.SetSelectedGameObject(null);
		PingHUDElement(Chat);
		typingIndicator.enabled = false;
	}

	private void EnableChat_performed(InputAction.CallbackContext context)
	{
		localPlayer = GameNetworkManager.Instance.localPlayerController;
		if (context.performed && !(localPlayer == null) && ((localPlayer.IsOwner && (!base.IsServer || localPlayer.isHostPlayerObject)) || localPlayer.isTestingPlayer) && !localPlayer.isPlayerDead && !localPlayer.inTerminalMenu)
		{
			ShipBuildModeManager.Instance.CancelBuildMode();
			localPlayer.isTypingChat = true;
			chatTextField.Select();
			PingHUDElement(Chat, 0.1f, 1f, 1f);
			typingIndicator.enabled = true;
		}
	}

	private void OpenMenu_performed(InputAction.CallbackContext context)
	{
		localPlayer = GameNetworkManager.Instance.localPlayerController;
		if (!(localPlayer == null) && localPlayer.isTypingChat && context.performed && ((localPlayer.IsOwner && (!base.IsServer || localPlayer.isHostPlayerObject)) || localPlayer.isTestingPlayer))
		{
			localPlayer.isTypingChat = false;
			EventSystem.current.SetSelectedGameObject(null);
			chatTextField.text = "";
			PingHUDElement(Chat, 1f);
			typingIndicator.enabled = false;
		}
	}

	private void PingScan_performed(InputAction.CallbackContext context)
	{
		if (!(GameNetworkManager.Instance.localPlayerController == null) && context.performed && CanPlayerScan() && playerPingingScan <= -1f)
		{
			playerPingingScan = 0.3f;
			scanEffectAnimator.transform.position = GameNetworkManager.Instance.localPlayerController.gameplayCamera.transform.position;
			scanEffectAnimator.SetTrigger("scan");
			UIAudio.PlayOneShot(scanSFX);
		}
	}

	private bool CanPlayerScan()
	{
		if (!GameNetworkManager.Instance.localPlayerController.inSpecialInteractAnimation)
		{
			return !GameNetworkManager.Instance.localPlayerController.isPlayerDead;
		}
		return false;
	}

	public void UpdateBoxesSpectateUI()
	{
		PlayerControllerB playerScript;
		for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
		{
			playerScript = StartOfRound.Instance.allPlayerScripts[i];
			if (!playerScript.isPlayerDead)
			{
				if (playerScript.isPlayerControlled || !spectatingPlayerBoxes.Values.Contains(playerScript))
				{
					continue;
				}
				Debug.Log("Removing player spectate box since they disconnected");
				Animator key = spectatingPlayerBoxes.FirstOrDefault((KeyValuePair<Animator, PlayerControllerB> x) => x.Value == playerScript).Key;
				if (key.gameObject.activeSelf)
				{
					for (int j = 0; j < spectatingPlayerBoxes.Count; j++)
					{
						RectTransform component = spectatingPlayerBoxes.ElementAt(j).Key.gameObject.GetComponent<RectTransform>();
						if (component.anchoredPosition.y <= -70f * (float)boxesAdded + 1f)
						{
							component.anchoredPosition = new Vector2(component.anchoredPosition.x, component.anchoredPosition.y + 70f);
						}
					}
					yOffsetAmount += 70f;
				}
				spectatingPlayerBoxes.Remove(key);
				UnityEngine.Object.Destroy(key.gameObject);
			}
			else if (spectatingPlayerBoxes.Values.Contains(playerScript))
			{
				GameObject gameObject = spectatingPlayerBoxes.FirstOrDefault((KeyValuePair<Animator, PlayerControllerB> x) => x.Value == playerScript).Key.gameObject;
				if (!gameObject.activeSelf)
				{
					RectTransform component2 = gameObject.GetComponent<RectTransform>();
					component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, yOffsetAmount);
					boxesAdded++;
					gameObject.SetActive(value: true);
					yOffsetAmount -= 70f;
				}
			}
			else
			{
				GameObject gameObject = UnityEngine.Object.Instantiate(spectatingPlayerBoxPrefab, SpectateBoxesContainer, worldPositionStays: false);
				gameObject.SetActive(value: true);
				RectTransform component3 = gameObject.GetComponent<RectTransform>();
				component3.anchoredPosition = new Vector2(component3.anchoredPosition.x, yOffsetAmount);
				yOffsetAmount -= 70f;
				boxesAdded++;
				spectatingPlayerBoxes.Add(gameObject.GetComponent<Animator>(), playerScript);
				gameObject.GetComponentInChildren<TextMeshProUGUI>().text = playerScript.playerUsername;
				if (!GameNetworkManager.Instance.disableSteam)
				{
					RawImage component4 = gameObject.GetComponent<RawImage>();
					FillSpectateBoxImageWithSteamProfile(component4, playerScript);
				}
			}
		}
	}

	private async void FillSpectateBoxImageWithSteamProfile(RawImage image, PlayerControllerB player)
	{
		if (SteamClient.IsValid)
		{
			image.texture = GetTextureFromImage(await SteamFriends.GetLargeAvatarAsync(player.playerSteamId));
		}
	}

	public static Texture2D GetTextureFromImage(Steamworks.Data.Image? image)
	{
		Texture2D texture2D = new Texture2D((int)image.Value.Width, (int)image.Value.Height);
		for (int i = 0; i < image.Value.Width; i++)
		{
			for (int j = 0; j < image.Value.Height; j++)
			{
				Steamworks.Data.Color pixel = image.Value.GetPixel(i, j);
				texture2D.SetPixel(i, (int)image.Value.Height - j, new UnityEngine.Color((float)(int)pixel.r / 255f, (float)(int)pixel.g / 255f, (float)(int)pixel.b / 255f, (float)(int)pixel.a / 255f));
			}
		}
		texture2D.Apply();
		return texture2D;
	}

	public void RemoveSpectateUI()
	{
		for (int i = 0; i < spectatingPlayerBoxes.Count; i++)
		{
			spectatingPlayerBoxes.ElementAt(i).Key.gameObject.SetActive(value: false);
			boxesAdded--;
		}
		yOffsetAmount = 0f;
		hasGottenPlayerSteamProfilePictures = false;
		hasLoadedSpectateUI = false;
	}

	private void UpdateSpectateBoxSpeakerIcons()
	{
		if (StartOfRound.Instance.voiceChatModule == null)
		{
			return;
		}
		bool flag = false;
		for (int i = 0; i < spectatingPlayerBoxes.Count; i++)
		{
			PlayerControllerB value = spectatingPlayerBoxes.ElementAt(i).Value;
			if (!value.isPlayerControlled && !value.isPlayerDead)
			{
				continue;
			}
			if (value == GameNetworkManager.Instance.localPlayerController)
			{
				if (!string.IsNullOrEmpty(StartOfRound.Instance.voiceChatModule.LocalPlayerName))
				{
					VoicePlayerState voicePlayerState = StartOfRound.Instance.voiceChatModule.FindPlayer(StartOfRound.Instance.voiceChatModule.LocalPlayerName);
					if (voicePlayerState != null)
					{
						spectatingPlayerBoxes.ElementAt(i).Key.SetBool("speaking", voicePlayerState.IsSpeaking && voicePlayerState.Amplitude > 0.005f);
					}
				}
			}
			else if (value.voicePlayerState == null)
			{
				if (!flag)
				{
					flag = true;
					StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
				}
			}
			else
			{
				VoicePlayerState voicePlayerState = value.voicePlayerState;
				spectatingPlayerBoxes.ElementAt(i).Key.SetBool("speaking", voicePlayerState.IsSpeaking && voicePlayerState.Amplitude > 0.005f && !voicePlayerState.IsLocallyMuted);
			}
		}
	}

	public void SetSpectatingTextToPlayer(PlayerControllerB playerScript)
	{
		if (playerScript == null)
		{
			spectatingPlayerText.text = "";
		}
		else
		{
			spectatingPlayerText.text = "(Spectating: " + playerScript.playerUsername + ")";
		}
	}

	private void DisplayScrapItemsOnHud()
	{
		if (boxesDisplaying < ScrapItemBoxes.Length && itemsToBeDisplayed.Count > 0)
		{
			DisplayNewScrapFound();
		}
		if (boxesDisplaying <= 0 || !(ScrapItemBoxes[bottomBoxIndex].UIContainer.anchoredPosition.y < (float)bottomBoxYPosition))
		{
			return;
		}
		for (int i = 0; i < ScrapItemBoxes.Length; i++)
		{
			ScrapItemBoxes[i].UIContainer.anchoredPosition += Vector2.up * (Time.deltaTime * 325f);
		}
		if (ScrapItemBoxes[bottomBoxIndex].UIContainer.anchoredPosition.y > (float)bottomBoxYPosition)
		{
			float num = ScrapItemBoxes[bottomBoxIndex].UIContainer.anchoredPosition.y - (float)bottomBoxYPosition;
			num -= 0.01f;
			for (int j = 0; j < ScrapItemBoxes.Length; j++)
			{
				ScrapItemBoxes[j].UIContainer.anchoredPosition -= Vector2.up * num;
			}
		}
	}

	private void SetScreenFilters()
	{
		UnderwaterScreenFilters();
		drunknessFilter.weight = Mathf.Lerp(drunknessFilter.weight, StartOfRound.Instance.drunknessSideEffect.Evaluate(GameNetworkManager.Instance.localPlayerController.drunkness), 5f * Time.deltaTime);
		gasImageAlpha.alpha = drunknessFilter.weight * 1.5f;
		if (StartOfRound.Instance.fearLevel > 0.4f)
		{
			insanityScreenFilter.weight = Mathf.Lerp(insanityScreenFilter.weight, StartOfRound.Instance.fearLevel, 5f * Time.deltaTime);
		}
		else
		{
			insanityScreenFilter.weight = Mathf.Lerp(insanityScreenFilter.weight, 0f, 2f * Time.deltaTime);
		}
		sinkingUnderAnimator.SetBool("cover", sinkingCoveredFace);
		if (flashbangScreenFilter.weight > 0f)
		{
			flashbangScreenFilter.weight -= Time.deltaTime * 0.16f;
		}
		HelmetCondensationDrops();
	}

	private void HelmetCondensationDrops()
	{
		if (!increaseHelmetCondensation)
		{
			if (helmetCondensationMaterial.color.a > 0f)
			{
				UnityEngine.Color color = helmetCondensationMaterial.color;
				color.a = Mathf.Clamp(color.a - Time.deltaTime / 2f, 0f, 0.27f);
				helmetCondensationMaterial.color = color;
			}
		}
		else
		{
			if (helmetCondensationMaterial.color.a < 1f)
			{
				UnityEngine.Color color2 = helmetCondensationMaterial.color;
				color2.a = Mathf.Clamp(color2.a + Time.deltaTime / 2f, 0f, 0.27f);
				helmetCondensationMaterial.color = color2;
			}
			increaseHelmetCondensation = false;
		}
		if ((TimeOfDay.Instance.effects[1].effectEnabled || TimeOfDay.Instance.effects[2].effectEnabled) && !TimeOfDay.Instance.insideLighting && Vector3.Angle(GameNetworkManager.Instance.localPlayerController.gameplayCamera.transform.forward, Vector3.up) < 45f)
		{
			increaseHelmetCondensation = true;
		}
	}

	private void UnderwaterScreenFilters()
	{
		bool flag = false;
		if (GameNetworkManager.Instance.localPlayerController.isPlayerDead && GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript != null)
		{
			PlayerControllerB spectatedPlayerScript = GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript;
			if (spectatedPlayerScript.underwaterCollider != null && spectatedPlayerScript.underwaterCollider.bounds.Contains(StartOfRound.Instance.spectateCamera.transform.position))
			{
				flag = true;
			}
		}
		if (setUnderwaterFilter || flag)
		{
			audioListenerLowPass.enabled = true;
			audioListenerLowPass.cutoffFrequency = Mathf.Lerp(audioListenerLowPass.cutoffFrequency, 700f, 10f * Time.deltaTime);
			underwaterScreenFilter.weight = 1f;
			breathingUnderwaterAudio.volume = Mathf.Lerp(breathingUnderwaterAudio.volume, 1f, 10f * Time.deltaTime);
			if (!flag && !breathingUnderwaterAudio.isPlaying)
			{
				breathingUnderwaterAudio.Play();
			}
			return;
		}
		if (audioListenerLowPass.cutoffFrequency >= 19000f)
		{
			audioListenerLowPass.enabled = false;
		}
		else
		{
			audioListenerLowPass.cutoffFrequency = Mathf.Lerp(audioListenerLowPass.cutoffFrequency, 20000f, 10f * Time.deltaTime);
		}
		if (underwaterScreenFilter.weight < 0.05f)
		{
			underwaterScreenFilter.weight = 0f;
			breathingUnderwaterAudio.Stop();
		}
		else
		{
			breathingUnderwaterAudio.volume = Mathf.Lerp(breathingUnderwaterAudio.volume, 0f, 10f * Time.deltaTime);
			underwaterScreenFilter.weight = Mathf.Lerp(underwaterScreenFilter.weight, 0f, 10f * Time.deltaTime);
		}
	}

	private void Update()
	{
		if (GameNetworkManager.Instance == null || GameNetworkManager.Instance.localPlayerController == null || GameNetworkManager.Instance.localPlayerController == null)
		{
			return;
		}
		DisplayScrapItemsOnHud();
		SetScreenFilters();
		if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
		{
			if (!hasLoadedSpectateUI)
			{
				hasLoadedSpectateUI = true;
				Debug.Log("Adding boxes");
				UpdateBoxesSpectateUI();
			}
			if (StartOfRound.Instance.shipIsLeaving || !StartOfRound.Instance.currentLevel.planetHasTime)
			{
				holdButtonToEndGameEarlyHoldTime = 0f;
				holdButtonToEndGameEarlyMeter.gameObject.SetActive(value: false);
				holdButtonToEndGameEarlyText.text = "";
				holdButtonToEndGameEarlyVotesText.text = "";
			}
			else if (!TimeOfDay.Instance.shipLeavingAlertCalled)
			{
				holdButtonToEndGameEarlyText.enabled = true;
				if (!TimeOfDay.Instance.votedShipToLeaveEarlyThisRound)
				{
					DisplaySpectatorVoteTip();
					if (StartOfRound.Instance.localPlayerUsingController)
					{
						holdButtonToEndGameEarlyText.text = "Tell autopilot ship to leave early : [R-trigger] (Hold)";
					}
					else
					{
						holdButtonToEndGameEarlyText.text = "Tell autopilot ship to leave early : [RMB] (Hold)";
					}
					if (playerActions.Movement.PingScan.IsPressed())
					{
						holdButtonToEndGameEarlyHoldTime += Time.deltaTime;
						holdButtonToEndGameEarlyMeter.gameObject.SetActive(value: true);
						if (holdButtonToEndGameEarlyHoldTime > 3f)
						{
							TimeOfDay.Instance.VoteShipToLeaveEarly();
							holdButtonToEndGameEarlyText.text = "Voted for ship to leave early";
						}
					}
					else
					{
						holdButtonToEndGameEarlyHoldTime = 0f;
						holdButtonToEndGameEarlyMeter.gameObject.SetActive(value: false);
					}
					holdButtonToEndGameEarlyMeter.fillAmount = holdButtonToEndGameEarlyHoldTime / 3f;
				}
				else
				{
					holdButtonToEndGameEarlyText.text = "Voted for ship to leave early";
					holdButtonToEndGameEarlyMeter.gameObject.SetActive(value: false);
				}
				int num = StartOfRound.Instance.connectedPlayersAmount + 1 - StartOfRound.Instance.livingPlayers;
				holdButtonToEndGameEarlyText.enabled = true;
				holdButtonToEndGameEarlyVotesText.text = $"({TimeOfDay.Instance.votesForShipToLeaveEarly}/{num} Votes)";
			}
			else
			{
				holdButtonToEndGameEarlyText.text = "Ship leaving in one hour";
				if (TimeOfDay.Instance.votesForShipToLeaveEarly <= 0)
				{
					holdButtonToEndGameEarlyVotesText.text = "";
				}
				holdButtonToEndGameEarlyMeter.gameObject.SetActive(value: false);
			}
			if (updateSpectateBoxesInterval >= 0.35f)
			{
				updateSpectateBoxesInterval = 0f;
				UpdateSpectateBoxSpeakerIcons();
			}
			else
			{
				updateSpectateBoxesInterval += Time.deltaTime;
			}
		}
		else
		{
			float num2 = Mathf.RoundToInt(Mathf.Clamp(GameNetworkManager.Instance.localPlayerController.carryWeight - 1f, 0f, 100f) * 105f);
			weightCounter.text = $"{num2} lb";
			weightCounterAnimator.SetFloat("weight", num2 / 130f);
		}
		if (CanPlayerScan())
		{
			UpdateScanNodes(GameNetworkManager.Instance.localPlayerController);
			scanElementsHidden = false;
			if (scannedScrapNum >= 2 && totalScrapScannedDisplayNum < totalScrapScanned)
			{
				addingToDisplayTotal = true;
				if (addToDisplayTotalInterval <= 0.03f)
				{
					addToDisplayTotalInterval += Time.deltaTime;
				}
				else
				{
					addToDisplayTotalInterval = 0f;
					totalScrapScannedDisplayNum = (int)Mathf.Clamp(Mathf.MoveTowards(totalScrapScannedDisplayNum, totalScrapScanned, 1500f * Time.deltaTime), 20f, 10000f);
					totalValueText.text = $"${totalScrapScannedDisplayNum}";
					UIAudio.PlayOneShot(addToScrapTotalSFX);
				}
			}
			else if (addingToDisplayTotal)
			{
				addingToDisplayTotal = false;
				UIAudio.PlayOneShot(finishAddingToTotalSFX);
			}
		}
		else if (!scanElementsHidden)
		{
			scanElementsHidden = true;
			DisableAllScanElements();
		}
		if (playerPingingScan >= -1f)
		{
			playerPingingScan -= Time.deltaTime;
		}
		for (int i = 0; i < HUDElements.Length; i++)
		{
			HUDElements[i].canvasGroup.alpha = Mathf.Lerp(HUDElements[i].canvasGroup.alpha, HUDElements[i].targetAlpha, 10f * Time.deltaTime);
		}
		if (holdFillAmount > 0f)
		{
			holdInteractionCanvasGroup.alpha = Mathf.Lerp(holdInteractionCanvasGroup.alpha, 1f, 20f * Time.deltaTime);
		}
		else
		{
			holdInteractionCanvasGroup.alpha = Mathf.Lerp(holdInteractionCanvasGroup.alpha, 0f, 20f * Time.deltaTime);
		}
		if (tutorialArrowState == 0 || !setTutorialArrow)
		{
			shockTutorialLeftAlpha.alpha = Mathf.Lerp(shockTutorialLeftAlpha.alpha, 0f, 17f * Time.deltaTime);
			shockTutorialRightAlpha.alpha = Mathf.Lerp(shockTutorialRightAlpha.alpha, 0f, 17f * Time.deltaTime);
		}
		else if (tutorialArrowState == 1)
		{
			shockTutorialLeftAlpha.alpha = Mathf.Lerp(shockTutorialLeftAlpha.alpha, 1f, 17f * Time.deltaTime);
			shockTutorialRightAlpha.alpha = Mathf.Lerp(shockTutorialRightAlpha.alpha, 0f, 17f * Time.deltaTime);
		}
		else
		{
			shockTutorialRightAlpha.alpha = Mathf.Lerp(shockTutorialRightAlpha.alpha, 1f, 17f * Time.deltaTime);
			shockTutorialLeftAlpha.alpha = Mathf.Lerp(shockTutorialLeftAlpha.alpha, 0f, 17f * Time.deltaTime);
		}
	}

	public void SetShipLeaveEarlyVotesText(int votes)
	{
		int num = StartOfRound.Instance.connectedPlayersAmount + 1 - StartOfRound.Instance.livingPlayers;
		holdButtonToEndGameEarlyVotesText.text = $"({votes}/{num} Votes)";
	}

	private void UpdateScanNodes(PlayerControllerB playerScript)
	{
		Vector3 zero = Vector3.zero;
		if (updateScanInterval <= 0f)
		{
			updateScanInterval = 0.25f;
			AssignNewNodes(playerScript);
		}
		updateScanInterval -= Time.deltaTime;
		bool flag = false;
		for (int i = 0; i < scanElements.Length; i++)
		{
			if (scanNodes.Count > 0 && scanNodes.TryGetValue(scanElements[i], out var value) && value != null)
			{
				try
				{
					if (NodeIsNotVisible(value, i))
					{
						continue;
					}
					if (!scanElements[i].gameObject.activeSelf)
					{
						scanElements[i].gameObject.SetActive(value: true);
						scanElements[i].GetComponent<Animator>().SetInteger("colorNumber", value.nodeType);
						if (value.creatureScanID != -1)
						{
							AttemptScanNewCreature(value.creatureScanID);
						}
					}
					goto IL_00f7;
				}
				catch (Exception arg)
				{
					Debug.LogError($"Error in updatescanNodes A: {arg}");
					goto IL_00f7;
				}
			}
			scanNodes.Remove(scanElements[i]);
			scanElements[i].gameObject.SetActive(value: false);
			continue;
			IL_00f7:
			try
			{
				scanElementText = scanElements[i].gameObject.GetComponentsInChildren<TextMeshProUGUI>();
				if (scanElementText.Length > 1)
				{
					scanElementText[0].text = value.headerText;
					scanElementText[1].text = value.subText;
				}
				if (value.nodeType == 2)
				{
					flag = true;
				}
				zero = playerScript.gameplayCamera.WorldToScreenPoint(value.transform.position);
				scanElements[i].anchoredPosition = new Vector2(zero.x - 439.48f, zero.y - 244.8f);
			}
			catch (Exception arg2)
			{
				Debug.LogError($"Error in updatescannodes B: {arg2}");
			}
		}
		try
		{
			if (!flag)
			{
				totalScrapScanned = 0;
				totalScrapScannedDisplayNum = 0;
				addToDisplayTotalInterval = 0.35f;
			}
			scanInfoAnimator.SetBool("display", scannedScrapNum >= 2 && flag);
		}
		catch (Exception arg3)
		{
			Debug.LogError($"Error in updatescannodes C: {arg3}");
		}
	}

	private void AssignNewNodes(PlayerControllerB playerScript)
	{
		int num = Physics.SphereCastNonAlloc(new Ray(playerScript.gameplayCamera.transform.position + playerScript.gameplayCamera.transform.forward * 20f, playerScript.gameplayCamera.transform.forward), 20f, scanNodesHit, 80f, 4194304);
		if (num > scanElements.Length)
		{
			num = scanElements.Length;
		}
		nodesOnScreen.Clear();
		scannedScrapNum = 0;
		if (num > scanElements.Length)
		{
			for (int i = 0; i < num; i++)
			{
				ScanNodeProperties component = scanNodesHit[i].transform.gameObject.GetComponent<ScanNodeProperties>();
				if (component.nodeType == 1 || component.nodeType == 2)
				{
					AttemptScanNode(component, i, playerScript);
				}
			}
		}
		if (nodesOnScreen.Count < scanElements.Length)
		{
			for (int j = 0; j < num; j++)
			{
				ScanNodeProperties component = scanNodesHit[j].transform.gameObject.GetComponent<ScanNodeProperties>();
				AttemptScanNode(component, j, playerScript);
			}
		}
	}

	private void AttemptScanNode(ScanNodeProperties node, int i, PlayerControllerB playerScript)
	{
		if (MeetsScanNodeRequirements(node, playerScript))
		{
			if (node.nodeType == 2)
			{
				scannedScrapNum++;
			}
			if (!nodesOnScreen.Contains(node))
			{
				nodesOnScreen.Add(node);
			}
			if (playerPingingScan >= 0f)
			{
				AssignNodeToUIElement(node);
			}
		}
	}

	private bool MeetsScanNodeRequirements(ScanNodeProperties node, PlayerControllerB playerScript)
	{
		if (node == null)
		{
			return false;
		}
		float num = Vector3.Distance(playerScript.transform.position, node.transform.position);
		if (num < (float)node.maxRange && num > (float)node.minRange)
		{
			if (node.requiresLineOfSight)
			{
				return !Physics.Linecast(playerScript.gameplayCamera.transform.position, node.transform.position, 256, QueryTriggerInteraction.Ignore);
			}
			return true;
		}
		return false;
	}

	private bool NodeIsNotVisible(ScanNodeProperties node, int elementIndex)
	{
		if (!nodesOnScreen.Contains(node))
		{
			if (scanNodes[scanElements[elementIndex]].nodeType == 2)
			{
				totalScrapScanned = Mathf.Clamp(totalScrapScanned - scanNodes[scanElements[elementIndex]].scrapValue, 0, 100000);
			}
			scanElements[elementIndex].gameObject.SetActive(value: false);
			scanNodes.Remove(scanElements[elementIndex]);
			return true;
		}
		return false;
	}

	private void AssignNodeToUIElement(ScanNodeProperties node)
	{
		if (scanNodes.ContainsValue(node))
		{
			return;
		}
		for (int i = 0; i < scanElements.Length; i++)
		{
			if (scanNodes.TryAdd(scanElements[i], node))
			{
				if (node.nodeType == 2)
				{
					totalScrapScanned += node.scrapValue;
					addedToScrapCounterThisFrame = true;
				}
				break;
			}
		}
	}

	private void DisableAllScanElements()
	{
		for (int i = 0; i < scanElements.Length; i++)
		{
			scanElements[i].gameObject.SetActive(value: false);
			totalScrapScanned = 0;
			totalScrapScannedDisplayNum = 0;
		}
	}

	private void AttemptScanNewCreature(int enemyID)
	{
		if (!terminalScript.scannedEnemyIDs.Contains(enemyID))
		{
			ScanNewCreatureServerRpc(enemyID);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void ScanNewCreatureServerRpc(int enemyID)
	{
		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(1944155956u, serverRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, enemyID);
				__endSendServerRpc(ref bufferWriter, 1944155956u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost) && !terminalScript.scannedEnemyIDs.Contains(enemyID))
			{
				terminalScript.scannedEnemyIDs.Add(enemyID);
				terminalScript.newlyScannedEnemyIDs.Add(enemyID);
				DisplayGlobalNotification("New creature data sent to terminal!");
				ScanNewCreatureClientRpc(enemyID);
			}
		}
	}

	[ClientRpc]
	public void ScanNewCreatureClientRpc(int enemyID)
	{
		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(3039261141u, clientRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, enemyID);
				__endSendClientRpc(ref bufferWriter, 3039261141u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !terminalScript.scannedEnemyIDs.Contains(enemyID))
			{
				terminalScript.scannedEnemyIDs.Add(enemyID);
				terminalScript.newlyScannedEnemyIDs.Add(enemyID);
				DisplayGlobalNotification("New creature data sent to terminal!");
			}
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void GetNewStoryLogServerRpc(int logID)
	{
		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(3153465849u, serverRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, logID);
				__endSendServerRpc(ref bufferWriter, 3153465849u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost) && !terminalScript.unlockedStoryLogs.Contains(logID))
			{
				terminalScript.unlockedStoryLogs.Add(logID);
				terminalScript.newlyUnlockedStoryLogs.Add(logID);
				DisplayGlobalNotification("Found journal entry: '" + terminalScript.logEntryFiles[logID].creatureName);
				GetNewStoryLogClientRpc(logID);
			}
		}
	}

	[ClientRpc]
	public void GetNewStoryLogClientRpc(int logID)
	{
		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(2416035003u, clientRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, logID);
				__endSendClientRpc(ref bufferWriter, 2416035003u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !terminalScript.unlockedStoryLogs.Contains(logID))
			{
				terminalScript.unlockedStoryLogs.Add(logID);
				terminalScript.newlyUnlockedStoryLogs.Add(logID);
				DisplayGlobalNotification("Found journal entry: '" + terminalScript.logEntryFiles[logID].creatureName + "'");
			}
		}
	}

	private void DisplayGlobalNotification(string displayText)
	{
		globalNotificationAnimator.SetTrigger("TriggerNotif");
		globalNotificationText.text = displayText;
		UIAudio.PlayOneShot(globalNotificationSFX);
	}

	public void PingHUDElement(HUDElement element, float delay = 2f, float startAlpha = 1f, float endAlpha = 0.2f)
	{
		if (delay == 0f && startAlpha == endAlpha)
		{
			element.targetAlpha = endAlpha;
			return;
		}
		element.targetAlpha = startAlpha;
		if (element.fadeCoroutine != null)
		{
			StopCoroutine(element.fadeCoroutine);
		}
		element.fadeCoroutine = StartCoroutine(FadeUIElement(element, delay, endAlpha));
	}

	private IEnumerator FadeUIElement(HUDElement element, float delay, float endAlpha)
	{
		yield return new WaitForSeconds(delay);
		element.targetAlpha = endAlpha;
	}

	public void HideHUD(bool hide)
	{
		if (hudHidden != hide)
		{
			hudHidden = hide;
			if (hide)
			{
				HUDAnimator.SetTrigger("hideHud");
				scanInfoAnimator.SetBool("display", value: false);
			}
			else
			{
				HUDAnimator.SetTrigger("revealHud");
			}
		}
	}

	public void ReadDialogue(DialogueSegment[] dialogueArray)
	{
		if (readDialogueCoroutine != null)
		{
			StopCoroutine(readDialogueCoroutine);
		}
		readDialogueCoroutine = StartCoroutine(ReadOutDialogue(dialogueArray));
	}

	private IEnumerator ReadOutDialogue(DialogueSegment[] dialogueArray)
	{
		dialogueBoxAnimator.SetBool("Open", value: true);
		for (int i = 0; i < dialogueArray.Length; i++)
		{
			dialogeBoxHeaderText.text = dialogueArray[i].speakerText;
			dialogeBoxText.text = dialogueArray[i].bodyText;
			dialogueBoxSFX.PlayOneShot(dialogueBleeps[UnityEngine.Random.Range(0, dialogueBleeps.Length)]);
			yield return new WaitForSeconds(dialogueArray[i].waitTime);
		}
		dialogueBoxAnimator.SetBool("Open", value: false);
	}

	public void DisplayCreditsEarning(int creditsEarned, GrabbableObject[] objectsSold, int newGroupCredits)
	{
		Debug.Log($"Earned {creditsEarned}; sold {objectsSold.Length} items; new credits amount: {newGroupCredits}");
		List<Item> list = new List<Item>();
		for (int i = 0; i < objectsSold.Length; i++)
		{
			list.Add(objectsSold[i].itemProperties);
		}
		Item[] array = list.Distinct().ToArray();
		string text = "";
		int num = 0;
		int num2 = 0;
		for (int j = 0; j < array.Length; j++)
		{
			num = 0;
			num2 = 0;
			for (int k = 0; k < objectsSold.Length; k++)
			{
				if (objectsSold[k].itemProperties == array[j])
				{
					num += objectsSold[k].scrapValue;
					num2++;
				}
			}
			text += $"{array[j].itemName} (x{num2}) : {num} \n";
		}
		moneyRewardsListText.text = text;
		moneyRewardsTotalText.text = $"TOTAL: ${creditsEarned}";
		moneyRewardsAnimator.SetTrigger("showRewards");
		rewardsScrollbar.value = 1f;
		if (list.Count > 8)
		{
			if (scrollRewardTextCoroutine != null)
			{
				StopCoroutine(scrollRewardTextCoroutine);
			}
			scrollRewardTextCoroutine = StartCoroutine(scrollRewardsListText());
		}
	}

	private IEnumerator scrollRewardsListText()
	{
		yield return new WaitForSeconds(0.3f);
		float num = 3f;
		while (num >= 0f)
		{
			num -= Time.deltaTime;
			rewardsScrollbar.value -= Time.deltaTime / num;
		}
	}

	public void DisplayNewDeadline(int overtimeBonus)
	{
		reachedProfitQuotaAnimator.SetBool("display", value: true);
		newProfitQuotaText.text = "$0";
		UIAudio.PlayOneShot(reachedQuotaSFX);
		displayingNewQuota = true;
		if (overtimeBonus < 0)
		{
			reachedProfitQuotaBonusText.text = "";
		}
		else
		{
			reachedProfitQuotaBonusText.text = $"Overtime bonus: ${overtimeBonus}";
		}
		StartCoroutine(rackUpNewQuotaText());
	}

	private IEnumerator rackUpNewQuotaText()
	{
		yield return new WaitForSeconds(3.5f);
		int quotaTextAmount = 0;
		while (quotaTextAmount < TimeOfDay.Instance.profitQuota)
		{
			quotaTextAmount = (int)Mathf.Clamp((float)quotaTextAmount + Time.deltaTime * 250f, quotaTextAmount + 3, TimeOfDay.Instance.profitQuota + 10);
			newProfitQuotaText.text = "$" + quotaTextAmount;
			yield return null;
		}
		newProfitQuotaText.text = "$" + TimeOfDay.Instance.profitQuota;
		TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
		UIAudio.PlayOneShot(newProfitQuotaSFX);
		yield return new WaitForSeconds(1.25f);
		displayingNewQuota = false;
		reachedProfitQuotaAnimator.SetBool("display", value: false);
	}

	public void DisplayDaysLeft(int daysLeft)
	{
		if (daysLeft >= 0)
		{
			string text = ((daysLeft != 1) ? $"{daysLeft} Days Left" : $"{daysLeft} Day Left");
			profitQuotaDaysLeftText.text = text;
			profitQuotaDaysLeftText2.text = text;
			if (daysLeft <= 1)
			{
				reachedProfitQuotaAnimator.SetTrigger("displayDaysLeft");
				UIAudio.PlayOneShot(OneDayToMeetQuotaSFX);
			}
			else
			{
				reachedProfitQuotaAnimator.SetTrigger("displayDaysLeftCalm");
				UIAudio.PlayOneShot(profitQuotaDaysLeftCalmSFX);
			}
		}
	}

	public void ShowPlayersFiredScreen(bool show)
	{
		playersFiredAnimator.SetBool("gameOver", show);
	}

	public void ShakeCamera(ScreenShakeType shakeType)
	{
		switch (shakeType)
		{
		case ScreenShakeType.Big:
			playerScreenShakeAnimator.SetTrigger("bigShake");
			break;
		case ScreenShakeType.Small:
			playerScreenShakeAnimator.SetTrigger("smallShake");
			break;
		case ScreenShakeType.Long:
			playerScreenShakeAnimator.SetTrigger("longShake");
			break;
		case ScreenShakeType.VeryStrong:
			playerScreenShakeAnimator.SetTrigger("veryStrongShake");
			break;
		}
	}

	public void ToggleHUD(bool enable)
	{
		HUDContainer.SetActive(enable);
	}

	public void FillEndGameStats(EndOfGameStats stats)
	{
		int num = 0;
		int num2 = 0;
		for (int i = 0; i < playersManager.allPlayerScripts.Length; i++)
		{
			PlayerControllerB playerControllerB = playersManager.allPlayerScripts[i];
			statsUIElements.playerNamesText[i].text = "";
			statsUIElements.playerStates[i].enabled = false;
			statsUIElements.playerNotesText[i].text = "Notes: \n";
			if (playerControllerB.disconnectedMidGame || playerControllerB.isPlayerDead || playerControllerB.isPlayerControlled)
			{
				if (playerControllerB.isPlayerDead)
				{
					num++;
				}
				else if (playerControllerB.isPlayerControlled)
				{
					num2++;
				}
				statsUIElements.playerNamesText[i].text = playersManager.allPlayerScripts[i].playerUsername;
				statsUIElements.playerStates[i].enabled = true;
				if (playersManager.allPlayerScripts[i].isPlayerDead)
				{
					if (playersManager.allPlayerScripts[i].causeOfDeath == CauseOfDeath.Abandoned)
					{
						statsUIElements.playerStates[i].sprite = statsUIElements.missingIcon;
					}
					else
					{
						statsUIElements.playerStates[i].sprite = statsUIElements.deceasedIcon;
					}
				}
				else
				{
					statsUIElements.playerStates[i].sprite = statsUIElements.aliveIcon;
				}
				for (int j = 0; j < 3 && j < stats.allPlayerStats[i].playerNotes.Count; j++)
				{
					TextMeshProUGUI obj = statsUIElements.playerNotesText[i];
					obj.text = obj.text + "* " + stats.allPlayerStats[i].playerNotes[j] + "\n";
				}
			}
			else
			{
				statsUIElements.playerNotesText[i].text = "";
			}
		}
		statsUIElements.quotaNumerator.text = RoundManager.Instance.scrapCollectedInLevel.ToString();
		statsUIElements.quotaDenominator.text = RoundManager.Instance.totalScrapValueInLevel.ToString();
		if (StartOfRound.Instance.allPlayersDead)
		{
			statsUIElements.allPlayersDeadOverlay.enabled = true;
			statsUIElements.gradeLetter.text = "F";
			return;
		}
		statsUIElements.allPlayersDeadOverlay.enabled = false;
		int num3 = 0;
		float num4 = (float)RoundManager.Instance.scrapCollectedInLevel / RoundManager.Instance.totalScrapValueInLevel;
		if (num2 == StartOfRound.Instance.connectedPlayersAmount + 1)
		{
			num3++;
		}
		else if (num > 1)
		{
			num3--;
		}
		if (num4 >= 0.99f)
		{
			num3 += 2;
		}
		else if (num4 >= 0.6f)
		{
			num3++;
		}
		else if (num4 <= 0.25f)
		{
			num3--;
		}
		switch (num3)
		{
		case -1:
			statsUIElements.gradeLetter.text = "D";
			break;
		case 0:
			statsUIElements.gradeLetter.text = "C";
			break;
		case 1:
			statsUIElements.gradeLetter.text = "B";
			break;
		case 2:
			statsUIElements.gradeLetter.text = "A";
			break;
		case 3:
			statsUIElements.gradeLetter.text = "S";
			break;
		}
	}

	[ServerRpc]
	public void SyncAllPlayerLevelsServerRpc()
	{
		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 <= Unity.Netcode.LogLevel.Normal)
				{
					Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			ServerRpcParams serverRpcParams = default(ServerRpcParams);
			FastBufferWriter bufferWriter = __beginSendServerRpc(2352591293u, serverRpcParams, RpcDelivery.Reliable);
			__endSendServerRpc(ref bufferWriter, 2352591293u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Server || (!networkManager.IsServer && !networkManager.IsHost))
		{
			return;
		}
		int[] array = new int[4];
		for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
		{
			if (!StartOfRound.Instance.allPlayerScripts[i].isPlayerControlled)
			{
				array[i] = -1;
			}
			else
			{
				array[i] = StartOfRound.Instance.allPlayerScripts[i].playerLevelNumber;
			}
		}
		bool[] array2 = new bool[4];
		for (int j = 0; j < StartOfRound.Instance.allPlayerScripts.Length; j++)
		{
			if (!StartOfRound.Instance.allPlayerScripts[j].isPlayerControlled)
			{
				array2[j] = false;
			}
			else
			{
				array2[j] = StartOfRound.Instance.allPlayerScripts[j].playerBetaBadgeMesh.enabled;
			}
		}
		SyncAllPlayerLevelsClientRpc(array, array2);
	}

	[ClientRpc]
	public void SyncAllPlayerLevelsClientRpc(int[] playerLevelNumbers, bool[] playersHaveBeta)
	{
		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(1570713893u, clientRpcParams, RpcDelivery.Reliable);
			bool value = playerLevelNumbers != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(playerLevelNumbers, default(FastBufferWriter.ForPrimitives));
			}
			bool value2 = playersHaveBeta != null;
			bufferWriter.WriteValueSafe(in value2, default(FastBufferWriter.ForPrimitives));
			if (value2)
			{
				bufferWriter.WriteValueSafe(playersHaveBeta, default(FastBufferWriter.ForPrimitives));
			}
			__endSendClientRpc(ref bufferWriter, 1570713893u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		try
		{
			for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
			{
				SetLevelOfPlayer(StartOfRound.Instance.allPlayerScripts[i], playerLevelNumbers[i], playersHaveBeta[i]);
			}
		}
		catch (Exception arg)
		{
			Debug.LogError($"Error while syncing player level from server: {arg}");
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void SyncPlayerLevelServerRpc(int playerId, int playerLevelIndex, bool hasBeta = false)
	{
		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(1389701054u, serverRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, playerId);
				BytePacker.WriteValueBitPacked(bufferWriter, playerLevelIndex);
				bufferWriter.WriteValueSafe(in hasBeta, default(FastBufferWriter.ForPrimitives));
				__endSendServerRpc(ref bufferWriter, 1389701054u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				SyncPlayerLevelClientRpc(playerId, playerLevelIndex, hasBeta);
			}
		}
	}

	[ClientRpc]
	public void SyncPlayerLevelClientRpc(int playerId, int playerLevelIndex, bool hasBeta)
	{
		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(1676259161u, clientRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, playerId);
			BytePacker.WriteValueBitPacked(bufferWriter, playerLevelIndex);
			bufferWriter.WriteValueSafe(in hasBeta, default(FastBufferWriter.ForPrimitives));
			__endSendClientRpc(ref bufferWriter, 1676259161u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		try
		{
			if ((int)GameNetworkManager.Instance.localPlayerController.playerClientId != playerId)
			{
				if (playerLevelIndex >= playerLevels.Length)
				{
					Debug.LogError("Error: Player level synced in client RPC was above the max player level!");
				}
				else
				{
					SetLevelOfPlayer(StartOfRound.Instance.allPlayerScripts[playerId], playerLevelIndex, hasBeta);
				}
			}
		}
		catch (Exception arg)
		{
			Debug.LogError($"Error while syncing player level from client #{playerId}: {arg}");
		}
	}

	public void SetLevelOfPlayer(PlayerControllerB playerScript, int playerLevelIndex, bool hasBeta)
	{
		playerScript.playerLevelNumber = playerLevelIndex;
		playerScript.playerBetaBadgeMesh.enabled = hasBeta;
		playerScript.playerBadgeMesh.mesh = playerLevels[playerLevelIndex].badgeMesh;
	}

	public void SetPlayerLevel(bool isDead, bool mostProfitable, bool allPlayersDead)
	{
		int num = 0;
		num = ((!isDead) ? (num + 10) : (num - 3));
		if (mostProfitable)
		{
			num += 15;
		}
		if (allPlayersDead)
		{
			num -= 5;
		}
		if (num > 0)
		{
			Debug.Log($"XP gain before scaling to scrap returned: {num}");
			Debug.Log((float)RoundManager.Instance.scrapCollectedInLevel / RoundManager.Instance.totalScrapValueInLevel);
			float num2 = (float)RoundManager.Instance.scrapCollectedInLevel / RoundManager.Instance.totalScrapValueInLevel;
			Debug.Log(num2);
			num = (int)((float)num * num2);
		}
		if (num == 0)
		{
			Debug.Log("Gained no XP");
			playerLevelMeter.fillAmount = localPlayerXP / playerLevels[localPlayerLevel].XPMax;
			playerLevelXPCounter.text = localPlayerXP.ToString();
			playerLevelText.text = playerLevels[localPlayerLevel].levelName;
		}
		else
		{
			StartCoroutine(SetPlayerLevelSmoothly(num));
		}
	}

	private IEnumerator SetPlayerLevelSmoothly(int XPGain)
	{
		float changingPlayerXP = localPlayerXP;
		int changingPlayerLevel = localPlayerLevel;
		int targetXPLevel = Mathf.Max(localPlayerXP + XPGain, 0);
		bool conditionMet = false;
		if (XPGain < 0)
		{
			LevellingAudio.clip = decreaseXPSFX;
		}
		else
		{
			LevellingAudio.clip = increaseXPSFX;
		}
		LevellingAudio.Play();
		float timeAtStart = Time.realtimeSinceStartup;
		while (!conditionMet && Time.realtimeSinceStartup - timeAtStart < 5f)
		{
			Debug.Log($"Level up timer: {Time.realtimeSinceStartup - timeAtStart}");
			if (XPGain < 0)
			{
				changingPlayerXP -= Time.deltaTime * 15f;
				if (changingPlayerXP < 0f)
				{
					changingPlayerXP = 0f;
				}
				if (changingPlayerXP <= (float)targetXPLevel)
				{
					conditionMet = true;
				}
				if (changingPlayerLevel - 1 >= 0 && changingPlayerXP < (float)playerLevels[changingPlayerLevel].XPMin)
				{
					changingPlayerLevel--;
					UIAudio.PlayOneShot(levelDecreaseSFX);
					playerLevelBoxAnimator.SetTrigger("Shake");
					yield return new WaitForSeconds(0.4f);
				}
			}
			else
			{
				changingPlayerXP += Time.deltaTime * 15f;
				if (changingPlayerXP >= (float)targetXPLevel)
				{
					conditionMet = true;
				}
				if (changingPlayerLevel + 1 < playerLevels.Length && changingPlayerXP >= (float)playerLevels[changingPlayerLevel].XPMax)
				{
					changingPlayerLevel++;
					UIAudio.PlayOneShot(levelIncreaseSFX);
					playerLevelBoxAnimator.SetTrigger("Shake");
					yield return new WaitForSeconds(0.4f);
				}
			}
			playerLevelMeter.fillAmount = (changingPlayerXP - (float)playerLevels[changingPlayerLevel].XPMin) / (float)playerLevels[changingPlayerLevel].XPMax;
			playerLevelText.text = playerLevels[changingPlayerLevel].levelName;
			playerLevelXPCounter.text = $"{Mathf.RoundToInt(changingPlayerXP)} EXP";
			yield return null;
		}
		LevellingAudio.Stop();
		int num = 0;
		for (int i = 0; i < playerLevels.Length; i++)
		{
			if (targetXPLevel >= playerLevels[i].XPMin && targetXPLevel < playerLevels[i].XPMax)
			{
				num = i;
				break;
			}
		}
		localPlayerXP = targetXPLevel;
		localPlayerLevel = num;
		playerLevelText.text = playerLevels[localPlayerLevel].levelName;
		playerLevelXPCounter.text = $"{Mathf.RoundToInt(localPlayerXP)} EXP";
		bool hasBeta = ES3.Load("playedDuringBeta", "LCGeneralSaveData", defaultValue: true);
		SyncPlayerLevelServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId, localPlayerLevel, hasBeta);
	}

	public void ApplyPenalty(int playersDead, int bodiesInsured)
	{
		float num = 0.2f;
		Terminal terminal = UnityEngine.Object.FindObjectOfType<Terminal>();
		int groupCredits = terminal.groupCredits;
		bodiesInsured = Mathf.Max(bodiesInsured, 0);
		for (int i = 0; i < playersDead - bodiesInsured; i++)
		{
			terminal.groupCredits -= (int)((float)groupCredits * num);
		}
		for (int j = 0; j < bodiesInsured; j++)
		{
			terminal.groupCredits -= (int)((float)groupCredits * (num / 2.5f));
		}
		if (terminal.groupCredits < 0)
		{
			terminal.groupCredits = 0;
		}
		statsUIElements.penaltyAddition.text = $"{playersDead} casualties: -{num * 100f * (float)(playersDead - bodiesInsured)}%\n({bodiesInsured} bodies recovered)";
		statsUIElements.penaltyTotal.text = $"DUE: ${groupCredits - terminal.groupCredits}";
		Debug.Log($"New group credits after penalty: {terminal.groupCredits}");
	}

	public void SetQuota(int numerator, int denominator = -1)
	{
		HUDQuotaNumerator.text = numerator.ToString();
		if (denominator != -1)
		{
			HUDQuotaDenominator.text = denominator.ToString();
		}
	}

	public void AddNewScrapFoundToDisplay(GrabbableObject GObject)
	{
		if (itemsToBeDisplayed.Count <= 16)
		{
			itemsToBeDisplayed.Add(GObject);
		}
	}

	public void DisplayNewScrapFound()
	{
		if (itemsToBeDisplayed.Count <= 0)
		{
			return;
		}
		if (itemsToBeDisplayed[0] == null || itemsToBeDisplayed[0].itemProperties.spawnPrefab == null)
		{
			itemsToBeDisplayed.Clear();
			return;
		}
		if (itemsToBeDisplayed[0].scrapValue < 80)
		{
			UIAudio.PlayOneShot(displayCollectedScrapSFXSmall);
		}
		else
		{
			UIAudio.PlayOneShot(displayCollectedScrapSFX);
		}
		GameObject gameObject = UnityEngine.Object.Instantiate(itemsToBeDisplayed[0].itemProperties.spawnPrefab, ScrapItemBoxes[nextBoxIndex].itemObjectContainer);
		UnityEngine.Object.Destroy(gameObject.GetComponent<NetworkObject>());
		UnityEngine.Object.Destroy(gameObject.GetComponent<GrabbableObject>());
		UnityEngine.Object.Destroy(gameObject.GetComponent<Collider>());
		gameObject.transform.localPosition = Vector3.zero;
		gameObject.transform.localScale = gameObject.transform.localScale * 4f;
		gameObject.transform.rotation = Quaternion.Euler(itemsToBeDisplayed[0].itemProperties.restingRotation);
		Renderer[] componentsInChildren = gameObject.GetComponentsInChildren<Renderer>();
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			if (componentsInChildren[i].gameObject.layer != 22)
			{
				Material[] sharedMaterials = componentsInChildren[i].sharedMaterials;
				componentsInChildren[i].rendererPriority = 70;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					sharedMaterials[j] = hologramMaterial;
				}
				componentsInChildren[i].sharedMaterials = sharedMaterials;
				componentsInChildren[i].gameObject.layer = 5;
			}
		}
		ScrapItemBoxes[nextBoxIndex].itemDisplayAnimator.SetTrigger("collect");
		if (itemsToBeDisplayed[0] is RagdollGrabbableObject)
		{
			RagdollGrabbableObject ragdollGrabbableObject = itemsToBeDisplayed[0] as RagdollGrabbableObject;
			if (ragdollGrabbableObject != null && ragdollGrabbableObject.ragdoll != null)
			{
				ScrapItemBoxes[nextBoxIndex].headerText.text = ragdollGrabbableObject.ragdoll.playerScript.playerUsername + " collected!";
			}
			else
			{
				ScrapItemBoxes[nextBoxIndex].headerText.text = "Body collected!";
			}
		}
		else
		{
			ScrapItemBoxes[nextBoxIndex].headerText.text = itemsToBeDisplayed[0].itemProperties.itemName + " collected!";
		}
		ScrapItemBoxes[nextBoxIndex].valueText.text = $"Value: ${itemsToBeDisplayed[0].scrapValue}";
		if (boxesDisplaying > 0)
		{
			ScrapItemBoxes[nextBoxIndex].UIContainer.anchoredPosition = new Vector2(ScrapItemBoxes[nextBoxIndex].UIContainer.anchoredPosition.x, ScrapItemBoxes[bottomBoxIndex].UIContainer.anchoredPosition.y - 124f);
		}
		else
		{
			ScrapItemBoxes[nextBoxIndex].UIContainer.anchoredPosition = new Vector2(ScrapItemBoxes[nextBoxIndex].UIContainer.anchoredPosition.x, bottomBoxYPosition);
		}
		bottomBoxIndex = nextBoxIndex;
		StartCoroutine(displayScrapTimer(gameObject));
		playScrapDisplaySFX();
		boxesDisplaying++;
		nextBoxIndex = (nextBoxIndex + 1) % 3;
		itemsToBeDisplayed.RemoveAt(0);
	}

	private IEnumerator playScrapDisplaySFX()
	{
		yield return new WaitForSeconds(0.05f * (float)boxesDisplaying);
	}

	private IEnumerator displayScrapTimer(GameObject displayingObject)
	{
		yield return new WaitForSeconds(3.5f);
		boxesDisplaying--;
		UnityEngine.Object.Destroy(displayingObject);
	}

	public void ChangeControlTip(int toolTipNumber, string changeTo, bool clearAllOther = false)
	{
		if (StartOfRound.Instance.localPlayerUsingController)
		{
			StringBuilder stringBuilder = new StringBuilder(changeTo);
			stringBuilder.Replace("[E]", "[D-pad up]");
			stringBuilder.Replace("[Q]", "[D-pad down]");
			stringBuilder.Replace("[LMB]", "[Y]");
			stringBuilder.Replace("[RMB]", "[R-Trigger]");
			stringBuilder.Replace("[G]", "[B]");
			changeTo = stringBuilder.ToString();
		}
		else
		{
			changeTo = changeTo.Replace("[RMB]", "[LMB]");
		}
		controlTipLines[toolTipNumber].text = changeTo;
		if (clearAllOther)
		{
			for (int i = 0; i < controlTipLines.Length; i++)
			{
				if (i != toolTipNumber)
				{
					controlTipLines[i].text = "";
				}
			}
		}
		if (forceChangeTextCoroutine != null)
		{
			StopCoroutine(forceChangeTextCoroutine);
		}
		forceChangeTextCoroutine = StartCoroutine(ForceChangeText(controlTipLines[toolTipNumber], changeTo));
	}

	private IEnumerator ForceChangeText(TextMeshProUGUI textToChange, string changeTextTo)
	{
		for (int i = 0; i < 5; i++)
		{
			yield return null;
			textToChange.text = changeTextTo;
		}
	}

	public void ClearControlTips()
	{
		for (int i = 0; i < controlTipLines.Length; i++)
		{
			controlTipLines[i].text = "";
		}
	}

	public void ChangeControlTipMultiple(string[] allLines, bool holdingItem = false, Item itemProperties = null)
	{
		if (holdingItem)
		{
			controlTipLines[0].text = "Drop " + itemProperties.itemName + " : [G]";
		}
		if (allLines == null)
		{
			return;
		}
		int num = 0;
		if (holdingItem)
		{
			num = 1;
		}
		for (int i = 0; i < allLines.Length && i + num < controlTipLines.Length; i++)
		{
			string text = allLines[i];
			if (StartOfRound.Instance.localPlayerUsingController)
			{
				StringBuilder stringBuilder = new StringBuilder(text);
				stringBuilder.Replace("[E]", "[D-pad up]");
				stringBuilder.Replace("[Q]", "[D-pad down]");
				stringBuilder.Replace("[LMB]", "[Y]");
				stringBuilder.Replace("[RMB]", "[R-Trigger]");
				stringBuilder.Replace("[G]", "[B]");
				text = stringBuilder.ToString();
			}
			else
			{
				text = text.Replace("[RMB]", "[LMB]");
			}
			controlTipLines[i + num].text = text;
		}
	}

	public void DisplayStatusEffect(string statusEffect)
	{
		statusEffectAnimator.SetTrigger("IndicateStatus");
		statusEffectText.text = statusEffect;
	}

	public void DisplayTip(string headerText, string bodyText, bool isWarning = false, bool useSave = false, string prefsKey = "LC_Tip1")
	{
		if (!CanTipDisplay(isWarning, useSave, prefsKey))
		{
			return;
		}
		if (useSave)
		{
			if (tipsPanelCoroutine != null)
			{
				StopCoroutine(tipsPanelCoroutine);
			}
			tipsPanelCoroutine = StartCoroutine(TipsPanelTimer(prefsKey));
		}
		tipsPanelHeader.text = headerText;
		tipsPanelBody.text = bodyText;
		if (isWarning)
		{
			tipsPanelAnimator.SetTrigger("TriggerWarning");
			RoundManager.PlayRandomClip(UIAudio, warningSFX, randomize: false);
		}
		else
		{
			tipsPanelAnimator.SetTrigger("TriggerHint");
			RoundManager.PlayRandomClip(UIAudio, tipsSFX, randomize: false);
		}
	}

	private void DisplaySpectatorVoteTip()
	{
		if (displayedSpectatorAFKTip)
		{
			return;
		}
		bool flag = false;
		for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
		{
			if (!StartOfRound.Instance.allPlayerScripts[i].isPlayerDead && StartOfRound.Instance.allPlayerScripts[i].timeSincePlayerMoving < 10f)
			{
				flag = true;
			}
		}
		if (!flag)
		{
			noLivingPlayersAtKeyboardTimer += Time.deltaTime;
			if (noLivingPlayersAtKeyboardTimer > 12f)
			{
				if (StartOfRound.Instance.localPlayerUsingController)
				{
					DisplaySpectatorTip("TIP!: Hold [R-Trigger] to vote for the autopilot ship to leave early.");
				}
				else
				{
					DisplaySpectatorTip("TIP!: Hold [RMB] to vote for the autopilot ship to leave early.");
				}
			}
		}
		else
		{
			noLivingPlayersAtKeyboardTimer = 0f;
		}
	}

	private void DisplaySpectatorTip(string tipText)
	{
		displayedSpectatorAFKTip = true;
		spectatorTipText.text = tipText;
		if (!spectatorTipText.enabled)
		{
			StartCoroutine(displayTipTextTimer());
		}
	}

	private IEnumerator displayTipTextTimer()
	{
		UIAudio.PlayOneShot(tipsSFX[0], 1f);
		spectatorTipText.enabled = true;
		yield return new WaitForSeconds(7f);
		spectatorTipText.enabled = false;
	}

	private bool CanTipDisplay(bool isWarning, bool useSave, string prefsKey)
	{
		if (useSave)
		{
			return !ES3.Load(prefsKey, "LCGeneralSaveData", defaultValue: false);
		}
		if (tipsPanelCoroutine != null)
		{
			if (isWarning && !isDisplayingWarning)
			{
				return true;
			}
			return false;
		}
		return true;
	}

	private IEnumerator TipsPanelTimer(string prefsKey)
	{
		yield return new WaitForSeconds(5f);
		ES3.Save(prefsKey, value: true, "LCGeneralSaveData");
	}

	public string SetClock(float timeNormalized, float numberOfHours, bool createNewLine = true)
	{
		int num = (int)(timeNormalized * (60f * numberOfHours)) + 360;
		int num2 = (int)Mathf.Floor(num / 60);
		if (!createNewLine)
		{
			newLine = " ";
		}
		else
		{
			newLine = "\n";
		}
		amPM = newLine + "AM";
		if (num2 >= 24)
		{
			clockNumber.text = "12:00 " + newLine + " AM";
			return "12:00\nAM";
		}
		if (num2 < 12)
		{
			amPM = newLine + "AM";
		}
		else
		{
			amPM = newLine + "PM";
		}
		if (num2 > 12)
		{
			num2 %= 12;
		}
		int num3 = num % 60;
		string text = $"{num2:00}:{num3:00}".TrimStart('0') + amPM;
		clockNumber.text = text;
		return text;
	}

	public void SetClockIcon(DayMode dayMode)
	{
		clockIcon.sprite = clockIcons[(int)dayMode];
	}

	public void SetClockVisible(bool visible)
	{
		if (visible)
		{
			Clock.targetAlpha = 1f;
		}
		else
		{
			Clock.targetAlpha = 0f;
		}
	}

	public void TriggerAlarmHornEffect()
	{
		if (!(UnityEngine.Object.FindObjectOfType<AlarmButton>() == null))
		{
			AlarmHornServerRpc();
		}
	}

	[ServerRpc]
	public void AlarmHornServerRpc()
	{
		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 <= Unity.Netcode.LogLevel.Normal)
				{
					Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			ServerRpcParams serverRpcParams = default(ServerRpcParams);
			FastBufferWriter bufferWriter = __beginSendServerRpc(1616150480u, serverRpcParams, RpcDelivery.Reliable);
			__endSendServerRpc(ref bufferWriter, 1616150480u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
		{
			AlarmButton alarmButton = UnityEngine.Object.FindObjectOfType<AlarmButton>();
			if (!(alarmButton == null) && !(alarmButton.timeSincePushing < 1f))
			{
				alarmButton.timeSincePushing = 0f;
				AlarmHornClientRpc();
			}
		}
	}

	[ClientRpc]
	public void AlarmHornClientRpc()
	{
		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(840104050u, clientRpcParams, RpcDelivery.Reliable);
			__endSendClientRpc(ref bufferWriter, 840104050u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
		{
			AlarmButton alarmButton = UnityEngine.Object.FindObjectOfType<AlarmButton>();
			if (!(alarmButton == null))
			{
				alarmButton.timeSincePushing = 0f;
				alarmHornEffect.SetTrigger("triggerAlarm");
				UIAudio.PlayOneShot(shipAlarmHornSFX, 1f);
			}
		}
	}

	public void RadiationWarningHUD()
	{
		radiationGraphicAnimator.SetTrigger("RadiationWarning");
		UIAudio.PlayOneShot(radiationWarningAudio, 1f);
	}

	public void UpdateInstabilityPercentage(int percentage)
	{
		if (previousInstability != percentage)
		{
			UpdateInstabilityClientRpc(percentage);
		}
	}

	[ClientRpc]
	public void UpdateInstabilityClientRpc(int percentage)
	{
		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(551948140u, clientRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, percentage);
				__endSendClientRpc(ref bufferWriter, 551948140u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				instabilityCounterNumber.text = $"{percentage}%";
				PingHUDElement(InstabilityCounter, 2f, 1f, 0.7f);
			}
		}
	}

	public void SetTutorialArrow(int state)
	{
		tutorialArrowState = state;
	}

	public bool HoldInteractionFill(float timeToHold, float speedMultiplier = 1f)
	{
		if (timeToHold == -1f)
		{
			return false;
		}
		holdFillAmount += Time.deltaTime * speedMultiplier;
		holdInteractionFillAmount.fillAmount = holdFillAmount / timeToHold;
		if (holdFillAmount > timeToHold)
		{
			holdFillAmount = 0f;
			return true;
		}
		return false;
	}

	public void ToggleErrorConsole()
	{
		errorLogPanel.SetActive(!Instance.errorLogPanel.activeSelf);
	}

	[ServerRpc(RequireOwnership = false)]
	public void SendErrorMessageServerRpc(string errorMessage, int sentByPlayerNum)
	{
		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(1043384750u, serverRpcParams, RpcDelivery.Reliable);
			bool value = errorMessage != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(errorMessage);
			}
			BytePacker.WriteValueBitPacked(bufferWriter, sentByPlayerNum);
			__endSendServerRpc(ref bufferWriter, 1043384750u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost) && GameNetworkManager.Instance.SendExceptionsToServer && !(Instance == null))
		{
			AddToErrorLog(errorMessage, sentByPlayerNum);
		}
	}

	public void AddToErrorLog(string errorMessage, int sentByPlayerNum)
	{
		if (!(errorMessage == previousErrorReceived))
		{
			previousErrorReceived = errorMessage;
			string playerUsername = StartOfRound.Instance.allPlayerScripts[sentByPlayerNum].playerUsername;
			playerUsername = playerUsername.Substring(0, Mathf.Clamp(5, 1, playerUsername.Length));
			Instance.errorLogText.text = (Instance.errorLogText.text + "\n\n" + playerUsername + ": " + errorMessage).Substring(Mathf.Max(0, Instance.errorLogText.text.Length - 1000));
		}
	}

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

	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeRPCS_HUDManager()
	{
		NetworkManager.__rpc_func_table.Add(2930587515u, __rpc_handler_2930587515);
		NetworkManager.__rpc_func_table.Add(168728662u, __rpc_handler_168728662);
		NetworkManager.__rpc_func_table.Add(2787681914u, __rpc_handler_2787681914);
		NetworkManager.__rpc_func_table.Add(1568596901u, __rpc_handler_1568596901);
		NetworkManager.__rpc_func_table.Add(1944155956u, __rpc_handler_1944155956);
		NetworkManager.__rpc_func_table.Add(3039261141u, __rpc_handler_3039261141);
		NetworkManager.__rpc_func_table.Add(3153465849u, __rpc_handler_3153465849);
		NetworkManager.__rpc_func_table.Add(2416035003u, __rpc_handler_2416035003);
		NetworkManager.__rpc_func_table.Add(2352591293u, __rpc_handler_2352591293);
		NetworkManager.__rpc_func_table.Add(1570713893u, __rpc_handler_1570713893);
		NetworkManager.__rpc_func_table.Add(1389701054u, __rpc_handler_1389701054);
		NetworkManager.__rpc_func_table.Add(1676259161u, __rpc_handler_1676259161);
		NetworkManager.__rpc_func_table.Add(1616150480u, __rpc_handler_1616150480);
		NetworkManager.__rpc_func_table.Add(840104050u, __rpc_handler_840104050);
		NetworkManager.__rpc_func_table.Add(551948140u, __rpc_handler_551948140);
		NetworkManager.__rpc_func_table.Add(1043384750u, __rpc_handler_1043384750);
	}

	private static void __rpc_handler_2930587515(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			string s = null;
			if (value)
			{
				reader.ReadValueSafe(out s, oneByteChars: false);
			}
			ByteUnpacker.ReadValueBitPacked(reader, out int value2);
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((HUDManager)target).AddPlayerChatMessageServerRpc(s, value2);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_168728662(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			string s = null;
			if (value)
			{
				reader.ReadValueSafe(out s, oneByteChars: false);
			}
			ByteUnpacker.ReadValueBitPacked(reader, out int value2);
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((HUDManager)target).AddPlayerChatMessageClientRpc(s, value2);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_2787681914(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			string s = null;
			if (value)
			{
				reader.ReadValueSafe(out s, oneByteChars: false);
			}
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((HUDManager)target).AddTextMessageServerRpc(s);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1568596901(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			string s = null;
			if (value)
			{
				reader.ReadValueSafe(out s, oneByteChars: false);
			}
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((HUDManager)target).AddTextMessageClientRpc(s);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1944155956(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;
			((HUDManager)target).ScanNewCreatureServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_3039261141(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;
			((HUDManager)target).ScanNewCreatureClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_3153465849(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;
			((HUDManager)target).GetNewStoryLogServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_2416035003(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;
			((HUDManager)target).GetNewStoryLogClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_2352591293(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 <= Unity.Netcode.LogLevel.Normal)
			{
				Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
			}
		}
		else
		{
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((HUDManager)target).SyncAllPlayerLevelsServerRpc();
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1570713893(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));
			}
			reader.ReadValueSafe(out bool value3, default(FastBufferWriter.ForPrimitives));
			bool[] value4 = null;
			if (value3)
			{
				reader.ReadValueSafe(out value4, default(FastBufferWriter.ForPrimitives));
			}
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((HUDManager)target).SyncAllPlayerLevelsClientRpc(value2, value4);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1389701054(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));
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((HUDManager)target).SyncPlayerLevelServerRpc(value, value2, value3);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1676259161(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));
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((HUDManager)target).SyncPlayerLevelClientRpc(value, value2, value3);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1616150480(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 <= Unity.Netcode.LogLevel.Normal)
			{
				Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
			}
		}
		else
		{
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((HUDManager)target).AlarmHornServerRpc();
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_840104050(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((HUDManager)target).AlarmHornClientRpc();
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_551948140(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;
			((HUDManager)target).UpdateInstabilityClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1043384750(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			string s = null;
			if (value)
			{
				reader.ReadValueSafe(out s, oneByteChars: false);
			}
			ByteUnpacker.ReadValueBitPacked(reader, out int value2);
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((HUDManager)target).SendErrorMessageServerRpc(s, value2);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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