2890 lines
88 KiB
C#
2890 lines
88 KiB
C#
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";
|
|
}
|
|
}
|