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

888 lines
26 KiB
C#
Raw Normal View History

2023-12-22 22:51:17 +00:00
using System;
using System.Collections;
using System.Collections.Generic;
using GameNetcodeStuff;
using Netcode.Transports.Facepunch;
using Steamworks;
using Steamworks.Data;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.SceneManagement;
public class GameNetworkManager : MonoBehaviour
{
public int gameVersionNum = 1;
public int compatibleFileCutoffVersion;
public bool AlwaysDisplayNews = true;
public bool isDemo;
[Space(5f)]
public bool SendExceptionsToServer;
[Space(5f)]
public bool disableSteam;
private FacepunchTransport transport;
public HostSettings lobbyHostSettings;
public int connectedPlayers;
private bool hasSubscribedToConnectionCallbacks;
public bool gameHasStarted;
public PlayerControllerB localPlayerController;
public int disconnectReason;
public string username;
public bool isDisconnecting;
public bool firstTimeInMenu = true;
public bool isHostingGame;
public bool waitingForLobbyDataRefresh;
public int playersInRefreshedLobby;
public string steamLobbyName;
public const string LCsaveFile1Name = "LCSaveFile1";
public const string LCsaveFile2Name = "LCSaveFile2";
public const string LCsaveFile3Name = "LCSaveFile3";
public const string generalSaveDataName = "LCGeneralSaveData";
public string currentSaveFileName = "LCSaveFile1";
public int saveFileNum;
public AudioClip buttonCancelSFX;
public AudioClip buttonSelectSFX;
public AudioClip buttonPressSFX;
public AudioClip buttonTuneSFX;
public bool disallowConnection;
public string disconnectionReasonMessage;
public bool localClientWaitingForApproval;
public bool disapprovedClientThisFrame;
private string previousLogErrorString;
public static GameNetworkManager Instance { get; private set; }
public Lobby? currentLobby { get; private set; }
private void LogCallback(string condition, string stackTrace, LogType type)
{
if ((type != LogType.Exception && type != 0) || HUDManager.Instance == null || localPlayerController == null)
{
return;
}
string text = condition + stackTrace.Substring(0, Mathf.Clamp(200, 0, stackTrace.Length));
if (string.IsNullOrEmpty(previousLogErrorString) || !(text == previousLogErrorString))
{
previousLogErrorString = text;
if (!SendExceptionsToServer)
{
HUDManager.Instance.AddToErrorLog(text, (int)localPlayerController.playerClientId);
return;
}
HUDManager.Instance.SendErrorMessageServerRpc(text, (int)localPlayerController.playerClientId);
HUDManager.Instance.AddToErrorLog(text, (int)localPlayerController.playerClientId);
}
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
StartCoroutine(waitFrameBeforeFindingUsername());
if (compatibleFileCutoffVersion > gameVersionNum)
{
Debug.LogError("The compatible file cutoff version was higher than the game version number. This should not happen!!");
compatibleFileCutoffVersion = gameVersionNum;
}
}
else
{
UnityEngine.Object.Destroy(base.gameObject);
}
}
private IEnumerator waitFrameBeforeFindingUsername()
{
yield return null;
yield return null;
if (!disableSteam)
{
string text = SteamClient.Name.ToString();
if (text.Length > 18)
{
text.Remove(15, text.Length - 15);
text += "...";
}
username = text;
}
else
{
username = "PlayerName";
}
}
private void Start()
{
GetComponent<NetworkManager>().NetworkConfig.ProtocolVersion = (ushort)gameVersionNum;
if ((bool)GetComponent<FacepunchTransport>())
{
transport = GetComponent<FacepunchTransport>();
}
else
{
Debug.Log("Facepunch transport is disabled.");
}
saveFileNum = ES3.Load("SelectedFile", "LCGeneralSaveData", 0);
switch (saveFileNum)
{
case 0:
currentSaveFileName = "LCSaveFile1";
break;
case 1:
currentSaveFileName = "LCSaveFile2";
break;
case 2:
currentSaveFileName = "LCSaveFile3";
break;
default:
currentSaveFileName = "LCSaveFile1";
break;
}
}
private void OnEnable()
{
Application.logMessageReceived += LogCallback;
if (!disableSteam)
{
Debug.Log("subcribing to steam callbacks");
SteamMatchmaking.OnLobbyCreated += SteamMatchmaking_OnLobbyCreated;
SteamMatchmaking.OnLobbyMemberJoined += SteamMatchmaking_OnLobbyMemberJoined;
SteamMatchmaking.OnLobbyMemberLeave += SteamMatchmaking_OnLobbyMemberLeave;
SteamMatchmaking.OnLobbyInvite += SteamMatchmaking_OnLobbyInvite;
SteamMatchmaking.OnLobbyGameCreated += SteamMatchmaking_OnLobbyGameCreated;
SteamFriends.OnGameLobbyJoinRequested += SteamFriends_OnGameLobbyJoinRequested;
}
}
private void OnDisable()
{
Application.logMessageReceived -= LogCallback;
if (!disableSteam)
{
Debug.Log("unsubscribing from steam callbacks");
SteamMatchmaking.OnLobbyCreated -= SteamMatchmaking_OnLobbyCreated;
SteamMatchmaking.OnLobbyMemberJoined -= SteamMatchmaking_OnLobbyMemberJoined;
SteamMatchmaking.OnLobbyMemberLeave -= SteamMatchmaking_OnLobbyMemberLeave;
SteamMatchmaking.OnLobbyInvite -= SteamMatchmaking_OnLobbyInvite;
SteamMatchmaking.OnLobbyGameCreated -= SteamMatchmaking_OnLobbyGameCreated;
SteamFriends.OnGameLobbyJoinRequested -= SteamFriends_OnGameLobbyJoinRequested;
}
}
public void SetSteamFriendGrouping(string groupName, int groupSize, string steamDisplay)
{
_ = disableSteam;
}
private void Singleton_OnClientDisconnectCallback(ulong clientId)
{
Debug.Log("Disconnect callback called");
Debug.Log($"Is server: {NetworkManager.Singleton.IsServer}; ishost: {NetworkManager.Singleton.IsHost}; isConnectedClient: {NetworkManager.Singleton.IsConnectedClient}");
if (NetworkManager.Singleton == null)
{
Debug.Log("Network singleton is null!");
return;
}
if (clientId == NetworkManager.Singleton.LocalClientId && localClientWaitingForApproval)
{
OnLocalClientConnectionDisapproved(clientId);
return;
}
if (NetworkManager.Singleton.IsServer)
{
Debug.Log($"Disconnect callback called in gamenetworkmanager; disconnecting clientId: {clientId}");
if (StartOfRound.Instance != null && !StartOfRound.Instance.ClientPlayerList.ContainsKey(clientId))
{
Debug.Log("A Player disconnected but they were not in clientplayerlist");
return;
}
if (clientId == NetworkManager.Singleton.LocalClientId)
{
Debug.Log("Disconnect callback called for local client; ignoring.");
return;
}
if (NetworkManager.Singleton.IsServer)
{
connectedPlayers--;
}
}
if (StartOfRound.Instance != null)
{
StartOfRound.Instance.OnClientDisconnect(clientId);
}
Debug.Log("Disconnect callback from networkmanager in gamenetworkmanager");
}
private void OnLocalClientConnectionDisapproved(ulong clientId)
{
localClientWaitingForApproval = false;
Debug.Log($"Local client connection denied; clientId: {clientId}; reason: {disconnectionReasonMessage.ToString()}");
if (!string.IsNullOrEmpty(NetworkManager.Singleton.DisconnectReason))
{
disconnectionReasonMessage = NetworkManager.Singleton.DisconnectReason;
}
UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false);
LeaveCurrentSteamLobby();
SetInstanceValuesBackToDefault();
if (NetworkManager.Singleton.IsConnectedClient)
{
Debug.Log("Calling shutdown(true) on server in OnLocalClientDisapproved");
NetworkManager.Singleton.Shutdown(discardMessageQueue: true);
}
}
private void Singleton_OnClientConnectedCallback(ulong clientId)
{
if (!(NetworkManager.Singleton == null))
{
Debug.Log("Client connected callback in gamenetworkmanager");
if (NetworkManager.Singleton.IsServer)
{
connectedPlayers++;
}
if (StartOfRound.Instance != null)
{
StartOfRound.Instance.OnClientConnect(clientId);
}
}
}
public void SubscribeToConnectionCallbacks()
{
if (!hasSubscribedToConnectionCallbacks)
{
NetworkManager.Singleton.OnClientConnectedCallback += Instance.Singleton_OnClientConnectedCallback;
NetworkManager.Singleton.OnClientDisconnectCallback += Instance.Singleton_OnClientDisconnectCallback;
hasSubscribedToConnectionCallbacks = true;
}
}
public void SteamFriends_OnGameLobbyJoinRequested(Lobby lobby, SteamId id)
{
if (UnityEngine.Object.FindObjectOfType<MenuManager>() == null)
{
return;
}
if (!Instance.currentLobby.HasValue)
{
Debug.Log("JOIN REQUESTED through steam invite");
Debug.Log($"lobby id: {lobby.Id}");
LobbySlot.JoinLobbyAfterVerifying(lobby, lobby.Id);
return;
}
Debug.Log("Attempted to join by Steam invite request, but already in a lobby.");
MenuManager menuManager = UnityEngine.Object.FindObjectOfType<MenuManager>();
if (menuManager != null)
{
menuManager.DisplayMenuNotification("You are already in a lobby!", "Back");
}
Instance.currentLobby.Value.Leave();
Instance.currentLobby = null;
}
public bool LobbyDataIsJoinable(Lobby lobby)
{
string data = lobby.GetData("vers");
if (data != Instance.gameVersionNum.ToString())
{
Debug.Log($"Lobby join denied! Attempted to join vers.{data} lobby id: {lobby.Id}");
UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false, RoomEnter.DoesntExist, $"The server host is playing on version {data} while you are on version {Instance.gameVersionNum}.");
return false;
}
if (lobby.GetData("joinable") == "false")
{
Debug.Log("Lobby join denied! Host lobby is not joinable");
UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false, RoomEnter.DoesntExist, "The server host has already landed their ship, or they are still loading in.");
return false;
}
if (lobby.MemberCount >= 4 || lobby.MemberCount < 1)
{
Debug.Log($"Lobby join denied! Too many members in lobby! {lobby.Id}");
UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false, RoomEnter.Full, "The server is full!");
return false;
}
Debug.Log($"Lobby join accepted! Lobby id {lobby.Id} is OK");
return true;
}
public IEnumerator TimeOutLobbyRefresh()
{
yield return new WaitForSeconds(7f);
waitingForLobbyDataRefresh = false;
UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false, RoomEnter.Error, "Error! Could not get the lobby data. Are you offline?");
SteamMatchmaking.OnLobbyDataChanged -= LobbySlot.OnLobbyDataRefresh;
}
private void SteamMatchmaking_OnLobbyMemberJoined(Lobby lobby, Friend friend)
{
}
private void SteamMatchmaking_OnLobbyMemberLeave(Lobby lobby, Friend friend)
{
}
private void SteamMatchmaking_OnLobbyGameCreated(Lobby lobby, uint arg2, ushort arg3, SteamId arg4)
{
}
private void SteamMatchmaking_OnLobbyInvite(Friend friend, Lobby lobby)
{
Debug.Log($"You got invited by {friend.Name} to join {lobby.Id}");
}
private void SteamMatchmaking_OnLobbyCreated(Result result, Lobby lobby)
{
if (result != Result.OK)
{
Debug.LogError($"Lobby could not be created! {result}", this);
}
lobby.SetData("name", lobbyHostSettings.lobbyName.ToString());
lobby.SetData("vers", Instance.gameVersionNum.ToString());
if (lobbyHostSettings.isLobbyPublic)
{
lobby.SetPublic();
}
else
{
lobby.SetPrivate();
lobby.SetFriendsOnly();
}
lobby.SetJoinable(b: false);
Instance.currentLobby = lobby;
steamLobbyName = lobby.GetData("name");
Debug.Log("Lobby has been created");
}
public void LeaveLobbyAtGameStart()
{
if (!Instance.currentLobby.HasValue)
{
Debug.Log("Current lobby is null. (Attempted to close lobby at game start)");
}
else
{
LeaveCurrentSteamLobby();
}
}
public void SetLobbyJoinable(bool joinable)
{
if (!Instance.currentLobby.HasValue)
{
Debug.Log($"Current lobby is null. (Attempted to set lobby joinable {joinable}.)");
}
else
{
Instance.currentLobby.Value.SetJoinable(joinable);
}
}
public void SetCurrentLobbyNull()
{
currentLobby = null;
}
private void OnApplicationQuit()
{
ES3.Save("SelectedFile", saveFileNum, "LCGeneralSaveData");
Disconnect();
}
public void Disconnect()
{
if (!isDisconnecting)
{
isDisconnecting = true;
if (isHostingGame)
{
disallowConnection = true;
}
StartDisconnect();
SaveGame();
if (NetworkManager.Singleton == null)
{
Debug.Log("Server is not active; quitting to main menu");
ResetGameValuesToDefault();
SceneManager.LoadScene("MainMenu");
}
else
{
StartCoroutine(DisconnectProcess());
}
}
}
private IEnumerator DisconnectProcess()
{
Debug.Log($"Shutting down and disconnecting from server. Is host?: {NetworkManager.Singleton.IsServer}");
NetworkManager.Singleton.Shutdown();
yield return new WaitUntil(() => !NetworkManager.Singleton.ShutdownInProgress);
ResetGameValuesToDefault();
SceneManager.LoadScene("MainMenu");
}
private void StartDisconnect()
{
if (!disableSteam)
{
Debug.Log("Leaving current lobby");
LeaveCurrentSteamLobby();
steamLobbyName = SteamClient.Name;
}
Debug.Log("Disconnecting and setting networkobjects to destroy with owner");
NetworkObject[] array = UnityEngine.Object.FindObjectsOfType<NetworkObject>(includeInactive: true);
for (int i = 0; i < array.Length; i++)
{
array[i].DontDestroyWithOwner = false;
}
Terminal terminal = UnityEngine.Object.FindObjectOfType<Terminal>();
if (terminal != null && terminal.displayingSteamKeyboard)
{
SteamUtils.OnGamepadTextInputDismissed -= terminal.OnGamepadTextInputDismissed_t;
}
}
public void SaveGame()
{
SaveLocalPlayerValues();
SaveGameValues();
}
private void ResetGameValuesToDefault()
{
ResetUnlockablesListValues();
if (StartOfRound.Instance != null)
{
StartOfRound.Instance.OnLocalDisconnect();
}
SetInstanceValuesBackToDefault();
}
public void ResetUnlockablesListValues()
{
if (!(StartOfRound.Instance != null))
{
return;
}
Debug.Log("Resetting unlockables list!");
List<UnlockableItem> unlockables = StartOfRound.Instance.unlockablesList.unlockables;
for (int i = 0; i < unlockables.Count; i++)
{
unlockables[i].hasBeenUnlockedByPlayer = false;
if (unlockables[i].unlockableType == 1)
{
unlockables[i].placedPosition = Vector3.zero;
unlockables[i].placedRotation = Vector3.zero;
unlockables[i].hasBeenMoved = false;
unlockables[i].inStorage = false;
}
}
}
private void SaveLocalPlayerValues()
{
try
{
if (HUDManager.Instance != null)
{
if (HUDManager.Instance.setTutorialArrow)
{
ES3.Save("FinishedShockMinigame", PatcherTool.finishedShockMinigame, "LCGeneralSaveData");
}
ES3.Save("PlayerLevel", HUDManager.Instance.localPlayerLevel, "LCGeneralSaveData");
ES3.Save("PlayerXPNum", HUDManager.Instance.localPlayerXP, "LCGeneralSaveData");
}
}
catch (Exception arg)
{
Debug.Log($"ERROR occured while saving local player values!: {arg}");
}
}
public void ResetSavedGameValues()
{
if (!isHostingGame)
{
return;
}
TimeOfDay timeOfDay = UnityEngine.Object.FindObjectOfType<TimeOfDay>();
if (timeOfDay != null)
{
ES3.Save("GlobalTime", 100, currentSaveFileName);
ES3.Save("QuotaFulfilled", 0, currentSaveFileName);
ES3.Save("QuotasPassed", 0, currentSaveFileName);
ES3.Save("ProfitQuota", timeOfDay.quotaVariables.startingQuota, currentSaveFileName);
ES3.Save("DeadlineTime", (int)(timeOfDay.totalTime * (float)timeOfDay.quotaVariables.deadlineDaysAmount), currentSaveFileName);
ES3.Save("GroupCredits", timeOfDay.quotaVariables.startingCredits, currentSaveFileName);
}
ES3.Save("CurrentPlanetID", 0, currentSaveFileName);
StartOfRound startOfRound = UnityEngine.Object.FindObjectOfType<StartOfRound>();
if (!(startOfRound != null))
{
return;
}
ES3.DeleteKey("UnlockedShipObjects", Instance.currentSaveFileName);
for (int i = 0; i < startOfRound.unlockablesList.unlockables.Count; i++)
{
if (startOfRound.unlockablesList.unlockables[i].unlockableType == 1)
{
ES3.DeleteKey("ShipUnlockMoved_" + startOfRound.unlockablesList.unlockables[i].unlockableName, currentSaveFileName);
ES3.DeleteKey("ShipUnlockStored_" + startOfRound.unlockablesList.unlockables[i].unlockableName, currentSaveFileName);
ES3.DeleteKey("ShipUnlockPos_" + startOfRound.unlockablesList.unlockables[i].unlockableName, currentSaveFileName);
ES3.DeleteKey("ShipUnlockRot_" + startOfRound.unlockablesList.unlockables[i].unlockableName, currentSaveFileName);
}
}
ResetUnlockablesListValues();
ES3.Save("RandomSeed", startOfRound.randomMapSeed + 1, currentSaveFileName);
ES3.Save("Stats_DaysSpent", 0, currentSaveFileName);
ES3.Save("Stats_Deaths", 0, currentSaveFileName);
ES3.Save("Stats_ValueCollected", 0, currentSaveFileName);
ES3.Save("Stats_StepsTaken", 0, currentSaveFileName);
}
private void SaveGameValues()
{
if (!isHostingGame)
{
return;
}
if (!ES3.KeyExists("FileGameVers", currentSaveFileName))
{
ES3.Save("FileGameVers", Instance.gameVersionNum, currentSaveFileName);
}
if (!StartOfRound.Instance.inShipPhase)
{
return;
}
try
{
TimeOfDay timeOfDay = UnityEngine.Object.FindObjectOfType<TimeOfDay>();
if (timeOfDay != null)
{
ES3.Save("QuotaFulfilled", timeOfDay.quotaFulfilled, currentSaveFileName);
ES3.Save("QuotasPassed", timeOfDay.timesFulfilledQuota, currentSaveFileName);
ES3.Save("ProfitQuota", timeOfDay.profitQuota, currentSaveFileName);
}
ES3.Save("CurrentPlanetID", StartOfRound.Instance.currentLevelID, currentSaveFileName);
Terminal terminal = UnityEngine.Object.FindObjectOfType<Terminal>();
if (terminal != null)
{
ES3.Save("GroupCredits", terminal.groupCredits, currentSaveFileName);
if (terminal.unlockedStoryLogs.Count > 0)
{
ES3.Save("StoryLogs", terminal.unlockedStoryLogs.ToArray(), currentSaveFileName);
}
if (terminal.scannedEnemyIDs.Count > 0)
{
ES3.Save("EnemyScans", terminal.scannedEnemyIDs.ToArray(), currentSaveFileName);
}
}
StartOfRound startOfRound = UnityEngine.Object.FindObjectOfType<StartOfRound>();
if (startOfRound != null)
{
List<int> list = new List<int>();
for (int i = 0; i < startOfRound.unlockablesList.unlockables.Count; i++)
{
if (startOfRound.unlockablesList.unlockables[i].hasBeenUnlockedByPlayer || startOfRound.unlockablesList.unlockables[i].hasBeenMoved || startOfRound.unlockablesList.unlockables[i].inStorage)
{
list.Add(i);
}
if (startOfRound.unlockablesList.unlockables[i].IsPlaceable)
{
if (startOfRound.unlockablesList.unlockables[i].canBeStored)
{
ES3.Save("ShipUnlockStored_" + startOfRound.unlockablesList.unlockables[i].unlockableName, startOfRound.unlockablesList.unlockables[i].inStorage, currentSaveFileName);
}
if (startOfRound.unlockablesList.unlockables[i].hasBeenMoved)
{
ES3.Save("ShipUnlockMoved_" + startOfRound.unlockablesList.unlockables[i].unlockableName, startOfRound.unlockablesList.unlockables[i].hasBeenMoved, currentSaveFileName);
ES3.Save("ShipUnlockPos_" + startOfRound.unlockablesList.unlockables[i].unlockableName, startOfRound.unlockablesList.unlockables[i].placedPosition, currentSaveFileName);
ES3.Save("ShipUnlockRot_" + startOfRound.unlockablesList.unlockables[i].unlockableName, startOfRound.unlockablesList.unlockables[i].placedRotation, currentSaveFileName);
}
}
}
if (list.Count > 0)
{
ES3.Save("UnlockedShipObjects", list.ToArray(), currentSaveFileName);
}
ES3.Save("DeadlineTime", (int)Mathf.Clamp(timeOfDay.timeUntilDeadline, 0f, 99999f), currentSaveFileName);
ES3.Save("RandomSeed", startOfRound.randomMapSeed, currentSaveFileName);
ES3.Save("Stats_DaysSpent", startOfRound.gameStats.daysSpent, currentSaveFileName);
ES3.Save("Stats_Deaths", startOfRound.gameStats.deaths, currentSaveFileName);
ES3.Save("Stats_ValueCollected", startOfRound.gameStats.scrapValueCollected, currentSaveFileName);
ES3.Save("Stats_StepsTaken", startOfRound.gameStats.allStepsTaken, currentSaveFileName);
}
SaveItemsInShip();
}
catch (Exception arg)
{
Debug.LogError($"Error while trying to save game values when disconnecting as host: {arg}");
}
}
private void SaveItemsInShip()
{
GrabbableObject[] array = UnityEngine.Object.FindObjectsByType<GrabbableObject>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);
if (array == null || array.Length == 0)
{
ES3.DeleteKey("shipGrabbableItemIDs", currentSaveFileName);
ES3.DeleteKey("shipGrabbableItemPos", currentSaveFileName);
ES3.DeleteKey("shipScrapValues", currentSaveFileName);
return;
}
List<int> list = new List<int>();
List<Vector3> list2 = new List<Vector3>();
List<int> list3 = new List<int>();
for (int i = 0; i < array.Length && i <= StartOfRound.Instance.maxShipItemCapacity; i++)
{
if (!StartOfRound.Instance.allItemsList.itemsList.Contains(array[i].itemProperties))
{
continue;
}
if (array[i].itemProperties.spawnPrefab == null)
{
Debug.LogError("Item '" + array[i].itemProperties.itemName + "' has no spawn prefab set!");
}
else
{
if (array[i].itemUsedUp)
{
continue;
}
for (int j = 0; j < StartOfRound.Instance.allItemsList.itemsList.Count; j++)
{
if (StartOfRound.Instance.allItemsList.itemsList[j] == array[i].itemProperties)
{
list.Add(j);
list2.Add(array[i].transform.position);
break;
}
}
if (array[i].itemProperties.isScrap)
{
list3.Add(array[i].scrapValue);
}
}
}
if (list.Count <= 0)
{
Debug.Log("Got no ship grabbable items to save.");
return;
}
ES3.Save("shipGrabbableItemPos", list2.ToArray(), currentSaveFileName);
ES3.Save("shipGrabbableItemIDs", list.ToArray(), currentSaveFileName);
if (list3.Count > 0)
{
ES3.Save("shipScrapValues", list3.ToArray(), currentSaveFileName);
}
}
private void ConvertUnsellableItemsToCredits()
{
if (!StartOfRound.Instance.inShipPhase)
{
Debug.Log("Players disconnected, but they were not in ship phase so they can't be reimbursed for their items.");
ES3.Save("Reimburse", 0, currentSaveFileName);
return;
}
int num = 0;
GrabbableObject[] array = UnityEngine.Object.FindObjectsOfType<GrabbableObject>();
for (int i = 0; i < array.Length; i++)
{
if (!array[i].itemProperties.isScrap && !array[i].itemUsedUp)
{
num += array[i].itemProperties.creditsWorth;
}
}
Terminal terminal = UnityEngine.Object.FindObjectOfType<Terminal>();
for (int j = 0; j < terminal.orderedItemsFromTerminal.Count; j++)
{
num += terminal.buyableItemsList[terminal.orderedItemsFromTerminal[j]].creditsWorth;
}
ES3.Save("Reimburse", num, currentSaveFileName);
}
private void SetInstanceValuesBackToDefault()
{
isDisconnecting = false;
disallowConnection = false;
connectedPlayers = 0;
localPlayerController = null;
gameHasStarted = false;
if (SoundManager.Instance != null)
{
SoundManager.Instance.ResetValues();
}
if (hasSubscribedToConnectionCallbacks && NetworkManager.Singleton != null)
{
NetworkManager.Singleton.OnClientConnectedCallback -= Singleton_OnClientConnectedCallback;
NetworkManager.Singleton.OnClientDisconnectCallback -= Singleton_OnClientDisconnectCallback;
hasSubscribedToConnectionCallbacks = false;
}
}
public void InviteFriendsUI()
{
SteamFriends.OpenGameInviteOverlay(Instance.currentLobby.Value.Id);
}
public async void StartHost()
{
if (!UnityEngine.Object.FindObjectOfType<MenuManager>())
{
Debug.Log("Menu manager script is not present in scene; unable to start host");
return;
}
if (Instance.currentLobby.HasValue)
{
Debug.Log("Tried starting host but currentLobby is not null! This should not happen. Leaving currentLobby and setting null.");
LeaveCurrentSteamLobby();
}
if (!disableSteam)
{
GameNetworkManager instance = Instance;
instance.currentLobby = await SteamMatchmaking.CreateLobbyAsync(4);
}
UnityEngine.Object.FindObjectOfType<MenuManager>().StartHosting();
SubscribeToConnectionCallbacks();
isHostingGame = true;
connectedPlayers = 1;
}
public async void JoinLobby(Lobby lobby, SteamId id)
{
Debug.Log($"lobby.id: {lobby.Id}");
Debug.Log($"id: {id}");
if (UnityEngine.Object.FindObjectOfType<MenuManager>() == null)
{
return;
}
if (!Instance.currentLobby.HasValue)
{
Instance.currentLobby = lobby;
steamLobbyName = lobby.GetData("name");
if (await lobby.Join() == RoomEnter.Success)
{
Debug.Log("Successfully joined steam lobby.");
Debug.Log($"AA {Instance.currentLobby.Value.Id}");
Debug.Log($"BB {id}");
Instance.StartClient(lobby.Owner.Id);
}
else
{
Debug.Log("Failed to join steam lobby.");
LeaveCurrentSteamLobby();
steamLobbyName = SteamClient.Name;
UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false, RoomEnter.Error, "The host has not loaded or has already landed their ship.");
}
}
else
{
Debug.Log("Lobby error!: Attempted to join, but we are already in a Steam lobby. We should not be in a lobby while in the menu!");
LeaveCurrentSteamLobby();
}
}
public void LeaveCurrentSteamLobby()
{
try
{
if (Instance.currentLobby.HasValue)
{
Instance.currentLobby.Value.Leave();
Instance.currentLobby = null;
}
}
catch (Exception arg)
{
Debug.Log($"Error caught while attempting to leave current lobby!: {arg}");
}
}
public void SetConnectionDataBeforeConnecting()
{
}
public void StartClient(SteamId id)
{
Debug.Log($"CC {id}");
transport.targetSteamId = id;
SetConnectionDataBeforeConnecting();
if (NetworkManager.Singleton.StartClient())
{
Debug.Log("started client!");
SubscribeToConnectionCallbacks();
UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: true);
return;
}
Debug.Log("Joined steam lobby successfully, but connection failed");
UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false);
if (Instance.currentLobby.HasValue)
{
Debug.Log("Leaving steam lobby");
Instance.currentLobby.Value.Leave();
Instance.currentLobby = null;
steamLobbyName = SteamClient.Name;
}
SetInstanceValuesBackToDefault();
}
private IEnumerator delayStartClient()
{
yield return new WaitForSeconds(1f);
if (NetworkManager.Singleton.StartClient())
{
Debug.Log("started client!");
Debug.Log($"Are we connected client: {NetworkManager.Singleton.IsConnectedClient}");
if (NetworkManager.Singleton != null)
{
Debug.Log("NetworkManager is not null");
}
Debug.Log($"Are we connected client: {NetworkManager.Singleton.IsConnectedClient}");
Debug.Log($"Are we host: {NetworkManager.Singleton.IsHost}");
yield return null;
if (NetworkManager.Singleton != null)
{
Debug.Log("NetworkManager is not null");
}
Debug.Log($"is networkmanager listening: {NetworkManager.Singleton.IsListening}");
Debug.Log("connected host name: " + NetworkManager.Singleton.ConnectedHostname);
}
}
}