using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Dissonance;
using Dissonance.Integrations.Unity_NFGO;
using GameNetcodeStuff;
using Steamworks;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;

public class StartOfRound : NetworkBehaviour
{
	public bool shouldApproveConnection;

	public bool allowLocalPlayerDeath = true;

	[Space(3f)]
	public int connectedPlayersAmount;

	public int thisClientPlayerId;

	public List<ulong> fullyLoadedPlayers = new List<ulong>(4);

	public int livingPlayers = 4;

	private bool mostRecentlyJoinedClient;

	public bool allPlayersDead;

	public Dictionary<ulong, int> ClientPlayerList = new Dictionary<ulong, int>();

	public List<ulong> KickedClientIds = new List<ulong>();

	public int daysPlayersSurvivedInARow;

	[Space(5f)]
	private bool hasHostSpawned;

	public bool inShipPhase = true;

	public float timeSinceRoundStarted;

	public bool shipIsLeaving;

	public bool displayedLevelResults;

	public bool newGameIsLoading;

	private int playersRevived;

	public EndOfGameStats gameStats;

	private bool localPlayerWasMostProfitableThisRound;

	[Header("Important objects")]
	public Camera spectateCamera;

	public AudioListener audioListener;

	[HideInInspector]
	public bool overrideSpectateCamera;

	public GameObject[] allPlayerObjects;

	public PlayerControllerB[] allPlayerScripts;

	public Transform[] playerSpawnPositions;

	public Transform outsideShipSpawnPosition;

	public Transform notSpawnedPosition;

	public Transform propsContainer;

	public Transform elevatorTransform;

	public Transform playersContainer;

	public PlayerControllerB localPlayerController;

	public List<PlayerControllerB> OtherClients = new List<PlayerControllerB>();

	[Space(3f)]
	public UnlockablesList unlockablesList;

	public AudioClip changeSuitSFX;

	public GameObject suitPrefab;

	public int suitsPlaced;

	public Transform rightmostSuitPosition;

	[Space(5f)]
	public GameObject playerPrefab;

	public GameObject ragdollGrabbableObjectPrefab;

	public List<GameObject> playerRagdolls = new List<GameObject>();

	public GameObject playerBloodPrefab;

	public Transform bloodObjectsContainer;

	public Camera introCamera;

	public Camera activeCamera;

	public SimpleEvent CameraSwitchEvent = new SimpleEvent();

	public GameObject testRoom;

	public GameObject testRoomPrefab;

	public Transform testRoomSpawnPosition;

	public bool localClientHasControl;

	public RuntimeAnimatorController localClientAnimatorController;

	public RuntimeAnimatorController otherClientsAnimatorController;

	public int playersMask = 8;

	public int collidersAndRoomMask = 2304;

	public int collidersAndRoomMaskAndPlayers = 2312;

	public int collidersAndRoomMaskAndDefault = 2305;

	public int collidersRoomMaskDefaultAndPlayers = 2313;

	public int collidersRoomDefaultAndFoliage = 3329;

	public int allPlayersCollideWithMask = -4493385;

	public int walkableSurfacesMask = 268437769;

	[Header("Physics")]
	public Collider[] PlayerPhysicsColliders;

	[Header("Ship Animations")]
	public NetworkObject shipAnimatorObject;

	public Animator shipAnimator;

	public AudioSource shipAmbianceAudio;

	public AudioSource ship3DAudio;

	public AudioClip shipDepartSFX;

	public AudioClip shipArriveSFX;

	public AudioSource shipDoorAudioSource;

	public AudioSource speakerAudioSource;

	public AudioClip suckedIntoSpaceSFX;

	public AudioClip airPressureSFX;

	public AudioClip[] shipCreakSFX;

	public AudioClip alarmSFX;

	public AudioClip firedVoiceSFX;

	public AudioClip openingHangarDoorAudio;

	public AudioClip allPlayersDeadAudio;

	public AudioClip shipIntroSpeechSFX;

	public AudioClip disableSpeakerSFX;

	public AudioClip zeroDaysLeftAlertSFX;

	public bool shipLeftAutomatically;

	public DialogueSegment[] openingDoorDialogue;

	public DialogueSegment[] gameOverDialogue;

	public DialogueSegment[] shipLeavingOnMidnightDialogue;

	public bool shipDoorsEnabled;

	public bool shipHasLanded;

	public Animator shipDoorsAnimator;

	public bool hangarDoorsClosed = true;

	private Coroutine shipTravelCoroutine;

	public ShipLights shipRoomLights;

	public AnimatedObjectTrigger closetLeftDoor;

	public AnimatedObjectTrigger closetRightDoor;

	public GameObject starSphereObject;

	public Dictionary<int, GameObject> SpawnedShipUnlockables = new Dictionary<int, GameObject>();

	public Transform gameOverCameraHandle;

	public Transform freeCinematicCameraTurnCompass;

	public Camera freeCinematicCamera;

	[Header("Players fired animation")]
	public bool firingPlayersCutsceneRunning;

	public bool suckingPlayersOutOfShip;

	private bool choseRandomFlyDirForPlayer;

	private Vector3 randomFlyDir = Vector3.zero;

	public float suckingPower;

	public bool suckingFurnitureOutOfShip;

	public Transform middleOfShipNode;

	public Transform shipDoorNode;

	public Transform middleOfSpaceNode;

	public Transform moveAwayFromShipNode;

	[Header("Level selection")]
	public GameObject currentPlanetPrefab;

	public Animator currentPlanetAnimator;

	public Animator outerSpaceSunAnimator;

	public Transform planetContainer;

	public SelectableLevel[] levels;

	public SelectableLevel currentLevel;

	public int currentLevelID;

	public bool isChallengeFile;

	public bool hasSubmittedChallengeRank;

	public int defaultPlanet;

	public bool travellingToNewLevel;

	public AnimationCurve planetsWeatherRandomCurve;

	public int maxShipItemCapacity = 45;

	public int currentShipItemCount;

	[Header("Ship Monitors")]
	public TextMeshProUGUI screenLevelDescription;

	public VideoPlayer screenLevelVideoReel;

	public TextMeshProUGUI mapScreenPlayerName;

	public ManualCameraRenderer mapScreen;

	public GameObject objectCodePrefab;

	public GameObject itemRadarIconPrefab;

	[Space(5f)]
	public Image deadlineMonitorBGImage;

	public Image profitQuotaMonitorBGImage;

	public TextMeshProUGUI deadlineMonitorText;

	public TextMeshProUGUI profitQuotaMonitorText;

	public GameObject upperMonitorsCanvas;

	public Canvas radarCanvas;

	[Header("Randomization")]
	public int randomMapSeed;

	public bool overrideRandomSeed;

	public int overrideSeedNumber;

	public AnimationCurve objectFallToGroundCurve;

	public AnimationCurve objectFallToGroundCurveNoBounce;

	public AnimationCurve playerSinkingCurve;

	[Header("Voice chat")]
	public DissonanceComms voiceChatModule;

	public float averageVoiceAmplitude;

	public int movingAverageLength = 20;

	public int averageCount;

	private float voiceChatNoiseCooldown;

	public bool updatedPlayerVoiceEffectsThisFrame;

	[Header("Player Audios")]
	public AudioMixerGroup playersVoiceMixerGroup;

	public FootstepSurface[] footstepSurfaces;

	public string[] naturalSurfaceTags;

	public AudioClip[] statusEffectClips;

	public AudioClip HUDSystemAlertSFX;

	public AudioClip playerJumpSFX;

	public AudioClip playerHitGroundSoft;

	public AudioClip playerHitGroundHard;

	public AudioClip damageSFX;

	public AudioClip fallDamageSFX;

	public AudioClip bloodGoreSFX;

	[Space(5f)]
	public float drowningTimer;

	[HideInInspector]
	public bool playedDrowningSFX;

	public AudioClip[] bodyCollisionSFX;

	public AudioClip playerFallDeath;

	public AudioClip hitPlayerSFX;

	private Coroutine fadeVolumeCoroutine;

	public List<DecalProjector> snowFootprintsPooledObjects = new List<DecalProjector>();

	public GameObject footprintDecal;

	public int currentFootprintIndex;

	public GameObject explosionPrefab;

	public float fearLevel;

	public bool fearLevelIncreasing;

	[Header("Company building game loop")]
	public float companyBuyingRate = 1f;

	public int hoursSinceLastCompanyVisit;

	public AudioClip companyVisitMusic;

	public bool localPlayerUsingController;

	private bool subscribedToConnectionApproval;

	public Collider shipBounds;

	public Collider shipInnerRoomBounds;

	private Coroutine updateVoiceEffectsCoroutine;

	public ReverbPreset shipReverb;

	public AnimationCurve drunknessSpeedEffect;

	public AnimationCurve drunknessSideEffect;

	private float updatePlayerVoiceInterval;

	private bool subscribedToConnectionCallbacks;

	public Volume blackSkyVolume;

	[Space(5f)]
	public AllItemsList allItemsList;

	public InteractEvent playerTeleportedEvent;

	[Space(3f)]
	public string[] randomNames;

	public float timeAtStartOfRun;

	private int allScrapValueCollected;

	public float playerLookMagnitudeThisFrame;

	public float timeAtMakingLastPersonalMovement;

	public Transform[] insideShipPositions;

	public static StartOfRound Instance { get; private set; }

	public void InstantiateFootprintsPooledObjects()
	{
		int num = 250;
		for (int i = 0; i < num; i++)
		{
			GameObject gameObject = UnityEngine.Object.Instantiate(footprintDecal, bloodObjectsContainer);
			snowFootprintsPooledObjects.Add(gameObject.GetComponent<DecalProjector>());
		}
	}

	private void ResetPooledObjects(bool destroy = false)
	{
		for (int i = 0; i < snowFootprintsPooledObjects.Count; i++)
		{
			snowFootprintsPooledObjects[i].enabled = false;
		}
		for (int num = SprayPaintItem.sprayPaintDecals.Count - 1; num >= 0; num--)
		{
			if (destroy || !(SprayPaintItem.sprayPaintDecals[num] != null) || !SprayPaintItem.sprayPaintDecals[num].transform.IsChildOf(elevatorTransform))
			{
				UnityEngine.Object.Destroy(SprayPaintItem.sprayPaintDecals[num]);
				SprayPaintItem.sprayPaintDecals.RemoveAt(num);
			}
		}
	}

	private void Awake()
	{
		if (Instance == null)
		{
			Instance = this;
			timeAtStartOfRun = Time.realtimeSinceStartup;
		}
		else
		{
			UnityEngine.Object.Destroy(Instance.gameObject);
			Instance = this;
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void PlayerLoadedServerRpc(ulong clientId)
	{
		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(4249638645u, serverRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, clientId);
				__endSendServerRpc(ref bufferWriter, 4249638645u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				fullyLoadedPlayers.Add(clientId);
				PlayerLoadedClientRpc(clientId);
			}
		}
	}

	[ClientRpc]
	private void PlayerLoadedClientRpc(ulong clientId)
	{
		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(462348217u, clientRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, clientId);
				__endSendClientRpc(ref bufferWriter, 462348217u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsServer)
			{
				fullyLoadedPlayers.Add(clientId);
			}
		}
	}

	[ClientRpc]
	private void ResetPlayersLoadedValueClientRpc(bool landingShip = false)
	{
		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(161788012u, clientRpcParams, RpcDelivery.Reliable);
			bufferWriter.WriteValueSafe(in landingShip, default(FastBufferWriter.ForPrimitives));
			__endSendClientRpc(ref bufferWriter, 161788012u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost) || base.IsServer)
		{
			return;
		}
		fullyLoadedPlayers.Clear();
		if (landingShip)
		{
			if (currentPlanetAnimator != null)
			{
				currentPlanetAnimator.SetTrigger("LandOnPlanet");
			}
			UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.interactable = false;
			UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.disabledHoverTip = "[Wait for ship to land]";
		}
	}

	private void SceneManager_OnLoadComplete1(ulong clientId, string sceneName, LoadSceneMode loadSceneMode)
	{
		DisableSpatializationOnAllAudio();
		if (sceneName == currentLevel.sceneName)
		{
			if (!shipDoorsEnabled)
			{
				HUDManager.Instance.loadingText.enabled = true;
				HUDManager.Instance.loadingDarkenScreen.enabled = true;
			}
			HUDManager.Instance.loadingText.text = "Waiting for crew...";
		}
		ClientPlayerList.TryGetValue(clientId, out var value);
		if (value == 0 || !base.IsServer)
		{
			PlayerLoadedServerRpc(clientId);
		}
	}

	private void SceneManager_OnUnloadComplete(ulong clientId, string sceneName)
	{
		if (sceneName == currentLevel.sceneName)
		{
			if (currentPlanetPrefab != null)
			{
				currentPlanetPrefab.SetActive(value: true);
				outerSpaceSunAnimator.gameObject.SetActive(value: true);
				currentPlanetAnimator.SetTrigger("LeavePlanet");
			}
			ClientPlayerList.TryGetValue(clientId, out var value);
			if (value == 0 || !base.IsServer)
			{
				PlayerLoadedServerRpc(clientId);
			}
		}
	}

	private void SceneManager_OnLoad(ulong clientId, string sceneName, LoadSceneMode loadSceneMode, AsyncOperation asyncOperation)
	{
		Debug.Log("Loading scene");
		Debug.Log("Scene that began loading: " + sceneName);
		if (!(sceneName != "SampleSceneRelay") || !(sceneName != "MainMenu"))
		{
			return;
		}
		if (currentPlanetPrefab != null)
		{
			currentPlanetPrefab.SetActive(value: false);
		}
		outerSpaceSunAnimator.gameObject.SetActive(value: false);
		if (currentLevel.sceneName != sceneName)
		{
			for (int i = 0; i < levels.Length; i++)
			{
				if (levels[i].sceneName == sceneName)
				{
					ChangeLevel(i);
				}
			}
		}
		HUDManager.Instance.loadingText.enabled = true;
		HUDManager.Instance.loadingText.text = "LOADING WORLD...";
	}

	private void OnEnable()
	{
		Debug.Log("Enabling connection callbacks in StartOfRound");
		if (NetworkManager.Singleton != null)
		{
			Debug.Log("Began listening to SceneManager_OnLoadComplete1 on this client");
			try
			{
				NetworkManager.Singleton.SceneManager.OnLoadComplete += SceneManager_OnLoadComplete1;
				NetworkManager.Singleton.SceneManager.OnLoad += SceneManager_OnLoad;
				NetworkManager.Singleton.SceneManager.OnUnloadComplete += SceneManager_OnUnloadComplete;
			}
			catch (Exception arg)
			{
				Debug.LogError($"Error returned when subscribing to scenemanager callbacks!: {arg}");
				GameNetworkManager.Instance.disconnectionReasonMessage = "An error occured when syncing the scene! The host might not have loaded in.";
				GameNetworkManager.Instance.Disconnect();
				return;
			}
			_ = base.IsServer;
		}
		else
		{
			GameNetworkManager.Instance.disconnectionReasonMessage = "Your connection timed out before you could load in. Try again?";
			GameNetworkManager.Instance.Disconnect();
		}
	}

	private void OnDisable()
	{
		Debug.Log("DISABLING connection callbacks in round manager");
		if (NetworkManager.Singleton != null)
		{
			_ = subscribedToConnectionApproval;
		}
	}

	private void Start()
	{
		TimeOfDay.Instance.globalTime = 100f;
		IngamePlayerSettings.Instance.RefreshAndDisplayCurrentMicrophone();
		HUDManager.Instance.SetNearDepthOfFieldEnabled(enabled: true);
		StartCoroutine(StartSpatialVoiceChat());
		NetworkObject[] array = UnityEngine.Object.FindObjectsOfType<NetworkObject>(includeInactive: true);
		for (int i = 0; i < array.Length; i++)
		{
			array[i].DontDestroyWithOwner = true;
		}
		if (base.IsServer)
		{
			SetTimeAndPlanetToSavedSettings();
			LoadUnlockables();
			LoadShipGrabbableItems();
			SetMapScreenInfoToCurrentLevel();
			UnityEngine.Object.FindObjectOfType<Terminal>().RotateShipDecorSelection();
			TimeOfDay timeOfDay = UnityEngine.Object.FindObjectOfType<TimeOfDay>();
			if (currentLevel.planetHasTime && timeOfDay.GetDayPhase(timeOfDay.CalculatePlanetTime(currentLevel) / timeOfDay.totalTime) == DayMode.Midnight)
			{
				UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.disabledHoverTip = "Too late on moon to land!";
				UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.interactable = false;
			}
			else
			{
				UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.interactable = true;
			}
		}
		SwitchMapMonitorPurpose(displayInfo: true);
		DisableSpatializationOnAllAudio();
		SetDiscordStatusDetails();
	}

	private void DisableSpatializationOnAllAudio()
	{
		AudioSource[] array = UnityEngine.Object.FindObjectsOfType<AudioSource>();
		for (int i = 0; i < array.Length; i++)
		{
			array[i].spatialize = false;
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void BuyShipUnlockableServerRpc(int unlockableID, int newGroupCreditsAmount)
	{
		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(3953483456u, serverRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, unlockableID);
			BytePacker.WriteValueBitPacked(bufferWriter, newGroupCreditsAmount);
			__endSendServerRpc(ref bufferWriter, 3953483456u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
		{
			Debug.Log($"Purchasing ship unlockable on host: {unlockableID}");
			if (unlockablesList.unlockables[unlockableID].hasBeenUnlockedByPlayer || newGroupCreditsAmount > UnityEngine.Object.FindObjectOfType<Terminal>().groupCredits)
			{
				Debug.Log("Unlockable was already unlocked! Setting group credits back to server's amount on all clients.");
				BuyShipUnlockableClientRpc(UnityEngine.Object.FindObjectOfType<Terminal>().groupCredits);
			}
			else
			{
				UnityEngine.Object.FindObjectOfType<Terminal>().groupCredits = newGroupCreditsAmount;
				BuyShipUnlockableClientRpc(newGroupCreditsAmount, unlockableID);
				UnlockShipObject(unlockableID);
			}
		}
	}

	[ClientRpc]
	public void BuyShipUnlockableClientRpc(int newGroupCreditsAmount, int unlockableID = -1)
	{
		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(418581783u, clientRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, newGroupCreditsAmount);
			BytePacker.WriteValueBitPacked(bufferWriter, unlockableID);
			__endSendClientRpc(ref bufferWriter, 418581783u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !(NetworkManager.Singleton == null) && !base.NetworkManager.ShutdownInProgress && !base.IsServer)
		{
			if (unlockableID != -1)
			{
				unlockablesList.unlockables[unlockableID].hasBeenUnlockedByPlayer = true;
			}
			UnityEngine.Object.FindObjectOfType<Terminal>().groupCredits = newGroupCreditsAmount;
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void ReturnUnlockableFromStorageServerRpc(int unlockableID)
	{
		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(3380566632u, serverRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, unlockableID);
			__endSendServerRpc(ref bufferWriter, 3380566632u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Server || (!networkManager.IsServer && !networkManager.IsHost) || !unlockablesList.unlockables[unlockableID].inStorage)
		{
			return;
		}
		if (unlockablesList.unlockables[unlockableID].spawnPrefab)
		{
			if (SpawnedShipUnlockables.ContainsKey(unlockableID))
			{
				return;
			}
			PlaceableShipObject[] array = UnityEngine.Object.FindObjectsOfType<PlaceableShipObject>();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].unlockableID == unlockableID)
				{
					return;
				}
			}
			SpawnUnlockable(unlockableID);
		}
		else
		{
			PlaceableShipObject[] array2 = UnityEngine.Object.FindObjectsOfType<PlaceableShipObject>();
			for (int j = 0; j < array2.Length; j++)
			{
				if (array2[j].unlockableID == unlockableID)
				{
					array2[j].parentObject.disableObject = false;
					break;
				}
			}
		}
		unlockablesList.unlockables[unlockableID].inStorage = false;
		ReturnUnlockableFromStorageClientRpc(unlockableID);
	}

	[ClientRpc]
	public void ReturnUnlockableFromStorageClientRpc(int unlockableID)
	{
		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(1076853239u, clientRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, unlockableID);
			__endSendClientRpc(ref bufferWriter, 1076853239u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost) || NetworkManager.Singleton == null || base.NetworkManager.ShutdownInProgress || base.IsServer)
		{
			return;
		}
		unlockablesList.unlockables[unlockableID].inStorage = false;
		PlaceableShipObject[] array = UnityEngine.Object.FindObjectsOfType<PlaceableShipObject>();
		for (int i = 0; i < array.Length; i++)
		{
			if (array[i].unlockableID == unlockableID)
			{
				array[i].parentObject.disableObject = false;
			}
		}
	}

	private void UnlockShipObject(int unlockableID)
	{
		if (!unlockablesList.unlockables[unlockableID].hasBeenUnlockedByPlayer && !unlockablesList.unlockables[unlockableID].alreadyUnlocked)
		{
			Debug.Log($"Set unlockable #{unlockableID}: {unlockablesList.unlockables[unlockableID].unlockableName}, to unlocked!");
			unlockablesList.unlockables[unlockableID].hasBeenUnlockedByPlayer = true;
			SpawnUnlockable(unlockableID);
		}
	}

	private void LoadUnlockables()
	{
		try
		{
			if (ES3.KeyExists("UnlockedShipObjects", GameNetworkManager.Instance.currentSaveFileName))
			{
				int[] array = ES3.Load<int[]>("UnlockedShipObjects", GameNetworkManager.Instance.currentSaveFileName);
				for (int i = 0; i < array.Length; i++)
				{
					if (!unlockablesList.unlockables[array[i]].alreadyUnlocked || unlockablesList.unlockables[array[i]].IsPlaceable)
					{
						if (!unlockablesList.unlockables[array[i]].alreadyUnlocked)
						{
							unlockablesList.unlockables[array[i]].hasBeenUnlockedByPlayer = true;
						}
						if (ES3.KeyExists("ShipUnlockStored_" + unlockablesList.unlockables[array[i]].unlockableName, GameNetworkManager.Instance.currentSaveFileName) && ES3.Load("ShipUnlockStored_" + unlockablesList.unlockables[array[i]].unlockableName, GameNetworkManager.Instance.currentSaveFileName, defaultValue: false))
						{
							unlockablesList.unlockables[array[i]].inStorage = true;
						}
						else
						{
							SpawnUnlockable(array[i]);
						}
					}
				}
				PlaceableShipObject[] array2 = UnityEngine.Object.FindObjectsOfType<PlaceableShipObject>();
				for (int j = 0; j < array2.Length; j++)
				{
					if (!unlockablesList.unlockables[array2[j].unlockableID].spawnPrefab && unlockablesList.unlockables[array2[j].unlockableID].inStorage)
					{
						array2[j].parentObject.disableObject = true;
						Debug.Log("DISABLE OBJECT A");
					}
				}
			}
			for (int k = 0; k < unlockablesList.unlockables.Count; k++)
			{
				if ((k != 0 || !isChallengeFile) && (unlockablesList.unlockables[k].alreadyUnlocked || (unlockablesList.unlockables[k].unlockedInChallengeFile && isChallengeFile)) && !unlockablesList.unlockables[k].IsPlaceable)
				{
					SpawnUnlockable(k);
				}
			}
		}
		catch (Exception arg)
		{
			Debug.LogError($"Error attempting to load ship unlockables on the host: {arg}");
		}
	}

	private void SpawnUnlockable(int unlockableIndex)
	{
		GameObject gameObject = null;
		UnlockableItem unlockableItem = unlockablesList.unlockables[unlockableIndex];
		switch (unlockableItem.unlockableType)
		{
		case 0:
		{
			gameObject = UnityEngine.Object.Instantiate(suitPrefab, rightmostSuitPosition.position + rightmostSuitPosition.forward * 0.18f * suitsPlaced, rightmostSuitPosition.rotation, null);
			gameObject.GetComponent<UnlockableSuit>().syncedSuitID.Value = unlockableIndex;
			gameObject.GetComponent<NetworkObject>().Spawn();
			AutoParentToShip component = gameObject.gameObject.GetComponent<AutoParentToShip>();
			component.overrideOffset = true;
			component.positionOffset = new Vector3(-2.45f, 2.75f, -8.41f) + rightmostSuitPosition.forward * 0.18f * suitsPlaced;
			component.rotationOffset = new Vector3(0f, 90f, 0f);
			SyncSuitsServerRpc();
			suitsPlaced++;
			break;
		}
		case 1:
			if (unlockableItem.spawnPrefab)
			{
				gameObject = UnityEngine.Object.Instantiate(unlockableItem.prefabObject, elevatorTransform.position, Quaternion.identity, null);
			}
			else
			{
				Debug.Log("Placing scene object at saved position: " + unlockablesList.unlockables[unlockableIndex].unlockableName);
				PlaceableShipObject[] array = UnityEngine.Object.FindObjectsOfType<PlaceableShipObject>();
				for (int i = 0; i < array.Length; i++)
				{
					if (array[i].unlockableID == unlockableIndex)
					{
						gameObject = array[i].parentObject.gameObject;
					}
				}
				if (gameObject == null)
				{
					return;
				}
			}
			if (ES3.KeyExists("ShipUnlockMoved_" + unlockableItem.unlockableName, GameNetworkManager.Instance.currentSaveFileName))
			{
				Vector3 vector = ES3.Load("ShipUnlockPos_" + unlockableItem.unlockableName, GameNetworkManager.Instance.currentSaveFileName, Vector3.zero);
				Vector3 placementRotation = ES3.Load("ShipUnlockRot_" + unlockableItem.unlockableName, GameNetworkManager.Instance.currentSaveFileName, Vector3.zero);
				Debug.Log($"Loading placed object position as: {vector}");
				ShipBuildModeManager.Instance.PlaceShipObject(vector, placementRotation, gameObject.GetComponentInChildren<PlaceableShipObject>(), placementSFX: false);
			}
			if (!gameObject.GetComponent<NetworkObject>().IsSpawned)
			{
				gameObject.GetComponent<NetworkObject>().Spawn();
			}
			break;
		}
		if (gameObject != null)
		{
			SpawnedShipUnlockables.Add(unlockableIndex, gameObject);
		}
	}

	[ServerRpc]
	public void SyncSuitsServerRpc()
	{
		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(1846610026u, serverRpcParams, RpcDelivery.Reliable);
			__endSendServerRpc(ref bufferWriter, 1846610026u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
		{
			SyncSuitsClientRpc();
		}
	}

	[ClientRpc]
	public void SyncSuitsClientRpc()
	{
		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(2369901769u, clientRpcParams, RpcDelivery.Reliable);
				__endSendClientRpc(ref bufferWriter, 2369901769u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				PositionSuitsOnRack();
			}
		}
	}

	private void LoadShipGrabbableItems()
	{
		if (!ES3.KeyExists("shipGrabbableItemIDs", GameNetworkManager.Instance.currentSaveFileName))
		{
			Debug.Log("Key 'shipGrabbableItems' does not exist");
			return;
		}
		int[] array = ES3.Load<int[]>("shipGrabbableItemIDs", GameNetworkManager.Instance.currentSaveFileName);
		Vector3[] array2 = ES3.Load<Vector3[]>("shipGrabbableItemPos", GameNetworkManager.Instance.currentSaveFileName);
		if (array == null || array2 == null)
		{
			Debug.LogError("Ship items list loaded from file returns a null value!");
			return;
		}
		Debug.Log($"Ship grabbable items list loaded. Count: {array.Length}");
		bool flag = ES3.KeyExists("shipScrapValues", GameNetworkManager.Instance.currentSaveFileName);
		int[] array3 = null;
		if (flag)
		{
			array3 = ES3.Load<int[]>("shipScrapValues", GameNetworkManager.Instance.currentSaveFileName);
		}
		int[] array4 = null;
		bool flag2 = false;
		if (ES3.KeyExists("shipItemSaveData", GameNetworkManager.Instance.currentSaveFileName))
		{
			flag2 = true;
			array4 = ES3.Load<int[]>("shipItemSaveData", GameNetworkManager.Instance.currentSaveFileName);
		}
		int num = 0;
		int num2 = 0;
		for (int i = 0; i < array.Length; i++)
		{
			if (allItemsList.itemsList.Count >= array[i])
			{
				if (!shipBounds.bounds.Contains(array2[i]))
				{
					array2[i] = playerSpawnPositions[1].position;
					array2[i].x += UnityEngine.Random.Range(-0.7f, 0.7f);
					array2[i].z += UnityEngine.Random.Range(2f, 2f);
					array2[i].y += 0.5f;
				}
				GrabbableObject component = UnityEngine.Object.Instantiate(allItemsList.itemsList[array[i]].spawnPrefab, array2[i], Quaternion.identity, elevatorTransform).GetComponent<GrabbableObject>();
				component.fallTime = 1f;
				component.hasHitGround = true;
				component.scrapPersistedThroughRounds = true;
				component.isInElevator = true;
				component.isInShipRoom = true;
				if (flag && allItemsList.itemsList[array[i]].isScrap)
				{
					Debug.Log($"Setting scrap value for item: {component.gameObject.name}: {array3[num]}");
					component.SetScrapValue(array3[num]);
					num++;
				}
				if (flag2 && component.itemProperties.saveItemVariable && num2 < array4.Length)
				{
					Debug.Log($"Loading item save data for item: {component.gameObject}: {array4[num2]}");
					component.LoadItemSaveData(array4[num2]);
					num2++;
				}
				component.NetworkObject.Spawn();
			}
		}
	}

	private void SetTimeAndPlanetToSavedSettings()
	{
		string currentSaveFileName = GameNetworkManager.Instance.currentSaveFileName;
		int levelID;
		if (currentSaveFileName == "LCChallengeFile")
		{
			System.Random random = new System.Random(GameNetworkManager.Instance.GetWeekNumber() + 2);
			randomMapSeed = random.Next(0, 100000000);
			hasSubmittedChallengeRank = ES3.Load("SubmittedScore", currentSaveFileName, defaultValue: false);
			isChallengeFile = true;
			UnlockableSuit.SwitchSuitForAllPlayers(24);
			SelectableLevel[] array = levels.Where((SelectableLevel x) => x.planetHasTime).ToArray();
			levelID = array[random.Next(0, array.Length)].levelID;
		}
		else
		{
			isChallengeFile = false;
			randomMapSeed = ES3.Load("RandomSeed", currentSaveFileName, 0);
			levelID = ES3.Load("CurrentPlanetID", currentSaveFileName, defaultPlanet);
		}
		ChangeLevel(levelID);
		ChangePlanet();
		if (isChallengeFile)
		{
			TimeOfDay.Instance.totalTime = TimeOfDay.Instance.lengthOfHours * (float)TimeOfDay.Instance.numberOfHours;
			TimeOfDay.Instance.timeUntilDeadline = TimeOfDay.Instance.totalTime;
			TimeOfDay.Instance.profitQuota = 200;
		}
		else
		{
			TimeOfDay.Instance.timesFulfilledQuota = ES3.Load("QuotasPassed", currentSaveFileName, 0);
			TimeOfDay.Instance.profitQuota = ES3.Load("ProfitQuota", currentSaveFileName, TimeOfDay.Instance.quotaVariables.startingQuota);
			TimeOfDay.Instance.totalTime = TimeOfDay.Instance.lengthOfHours * (float)TimeOfDay.Instance.numberOfHours;
			TimeOfDay.Instance.timeUntilDeadline = ES3.Load("DeadlineTime", currentSaveFileName, (int)(TimeOfDay.Instance.totalTime * (float)TimeOfDay.Instance.quotaVariables.deadlineDaysAmount));
			TimeOfDay.Instance.quotaFulfilled = ES3.Load("QuotaFulfilled", currentSaveFileName, 0);
			TimeOfDay.Instance.SetBuyingRateForDay();
			gameStats.daysSpent = ES3.Load("Stats_DaysSpent", currentSaveFileName, 0);
			gameStats.deaths = ES3.Load("Stats_Deaths", currentSaveFileName, 0);
			gameStats.scrapValueCollected = ES3.Load("Stats_ValueCollected", currentSaveFileName, 0);
			gameStats.allStepsTaken = ES3.Load("Stats_StepsTaken", currentSaveFileName, 0);
		}
		TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
		SetPlanetsWeather();
		UnityEngine.Object.FindObjectOfType<Terminal>().SetItemSales();
		if (gameStats.daysSpent == 0)
		{
			PlayFirstDayShipAnimation(waitForMenuToClose: true);
		}
		if (TimeOfDay.Instance.timeUntilDeadline > 0f && TimeOfDay.Instance.daysUntilDeadline <= 0 && TimeOfDay.Instance.timesFulfilledQuota <= 0)
		{
			StartCoroutine(playDaysLeftAlertSFXDelayed());
		}
	}

	private IEnumerator StartSpatialVoiceChat()
	{
		yield return new WaitUntil(() => localClientHasControl && GameNetworkManager.Instance.localPlayerController != null);
		for (int i = 0; i < allPlayerObjects.Length; i++)
		{
			if ((bool)allPlayerObjects[i].GetComponent<NfgoPlayer>() && !allPlayerObjects[i].GetComponent<NfgoPlayer>().IsTracking)
			{
				allPlayerObjects[i].GetComponent<NfgoPlayer>().VoiceChatTrackingStart();
			}
		}
		float startTime = Time.realtimeSinceStartup;
		yield return new WaitUntil(() => HUDManager.Instance.hasSetSavedValues || Time.realtimeSinceStartup - startTime > 5f);
		if (!HUDManager.Instance.hasSetSavedValues)
		{
			Debug.LogError("Failure to set local player level! Skipping sync.");
		}
		else
		{
			HUDManager.Instance.SyncAllPlayerLevelsServerRpc(HUDManager.Instance.localPlayerLevel, (int)GameNetworkManager.Instance.localPlayerController.playerClientId);
		}
		yield return new WaitForSeconds(12f);
		UpdatePlayerVoiceEffects();
	}

	private IEnumerator UpdatePlayerVoiceEffectsOnDelay()
	{
		yield return new WaitForSeconds(12f);
		UpdatePlayerVoiceEffects();
	}

	public void KickPlayer(int playerObjToKick)
	{
		if ((!allPlayerScripts[playerObjToKick].isPlayerControlled && !allPlayerScripts[playerObjToKick].isPlayerDead) || !base.IsServer)
		{
			return;
		}
		if (!GameNetworkManager.Instance.disableSteam)
		{
			ulong playerSteamId = Instance.allPlayerScripts[playerObjToKick].playerSteamId;
			if (!KickedClientIds.Contains(playerSteamId))
			{
				KickedClientIds.Add(playerSteamId);
			}
		}
		NetworkManager.Singleton.DisconnectClient(allPlayerScripts[playerObjToKick].actualClientId);
		HUDManager.Instance.AddTextToChatOnServer($"[playerNum{playerObjToKick}] was kicked.");
	}

	public void OnLocalDisconnect()
	{
		if (NetworkManager.Singleton != null)
		{
			if (NetworkManager.Singleton.SceneManager != null)
			{
				NetworkManager.Singleton.SceneManager.OnLoadComplete -= SceneManager_OnLoadComplete1;
				NetworkManager.Singleton.SceneManager.OnLoad -= SceneManager_OnLoad;
			}
			else
			{
				Debug.Log("Scene manager is null");
			}
		}
	}

	public void OnClientDisconnect(ulong clientId)
	{
		if (ClientPlayerList == null || !ClientPlayerList.ContainsKey(clientId))
		{
			Debug.Log("Disconnection callback called for a client id which isn't in ClientPlayerList; ignoring. This is likely due to an unapproved connection.");
			return;
		}
		if (NetworkManager.Singleton == null || GameNetworkManager.Instance == null || GameNetworkManager.Instance.localPlayerController == null)
		{
			GameNetworkManager.Instance.disconnectReason = 1;
			GameNetworkManager.Instance.Disconnect();
			return;
		}
		if (clientId == NetworkManager.Singleton.LocalClientId || clientId == GameNetworkManager.Instance.localPlayerController.actualClientId)
		{
			Debug.Log("Disconnect callback called for local client; ignoring.");
			return;
		}
		Debug.Log("Client disconnected from server");
		if (!ClientPlayerList.TryGetValue(clientId, out var value))
		{
			Debug.LogError("Could not get player object number from client id on disconnect!");
		}
		if (!base.IsServer)
		{
			Debug.Log($"player disconnected c; {clientId}");
			Debug.Log(ClientPlayerList.Count);
			for (int i = 0; i < ClientPlayerList.Count; i++)
			{
				ClientPlayerList.TryGetValue((ulong)i, out var value2);
				Debug.Log($"client id: {i} ; player object id: {value2}");
			}
			Debug.Log($"disconnecting client id: {clientId}");
			if (ClientPlayerList.TryGetValue(clientId, out var value3) && value3 == 0)
			{
				Debug.Log("Host disconnected!");
				Debug.Log(GameNetworkManager.Instance.isDisconnecting);
				if (!GameNetworkManager.Instance.isDisconnecting)
				{
					Debug.Log("Host quit! Ending game for client.");
					GameNetworkManager.Instance.disconnectReason = 1;
					GameNetworkManager.Instance.Disconnect();
					return;
				}
			}
			OnPlayerDC(value, clientId);
			return;
		}
		if (fullyLoadedPlayers.Contains(clientId))
		{
			fullyLoadedPlayers.Remove(clientId);
		}
		if (RoundManager.Instance.playersFinishedGeneratingFloor.Contains(clientId))
		{
			RoundManager.Instance.playersFinishedGeneratingFloor.Remove(clientId);
		}
		GrabbableObject[] array = UnityEngine.Object.FindObjectsOfType<GrabbableObject>();
		for (int j = 0; j < array.Length; j++)
		{
			if (!array[j].isHeld)
			{
				array[j].heldByPlayerOnServer = false;
			}
		}
		if (!base.IsServer)
		{
			return;
		}
		List<ulong> list = new List<ulong>();
		foreach (KeyValuePair<ulong, int> clientPlayer in ClientPlayerList)
		{
			if (clientPlayer.Key != clientId)
			{
				list.Add(clientPlayer.Key);
			}
		}
		ClientRpcParams clientRpcParams = default(ClientRpcParams);
		clientRpcParams.Send = new ClientRpcSendParams
		{
			TargetClientIds = list.ToArray()
		};
		ClientRpcParams clientRpcParams2 = clientRpcParams;
		OnPlayerDC(value, clientId);
		OnClientDisconnectClientRpc(value, clientId, clientRpcParams2);
	}

	[ClientRpc]
	public void OnClientDisconnectClientRpc(int playerObjectNumber, ulong clientId, ClientRpcParams clientRpcParams = default(ClientRpcParams))
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			if (__rpc_exec_stage != __RpcExecStage.Client && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter bufferWriter = __beginSendClientRpc(475465488u, clientRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, playerObjectNumber);
				BytePacker.WriteValueBitPacked(bufferWriter, clientId);
				__endSendClientRpc(ref bufferWriter, 475465488u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				OnPlayerDC(playerObjectNumber, clientId);
			}
		}
	}

	public void OnPlayerDC(int playerObjectNumber, ulong clientId)
	{
		Debug.Log("Calling OnPlayerDC!");
		if (!ClientPlayerList.ContainsKey(clientId))
		{
			Debug.Log("disconnect: clientId key already removed!");
			return;
		}
		if (GameNetworkManager.Instance.localPlayerController != null && clientId == GameNetworkManager.Instance.localPlayerController.actualClientId)
		{
			Debug.Log("OnPlayerDC: Local client is disconnecting so return.");
			return;
		}
		if (base.NetworkManager.ShutdownInProgress || NetworkManager.Singleton == null)
		{
			Debug.Log("Shutdown is in progress, returning");
			return;
		}
		Debug.Log("Player DC'ing 2");
		if (base.IsServer && ClientPlayerList.TryGetValue(clientId, out var value))
		{
			HUDManager.Instance.AddTextToChatOnServer($"[playerNum{allPlayerScripts[value].playerClientId}] disconnected.");
		}
		if (!allPlayerScripts[playerObjectNumber].isPlayerDead)
		{
			livingPlayers--;
		}
		ClientPlayerList.Remove(clientId);
		connectedPlayersAmount--;
		Debug.Log("Player DC'ing 3");
		PlayerControllerB component = allPlayerObjects[playerObjectNumber].GetComponent<PlayerControllerB>();
		try
		{
			component.isPlayerControlled = false;
			component.isPlayerDead = false;
			if (!inShipPhase)
			{
				component.disconnectedMidGame = true;
				if (livingPlayers == 0)
				{
					allPlayersDead = true;
					ShipLeaveAutomatically();
				}
			}
			component.DropAllHeldItems(itemsFall: true, disconnecting: true);
			Debug.Log("Teleporting disconnected player out");
			component.TeleportPlayer(notSpawnedPosition.position);
			UnlockableSuit.SwitchSuitForPlayer(component, 0, playAudio: false);
			if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
			{
				HUDManager.Instance.UpdateBoxesSpectateUI();
			}
			if (!NetworkManager.Singleton.ShutdownInProgress && base.IsServer)
			{
				component.gameObject.GetComponent<NetworkObject>().RemoveOwnership();
			}
			QuickMenuManager quickMenuManager = UnityEngine.Object.FindObjectOfType<QuickMenuManager>();
			if (quickMenuManager != null)
			{
				quickMenuManager.RemoveUserFromPlayerList(playerObjectNumber);
			}
			Debug.Log($"Current players after dc: {connectedPlayersAmount}");
		}
		catch (Exception arg)
		{
			Debug.LogError($"Error while handling player disconnect!: {arg}");
		}
	}

	public void OnClientConnect(ulong clientId)
	{
		if (!base.IsServer)
		{
			return;
		}
		Debug.Log("player connected");
		Debug.Log($"connected players #: {connectedPlayersAmount}");
		try
		{
			List<int> list = ClientPlayerList.Values.ToList();
			Debug.Log($"Connecting new player on host; clientId: {clientId}");
			int num = 0;
			for (int i = 1; i < 4; i++)
			{
				if (!list.Contains(i))
				{
					num = i;
					break;
				}
			}
			allPlayerScripts[num].actualClientId = clientId;
			allPlayerObjects[num].GetComponent<NetworkObject>().ChangeOwnership(clientId);
			Debug.Log($"New player assigned object id: {allPlayerObjects[num]}");
			List<ulong> list2 = new List<ulong>();
			for (int j = 0; j < allPlayerObjects.Length; j++)
			{
				NetworkObject component = allPlayerObjects[j].GetComponent<NetworkObject>();
				if (!component.IsOwnedByServer)
				{
					list2.Add(component.OwnerClientId);
				}
				else if (j == 0)
				{
					list2.Add(NetworkManager.Singleton.LocalClientId);
				}
				else
				{
					list2.Add(999uL);
				}
			}
			int groupCredits = UnityEngine.Object.FindObjectOfType<Terminal>().groupCredits;
			int profitQuota = TimeOfDay.Instance.profitQuota;
			int quotaFulfilled = TimeOfDay.Instance.quotaFulfilled;
			int timeUntilDeadline = (int)TimeOfDay.Instance.timeUntilDeadline;
			OnPlayerConnectedClientRpc(clientId, connectedPlayersAmount, list2.ToArray(), num, groupCredits, currentLevelID, profitQuota, timeUntilDeadline, quotaFulfilled, randomMapSeed, isChallengeFile);
			ClientPlayerList.Add(clientId, num);
			Debug.Log($"client id connecting: {clientId} ; their corresponding player object id: {num}");
		}
		catch (Exception arg)
		{
			Debug.LogError($"Error occured in OnClientConnected! Shutting server down. clientId: {clientId}. Error: {arg}");
			GameNetworkManager.Instance.disconnectionReasonMessage = "Error occured when a player attempted to join the server! Restart the application and please report the glitch!";
			GameNetworkManager.Instance.Disconnect();
		}
	}

	[ClientRpc]
	private void OnPlayerConnectedClientRpc(ulong clientId, int connectedPlayers, ulong[] connectedPlayerIdsOrdered, int assignedPlayerObjectId, int serverMoneyAmount, int levelID, int profitQuota, int timeUntilDeadline, int quotaFulfilled, int randomSeed, bool isChallenge)
	{
		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(886676601u, clientRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, clientId);
			BytePacker.WriteValueBitPacked(bufferWriter, connectedPlayers);
			bool value = connectedPlayerIdsOrdered != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(connectedPlayerIdsOrdered, default(FastBufferWriter.ForPrimitives));
			}
			BytePacker.WriteValueBitPacked(bufferWriter, assignedPlayerObjectId);
			BytePacker.WriteValueBitPacked(bufferWriter, serverMoneyAmount);
			BytePacker.WriteValueBitPacked(bufferWriter, levelID);
			BytePacker.WriteValueBitPacked(bufferWriter, profitQuota);
			BytePacker.WriteValueBitPacked(bufferWriter, timeUntilDeadline);
			BytePacker.WriteValueBitPacked(bufferWriter, quotaFulfilled);
			BytePacker.WriteValueBitPacked(bufferWriter, randomSeed);
			bufferWriter.WriteValueSafe(in isChallenge, default(FastBufferWriter.ForPrimitives));
			__endSendClientRpc(ref bufferWriter, 886676601u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		try
		{
			Debug.Log($"NEW CLIENT JOINED THE SERVER!!; clientId: {clientId}");
			if (NetworkManager.Singleton == null)
			{
				return;
			}
			if (clientId == NetworkManager.Singleton.LocalClientId && GameNetworkManager.Instance.localClientWaitingForApproval)
			{
				GameNetworkManager.Instance.localClientWaitingForApproval = false;
			}
			if (!base.IsServer)
			{
				ClientPlayerList.Clear();
				for (int i = 0; i < connectedPlayerIdsOrdered.Length; i++)
				{
					if (connectedPlayerIdsOrdered[i] == 999)
					{
						Debug.Log($"Skipping at index {i}");
						continue;
					}
					ClientPlayerList.Add(connectedPlayerIdsOrdered[i], i);
					Debug.Log($"adding value to ClientPlayerList at value of index {i}: {connectedPlayerIdsOrdered[i]}");
				}
				if (!ClientPlayerList.ContainsKey(clientId))
				{
					Debug.Log($"Successfully added new client id {clientId} and connected to object {assignedPlayerObjectId}");
					ClientPlayerList.Add(clientId, assignedPlayerObjectId);
				}
				else
				{
					Debug.Log("ClientId already in ClientPlayerList!");
				}
				Debug.Log($"clientplayerlist count for client: {ClientPlayerList.Count}");
				Terminal terminal = UnityEngine.Object.FindObjectOfType<Terminal>();
				terminal.groupCredits = serverMoneyAmount;
				TimeOfDay timeOfDay = UnityEngine.Object.FindObjectOfType<TimeOfDay>();
				timeOfDay.globalTime = 100f;
				ChangeLevel(levelID);
				ChangePlanet();
				isChallengeFile = isChallenge;
				randomMapSeed = randomSeed;
				terminal.RotateShipDecorSelection();
				SetPlanetsWeather();
				UnityEngine.Object.FindObjectOfType<Terminal>().SetItemSales();
				SetMapScreenInfoToCurrentLevel();
				TimeOfDay.Instance.profitQuota = profitQuota;
				TimeOfDay.Instance.timeUntilDeadline = timeUntilDeadline;
				timeOfDay.SetBuyingRateForDay();
				TimeOfDay.Instance.quotaFulfilled = quotaFulfilled;
				TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
			}
			connectedPlayersAmount = connectedPlayers + 1;
			Debug.Log("New player: " + allPlayerObjects[assignedPlayerObjectId].name);
			PlayerControllerB playerControllerB = allPlayerScripts[assignedPlayerObjectId];
			Vector3 vector = (playerControllerB.serverPlayerPosition = GetPlayerSpawnPosition(assignedPlayerObjectId));
			playerControllerB.actualClientId = clientId;
			playerControllerB.isInElevator = true;
			playerControllerB.isInHangarShipRoom = true;
			playerControllerB.wasInElevatorLastFrame = false;
			allPlayerScripts[assignedPlayerObjectId].TeleportPlayer(vector);
			StartCoroutine(setPlayerToSpawnPosition(allPlayerObjects[assignedPlayerObjectId].transform, vector));
			for (int j = 0; j < connectedPlayersAmount + 1; j++)
			{
				if (j == 0 || !allPlayerScripts[j].IsOwnedByServer)
				{
					allPlayerScripts[j].isPlayerControlled = true;
				}
			}
			playerControllerB.isPlayerControlled = true;
			livingPlayers = connectedPlayersAmount + 1;
			Debug.Log($"Connected players (joined clients) amount after connection: {connectedPlayersAmount}");
			if (NetworkManager.Singleton.LocalClientId == clientId)
			{
				Debug.Log($"Asking server to sync already-held objects. Our client id: {NetworkManager.Singleton.LocalClientId}");
				mostRecentlyJoinedClient = true;
				if (isChallengeFile)
				{
					UnlockableSuit.SwitchSuitForAllPlayers(24);
				}
				HUDManager.Instance.SetSavedValues(assignedPlayerObjectId);
				SyncAlreadyHeldObjectsServerRpc((int)NetworkManager.Singleton.LocalClientId);
			}
			else
			{
				Debug.Log($"This client is not the client who just joined. Our client id: {NetworkManager.Singleton.LocalClientId}; joining client id: {clientId}");
				mostRecentlyJoinedClient = false;
				if (updateVoiceEffectsCoroutine != null)
				{
					StopCoroutine(updateVoiceEffectsCoroutine);
				}
				updateVoiceEffectsCoroutine = StartCoroutine(UpdatePlayerVoiceEffectsOnDelay());
				if (!playerControllerB.gameObject.GetComponentInChildren<NfgoPlayer>().IsTracking)
				{
					playerControllerB.gameObject.GetComponentInChildren<NfgoPlayer>().VoiceChatTrackingStart();
				}
			}
			if (GameNetworkManager.Instance.disableSteam)
			{
				QuickMenuManager quickMenuManager = UnityEngine.Object.FindObjectOfType<QuickMenuManager>();
				for (int k = 0; k < allPlayerScripts.Length; k++)
				{
					if (allPlayerScripts[k].isPlayerControlled || allPlayerScripts[k].isPlayerDead)
					{
						quickMenuManager.AddUserToPlayerList(0uL, allPlayerScripts[k].playerUsername, (int)allPlayerScripts[k].playerClientId);
					}
				}
			}
			SetDiscordStatusDetails();
		}
		catch (Exception arg)
		{
			Debug.LogError($"Failed to assign new player with client id #{clientId}: {arg}");
			GameNetworkManager.Instance.disconnectionReasonMessage = "An error occured while spawning into the game. Please report the glitch!";
			GameNetworkManager.Instance.Disconnect();
		}
	}

	private Vector3 GetPlayerSpawnPosition(int playerNum, bool simpleTeleport = false)
	{
		if (simpleTeleport)
		{
			return playerSpawnPositions[0].position;
		}
		Debug.DrawRay(playerSpawnPositions[playerNum].position, Vector3.up, Color.red, 15f);
		if (!Physics.CheckSphere(playerSpawnPositions[playerNum].position, 0.2f, 67108864, QueryTriggerInteraction.Ignore))
		{
			return playerSpawnPositions[playerNum].position;
		}
		if (!Physics.CheckSphere(playerSpawnPositions[playerNum].position + Vector3.up, 0.2f, 67108864, QueryTriggerInteraction.Ignore))
		{
			return playerSpawnPositions[playerNum].position + Vector3.up * 0.5f;
		}
		for (int i = 0; i < playerSpawnPositions.Length; i++)
		{
			if (i != playerNum)
			{
				Debug.DrawRay(playerSpawnPositions[i].position, Vector3.up, Color.green, 15f);
				if (!Physics.CheckSphere(playerSpawnPositions[i].position, 0.12f, -67108865, QueryTriggerInteraction.Ignore))
				{
					return playerSpawnPositions[i].position;
				}
				if (!Physics.CheckSphere(playerSpawnPositions[i].position + Vector3.up, 0.12f, 67108864, QueryTriggerInteraction.Ignore))
				{
					return playerSpawnPositions[i].position + Vector3.up * 0.5f;
				}
			}
		}
		System.Random random = new System.Random(65);
		float y = playerSpawnPositions[0].position.y;
		for (int j = 0; j < 15; j++)
		{
			Vector3 vector = new Vector3(random.Next((int)shipInnerRoomBounds.bounds.min.x, (int)shipInnerRoomBounds.bounds.max.x), y, random.Next((int)shipInnerRoomBounds.bounds.min.z, (int)shipInnerRoomBounds.bounds.max.z));
			vector = shipInnerRoomBounds.transform.InverseTransformPoint(vector);
			Debug.DrawRay(vector, Vector3.up, Color.yellow, 15f);
			if (!Physics.CheckSphere(vector, 0.12f, 67108864, QueryTriggerInteraction.Ignore))
			{
				return playerSpawnPositions[j].position;
			}
		}
		return playerSpawnPositions[0].position + Vector3.up * 0.5f;
	}

	[ServerRpc(RequireOwnership = false)]
	public void SyncAlreadyHeldObjectsServerRpc(int joiningClientId)
	{
		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(682230258u, serverRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, joiningClientId);
			__endSendServerRpc(ref bufferWriter, 682230258u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Server || (!networkManager.IsServer && !networkManager.IsHost))
		{
			return;
		}
		Debug.Log("Syncing already-held objects on server");
		try
		{
			GrabbableObject[] array = UnityEngine.Object.FindObjectsByType<GrabbableObject>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);
			List<NetworkObjectReference> list = new List<NetworkObjectReference>();
			List<int> list2 = new List<int>();
			List<int> list3 = new List<int>();
			List<int> list4 = new List<int>();
			for (int i = 0; i < array.Length; i++)
			{
				if (!array[i].isHeld)
				{
					continue;
				}
				list2.Add((int)array[i].playerHeldBy.playerClientId);
				list.Add(array[i].NetworkObject);
				Debug.Log($"Object #{i} is held");
				for (int j = 0; j < array[i].playerHeldBy.ItemSlots.Length; j++)
				{
					if (array[i].playerHeldBy.ItemSlots[j] == array[i])
					{
						list3.Add(j);
						Debug.Log($"Item slot index for item #{i}: {j}");
					}
				}
				if (array[i].isPocketed)
				{
					list4.Add(list.Count - 1);
					Debug.Log($"Object #{i} is pocketed");
				}
			}
			Debug.Log($"pocketed objects count: {list4.Count}");
			Debug.Log($"held objects count: {list.Count}");
			List<int> list5 = new List<int>();
			for (int k = 0; k < array.Length; k++)
			{
				if (array[k].itemProperties.isScrap)
				{
					list5.Add(array[k].scrapValue);
				}
			}
			if (list.Count > 0)
			{
				SyncAlreadyHeldObjectsClientRpc(list.ToArray(), list2.ToArray(), list3.ToArray(), list4.ToArray(), joiningClientId);
			}
			else
			{
				SyncShipUnlockablesServerRpc();
			}
		}
		catch (Exception arg)
		{
			Debug.LogError($"Error while syncing players' already held objects in server! Skipping. Error: {arg}");
			SyncShipUnlockablesServerRpc();
		}
	}

	[ClientRpc]
	public void SyncAlreadyHeldObjectsClientRpc(NetworkObjectReference[] gObjects, int[] playersHeldBy, int[] itemSlotNumbers, int[] isObjectPocketed, int syncWithClient)
	{
		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(1613265729u, clientRpcParams, RpcDelivery.Reliable);
			bool value = gObjects != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(gObjects, default(FastBufferWriter.ForNetworkSerializable));
			}
			bool value2 = playersHeldBy != null;
			bufferWriter.WriteValueSafe(in value2, default(FastBufferWriter.ForPrimitives));
			if (value2)
			{
				bufferWriter.WriteValueSafe(playersHeldBy, default(FastBufferWriter.ForPrimitives));
			}
			bool value3 = itemSlotNumbers != null;
			bufferWriter.WriteValueSafe(in value3, default(FastBufferWriter.ForPrimitives));
			if (value3)
			{
				bufferWriter.WriteValueSafe(itemSlotNumbers, default(FastBufferWriter.ForPrimitives));
			}
			bool value4 = isObjectPocketed != null;
			bufferWriter.WriteValueSafe(in value4, default(FastBufferWriter.ForPrimitives));
			if (value4)
			{
				bufferWriter.WriteValueSafe(isObjectPocketed, default(FastBufferWriter.ForPrimitives));
			}
			BytePacker.WriteValueBitPacked(bufferWriter, syncWithClient);
			__endSendClientRpc(ref bufferWriter, 1613265729u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost) || syncWithClient != (int)NetworkManager.Singleton.LocalClientId)
		{
			return;
		}
		Debug.Log("Syncing already-held objects on client");
		Debug.Log($"held objects count: {gObjects.Length}");
		Debug.Log($"pocketed objects count: {isObjectPocketed.Length}");
		try
		{
			for (int i = 0; i < gObjects.Length; i++)
			{
				if (gObjects[i].TryGet(out var networkObject))
				{
					GrabbableObject component = networkObject.gameObject.GetComponent<GrabbableObject>();
					component.isHeld = true;
					allPlayerScripts[playersHeldBy[i]].ItemSlots[itemSlotNumbers[i]] = component;
					component.parentObject = allPlayerScripts[playersHeldBy[i]].serverItemHolder;
					bool flag = false;
					Debug.Log($"isObjectPocketed length: {isObjectPocketed.Length}");
					Debug.Log($"iii {i}");
					for (int j = 0; j < isObjectPocketed.Length; j++)
					{
						Debug.Log($"bbb {j} ; {isObjectPocketed[j]}");
						if (isObjectPocketed[j] == i)
						{
							Debug.Log("Pocketing object for player: " + allPlayerScripts[playersHeldBy[i]].gameObject.name);
							component.isPocketed = true;
							component.EnableItemMeshes(enable: false);
							component.EnablePhysics(enable: false);
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						allPlayerScripts[playersHeldBy[i]].currentlyHeldObjectServer = component;
						allPlayerScripts[playersHeldBy[i]].isHoldingObject = true;
						allPlayerScripts[playersHeldBy[i]].twoHanded = component.itemProperties.twoHanded;
						allPlayerScripts[playersHeldBy[i]].twoHandedAnimation = component.itemProperties.twoHandedAnimation;
						allPlayerScripts[playersHeldBy[i]].currentItemSlot = itemSlotNumbers[i];
					}
				}
				else
				{
					Debug.LogError($"Syncing already held objects: Unable to get network object from reference for GObject; net object id: {gObjects[i].NetworkObjectId}");
				}
			}
		}
		catch (Exception arg)
		{
			Debug.LogError($"Error while syncing players' already held objects to client from server: {arg}");
		}
		SyncShipUnlockablesServerRpc();
	}

	[ServerRpc(RequireOwnership = false)]
	public void SyncShipUnlockablesServerRpc()
	{
		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(744998938u, serverRpcParams, RpcDelivery.Reliable);
			__endSendServerRpc(ref bufferWriter, 744998938u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Server || (!networkManager.IsServer && !networkManager.IsHost))
		{
			return;
		}
		try
		{
			int[] array = new int[4];
			for (int i = 0; i < 4; i++)
			{
				array[i] = allPlayerScripts[i].currentSuitID;
			}
			List<int> list = new List<int>();
			List<Vector3> list2 = new List<Vector3>();
			List<Vector3> list3 = new List<Vector3>();
			List<int> list4 = new List<int>();
			PlaceableShipObject[] array2 = (from x in UnityEngine.Object.FindObjectsOfType<PlaceableShipObject>()
				orderby x.unlockableID
				select x).ToArray();
			Debug.Log($"Server: objects in ship: {array2.Length}");
			for (int j = 0; j < array2.Length; j++)
			{
				if (j > 175)
				{
					Debug.Log("Attempted to sync more than 175 unlockables which is not allowed");
					break;
				}
				Debug.Log($"Server: placeableObject #{j}: {array2[j].parentObject.transform.name}");
				Debug.Log($"Server: position #{j}: {unlockablesList.unlockables[array2[j].unlockableID].placedPosition}");
				list.Add(array2[j].unlockableID);
				list2.Add(unlockablesList.unlockables[array2[j].unlockableID].placedPosition);
				list3.Add(unlockablesList.unlockables[array2[j].unlockableID].placedRotation);
				if (unlockablesList.unlockables[array2[j].unlockableID].inStorage)
				{
					list4.Add(array2[j].unlockableID);
				}
			}
			GrabbableObject[] array3 = (from x in UnityEngine.Object.FindObjectsByType<GrabbableObject>(FindObjectsInactive.Exclude, FindObjectsSortMode.None)
				orderby Vector3.Distance(x.transform.position, Vector3.zero)
				select x).ToArray();
			List<int> list5 = new List<int>();
			List<int> list6 = new List<int>();
			for (int k = 0; k < array3.Length; k++)
			{
				if (k > 250)
				{
					Debug.Log("Attempted to sync more than 250 scrap values which is not allowed");
					break;
				}
				if (array3[k].itemProperties.saveItemVariable)
				{
					list6.Add(array3[k].GetItemDataToSave());
				}
				if (array3[k].itemProperties.isScrap)
				{
					list5.Add(array3[k].scrapValue);
				}
			}
			SyncShipUnlockablesClientRpc(array, shipRoomLights.areLightsOn, list2.ToArray(), list3.ToArray(), list.ToArray(), list4.ToArray(), list5.ToArray(), list6.ToArray());
		}
		catch (Exception arg)
		{
			Debug.LogError($"Error while syncing unlockables in server. Quitting server: {arg}");
			GameNetworkManager.Instance.disconnectionReasonMessage = "An error occured while syncing ship objects! The file may be corrupted. Please report the glitch!";
			GameNetworkManager.Instance.Disconnect();
		}
	}

	private void PositionSuitsOnRack()
	{
		UnlockableSuit[] array = UnityEngine.Object.FindObjectsOfType<UnlockableSuit>();
		Debug.Log($"Suits: {array.Length}");
		for (int i = 0; i < array.Length; i++)
		{
			Debug.Log($"Suit #{i}: {array[i].suitID}");
			AutoParentToShip component = array[i].gameObject.GetComponent<AutoParentToShip>();
			component.overrideOffset = true;
			component.positionOffset = new Vector3(-2.45f, 2.75f, -8.41f) + rightmostSuitPosition.forward * 0.18f * i;
			component.rotationOffset = new Vector3(0f, 90f, 0f);
			Debug.Log($"pos: {component.positionOffset}; rot: {component.rotationOffset}");
		}
		UnityEngine.Object.FindObjectsOfType<UnlockableSuit>(includeInactive: true);
	}

	[ClientRpc]
	public void SyncShipUnlockablesClientRpc(int[] playerSuitIDs, bool shipLightsOn, Vector3[] placeableObjectPositions, Vector3[] placeableObjectRotations, int[] placeableObjects, int[] storedItems, int[] scrapValues, int[] itemSaveData)
	{
		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(4156335180u, clientRpcParams, RpcDelivery.Reliable);
			bool value = playerSuitIDs != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(playerSuitIDs, default(FastBufferWriter.ForPrimitives));
			}
			bufferWriter.WriteValueSafe(in shipLightsOn, default(FastBufferWriter.ForPrimitives));
			bool value2 = placeableObjectPositions != null;
			bufferWriter.WriteValueSafe(in value2, default(FastBufferWriter.ForPrimitives));
			if (value2)
			{
				bufferWriter.WriteValueSafe(placeableObjectPositions);
			}
			bool value3 = placeableObjectRotations != null;
			bufferWriter.WriteValueSafe(in value3, default(FastBufferWriter.ForPrimitives));
			if (value3)
			{
				bufferWriter.WriteValueSafe(placeableObjectRotations);
			}
			bool value4 = placeableObjects != null;
			bufferWriter.WriteValueSafe(in value4, default(FastBufferWriter.ForPrimitives));
			if (value4)
			{
				bufferWriter.WriteValueSafe(placeableObjects, default(FastBufferWriter.ForPrimitives));
			}
			bool value5 = storedItems != null;
			bufferWriter.WriteValueSafe(in value5, default(FastBufferWriter.ForPrimitives));
			if (value5)
			{
				bufferWriter.WriteValueSafe(storedItems, default(FastBufferWriter.ForPrimitives));
			}
			bool value6 = scrapValues != null;
			bufferWriter.WriteValueSafe(in value6, default(FastBufferWriter.ForPrimitives));
			if (value6)
			{
				bufferWriter.WriteValueSafe(scrapValues, default(FastBufferWriter.ForPrimitives));
			}
			bool value7 = itemSaveData != null;
			bufferWriter.WriteValueSafe(in value7, default(FastBufferWriter.ForPrimitives));
			if (value7)
			{
				bufferWriter.WriteValueSafe(itemSaveData, default(FastBufferWriter.ForPrimitives));
			}
			__endSendClientRpc(ref bufferWriter, 4156335180u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		if (!base.IsServer)
		{
			GrabbableObject[] array = (from x in UnityEngine.Object.FindObjectsByType<GrabbableObject>(FindObjectsInactive.Exclude, FindObjectsSortMode.None)
				orderby Vector3.Distance(x.transform.position, Vector3.zero)
				select x).ToArray();
			try
			{
				int num = 0;
				for (int i = 0; i < array.Length; i++)
				{
					if (array[i].itemProperties.saveItemVariable)
					{
						array[i].LoadItemSaveData(itemSaveData[num]);
						num++;
					}
				}
			}
			catch (Exception arg)
			{
				Debug.Log($"Error while attempting to sync item save data from host: {arg}");
			}
			try
			{
				int num2 = 0;
				for (int j = 0; j < array.Length; j++)
				{
					if (array[j].itemProperties.isScrap)
					{
						if (num2 >= scrapValues.Length)
						{
							break;
						}
						array[j].SetScrapValue(scrapValues[num2]);
						num2++;
					}
				}
				for (int k = 0; k < array.Length; k++)
				{
					if (array[k].transform.parent == null)
					{
						Vector3 position = array[k].transform.position;
						array[k].transform.parent = elevatorTransform;
						array[k].targetFloorPosition = elevatorTransform.InverseTransformPoint(position);
					}
				}
			}
			catch (Exception arg2)
			{
				Debug.LogError($"Error while syncing scrap objects to this client from server: {arg2}");
			}
			try
			{
				for (int l = 0; l < allPlayerScripts.Length; l++)
				{
					UnlockableSuit.SwitchSuitForPlayer(allPlayerScripts[l], playerSuitIDs[l], playAudio: false);
				}
				PositionSuitsOnRack();
				bool flag = false;
				PlaceableShipObject[] array2 = (from x in UnityEngine.Object.FindObjectsOfType<PlaceableShipObject>()
					orderby x.unlockableID
					select x).ToArray();
				for (int m = 0; m < array2.Length; m++)
				{
					if (!placeableObjects.Contains(array2[m].unlockableID))
					{
						continue;
					}
					Debug.Log($"Client: placeableObject #{m}: {array2[m].parentObject.transform.name}");
					Debug.Log($"Client: position #{m}: {placeableObjectPositions[m]}");
					if (!unlockablesList.unlockables[array2[m].unlockableID].alreadyUnlocked)
					{
						unlockablesList.unlockables[array2[m].unlockableID].hasBeenUnlockedByPlayer = true;
					}
					if (storedItems.Contains(array2[m].unlockableID))
					{
						unlockablesList.unlockables[array2[m].unlockableID].inStorage = true;
						if (!unlockablesList.unlockables[array2[m].unlockableID].spawnPrefab)
						{
							array2[m].parentObject.disableObject = true;
							Debug.Log("DISABLE OBJECT B");
						}
					}
					else if (!(placeableObjectPositions[m] == Vector3.zero))
					{
						flag = true;
						ShipBuildModeManager.Instance.PlaceShipObject(placeableObjectPositions[m], placeableObjectRotations[m], array2[m], placementSFX: false);
					}
				}
				if (mostRecentlyJoinedClient && flag && GameNetworkManager.Instance.localPlayerController != null)
				{
					GameNetworkManager.Instance.localPlayerController.TeleportPlayer(GetPlayerSpawnPosition((int)GameNetworkManager.Instance.localPlayerController.playerClientId));
				}
			}
			catch (Exception arg3)
			{
				Debug.LogError($"Error while syncing unlockables in ship to this client from server: {arg3}");
			}
		}
		try
		{
			for (int n = 0; n < 4; n++)
			{
				if (!allPlayerScripts[n].isPlayerControlled && !allPlayerScripts[n].isPlayerDead)
				{
					return;
				}
				allPlayerScripts[n].currentSuitID = playerSuitIDs[n];
				Material suitMaterial = unlockablesList.unlockables[playerSuitIDs[n]].suitMaterial;
				allPlayerScripts[n].thisPlayerModel.sharedMaterial = suitMaterial;
				allPlayerScripts[n].thisPlayerModelLOD1.sharedMaterial = suitMaterial;
				allPlayerScripts[n].thisPlayerModelLOD2.sharedMaterial = suitMaterial;
				allPlayerScripts[n].thisPlayerModelArms.sharedMaterial = suitMaterial;
			}
		}
		catch (Exception arg4)
		{
			Debug.LogError($"Error while syncing player suit materials from server to client: {arg4}");
		}
		HUDManager.Instance.SyncAllPlayerLevelsServerRpc();
		shipRoomLights.SetShipLightsOnLocalClientOnly(shipLightsOn);
		if (UnityEngine.Object.FindObjectOfType<TVScript>() != null)
		{
			UnityEngine.Object.FindObjectOfType<TVScript>().SyncTVServerRpc();
		}
	}

	public void StartTrackingAllPlayerVoices()
	{
		for (int i = 0; i < allPlayerScripts.Length; i++)
		{
			if ((allPlayerScripts[i].isPlayerControlled || Instance.allPlayerScripts[i].isPlayerDead) && !allPlayerScripts[i].gameObject.GetComponentInChildren<NfgoPlayer>().IsTracking)
			{
				Debug.Log("Starting voice tracking for player: " + allPlayerScripts[i].playerUsername);
				allPlayerScripts[i].gameObject.GetComponentInChildren<NfgoPlayer>().VoiceChatTrackingStart();
			}
		}
	}

	private IEnumerator setPlayerToSpawnPosition(Transform playerBody, Vector3 spawnPos)
	{
		for (int i = 0; i < 50; i++)
		{
			yield return null;
			yield return null;
			playerBody.position = spawnPos;
			if (Vector3.Distance(playerBody.position, spawnPos) < 6f)
			{
				break;
			}
		}
	}

	private void Update()
	{
		if (GameNetworkManager.Instance == null)
		{
			return;
		}
		if (GameNetworkManager.Instance.localPlayerController != null)
		{
			PlayerControllerB spectatedPlayerScript = GameNetworkManager.Instance.localPlayerController;
			if (spectatedPlayerScript.isPlayerDead && spectatedPlayerScript.spectatedPlayerScript != null)
			{
				spectatedPlayerScript = spectatedPlayerScript.spectatedPlayerScript;
			}
			if (spectatedPlayerScript.isInsideFactory)
			{
				blackSkyVolume.weight = 1f;
			}
			else
			{
				blackSkyVolume.weight = 0f;
			}
			if (suckingPlayersOutOfShip)
			{
				upperMonitorsCanvas.SetActive(value: false);
				SuckLocalPlayerOutOfShipDoor();
			}
			else if (!inShipPhase)
			{
				timeSinceRoundStarted += Time.deltaTime;
				upperMonitorsCanvas.SetActive(GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom);
			}
			else
			{
				upperMonitorsCanvas.SetActive(value: true);
			}
			if (IngamePlayerSettings.Instance.settings.pushToTalk)
			{
				voiceChatModule.IsMuted = !IngamePlayerSettings.Instance.playerInput.actions.FindAction("VoiceButton").IsPressed() && !GameNetworkManager.Instance.localPlayerController.speakingToWalkieTalkie;
				HUDManager.Instance.PTTIcon.enabled = IngamePlayerSettings.Instance.settings.micEnabled && !voiceChatModule.IsMuted;
			}
			else
			{
				voiceChatModule.IsMuted = !IngamePlayerSettings.Instance.settings.micEnabled;
				HUDManager.Instance.PTTIcon.enabled = false;
			}
			DetectVoiceChatAmplitude();
		}
		if (base.IsServer && !hasHostSpawned)
		{
			hasHostSpawned = true;
			ClientPlayerList.Add(NetworkManager.Singleton.LocalClientId, connectedPlayersAmount);
			allPlayerObjects[0].GetComponent<NetworkObject>().ChangeOwnership(NetworkManager.Singleton.LocalClientId);
			allPlayerObjects[0].GetComponent<PlayerControllerB>().isPlayerControlled = true;
			livingPlayers = connectedPlayersAmount + 1;
			allPlayerObjects[0].GetComponent<PlayerControllerB>().TeleportPlayer(GetPlayerSpawnPosition(0));
			GameNetworkManager.Instance.SetLobbyJoinable(joinable: true);
		}
	}

	private string NoPunctuation(string input)
	{
		return new string(input.Where((char c) => char.IsLetter(c)).ToArray());
	}

	private void SuckLocalPlayerOutOfShipDoor()
	{
		suckingPower += Time.deltaTime * 2f;
		GameNetworkManager.Instance.localPlayerController.fallValue = 0f;
		GameNetworkManager.Instance.localPlayerController.fallValueUncapped = 0f;
		if (Vector3.Distance(GameNetworkManager.Instance.localPlayerController.transform.position, middleOfShipNode.position) < 25f)
		{
			if (Physics.Linecast(GameNetworkManager.Instance.localPlayerController.transform.position, shipDoorNode.position, collidersAndRoomMask))
			{
				GameNetworkManager.Instance.localPlayerController.externalForces = Vector3.Normalize(middleOfShipNode.position - GameNetworkManager.Instance.localPlayerController.transform.position) * 350f;
			}
			else
			{
				GameNetworkManager.Instance.localPlayerController.externalForces = Vector3.Normalize(middleOfSpaceNode.position - GameNetworkManager.Instance.localPlayerController.transform.position) * (350f / Vector3.Distance(moveAwayFromShipNode.position, GameNetworkManager.Instance.localPlayerController.transform.position)) * (suckingPower / 2.25f);
			}
			return;
		}
		if (!choseRandomFlyDirForPlayer)
		{
			choseRandomFlyDirForPlayer = true;
			randomFlyDir = new Vector3(-1f, 0f, UnityEngine.Random.Range(-0.7f, 0.7f));
		}
		GameNetworkManager.Instance.localPlayerController.externalForces = Vector3.Scale(Vector3.one, randomFlyDir) * 70f;
	}

	private void DetectVoiceChatAmplitude()
	{
		if (GameNetworkManager.Instance == null || GameNetworkManager.Instance.localPlayerController == null || GameNetworkManager.Instance.localPlayerController.isPlayerDead || voiceChatModule.IsMuted || !voiceChatModule.enabled || voiceChatModule == null)
		{
			return;
		}
		VoicePlayerState voicePlayerState = voiceChatModule.FindPlayer(voiceChatModule.LocalPlayerName);
		averageCount++;
		if (averageCount > movingAverageLength)
		{
			averageVoiceAmplitude += (voicePlayerState.Amplitude - averageVoiceAmplitude) / (float)(movingAverageLength + 1);
		}
		else
		{
			averageVoiceAmplitude += voicePlayerState.Amplitude;
			if (averageCount == movingAverageLength)
			{
				averageVoiceAmplitude /= averageCount;
			}
		}
		float num = voicePlayerState.Amplitude / Mathf.Clamp(averageVoiceAmplitude, 0.008f, 0.5f);
		if (voicePlayerState.IsSpeaking && voiceChatNoiseCooldown <= 0f && num > 3f)
		{
			RoundManager.Instance.PlayAudibleNoise(GameNetworkManager.Instance.localPlayerController.transform.position, Mathf.Clamp(3f * num, 3f, 36f), Mathf.Clamp(num / 7f, 0.6f, 0.9f), 0, hangarDoorsClosed && GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom, 75);
			voiceChatNoiseCooldown = 0.2f;
		}
		voiceChatNoiseCooldown -= Time.deltaTime;
	}

	public void ShipLeaveAutomatically(bool leavingOnMidnight = false)
	{
		if (!shipLeftAutomatically && !shipIsLeaving)
		{
			shipLeftAutomatically = true;
			StartCoroutine(gameOverAnimation(leavingOnMidnight));
		}
	}

	public void SetSpectateCameraToGameOverMode(bool enableGameOver, PlayerControllerB localPlayer = null)
	{
		overrideSpectateCamera = enableGameOver;
		if (enableGameOver)
		{
			spectateCamera.transform.SetParent(gameOverCameraHandle, worldPositionStays: false);
		}
		else
		{
			spectateCamera.transform.SetParent(localPlayer.spectateCameraPivot, worldPositionStays: false);
		}
		spectateCamera.transform.localEulerAngles = Vector3.zero;
		spectateCamera.transform.localPosition = Vector3.zero;
	}

	public void SwitchCamera(Camera newCamera)
	{
		if (newCamera != spectateCamera)
		{
			spectateCamera.enabled = false;
		}
		newCamera.enabled = true;
		activeCamera = newCamera;
		UnityEngine.Object.FindObjectOfType<StormyWeather>(includeInactive: true).SwitchCamera(newCamera);
		CameraSwitchEvent.Invoke();
	}

	private IEnumerator gameOverAnimation(bool leavingOnMidnight)
	{
		yield return new WaitUntil(() => shipHasLanded);
		if (leavingOnMidnight)
		{
			HUDManager.Instance.ReadDialogue(shipLeavingOnMidnightDialogue);
		}
		HUDManager.Instance.shipLeavingEarlyIcon.enabled = false;
		StartMatchLever startMatchLever = UnityEngine.Object.FindObjectOfType<StartMatchLever>();
		startMatchLever.triggerScript.animationString = "SA_PushLeverBack";
		startMatchLever.leverHasBeenPulled = false;
		startMatchLever.triggerScript.interactable = false;
		startMatchLever.leverAnimatorObject.SetBool("pullLever", value: false);
		ShipLeave();
		yield return new WaitForSeconds(1.5f);
		SetSpectateCameraToGameOverMode(enableGameOver: true);
		if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
		{
			GameNetworkManager.Instance.localPlayerController.SetSpectatedPlayerEffects(allPlayersDead: true);
		}
		yield return new WaitForSeconds(1f);
		if (!leavingOnMidnight)
		{
			HUDManager.Instance.ReadDialogue(gameOverDialogue);
		}
		Debug.Log($"Is in elevator D?: {GameNetworkManager.Instance.localPlayerController.isInElevator}");
		yield return new WaitForSeconds(9.5f);
		if (!leavingOnMidnight)
		{
			HUDManager.Instance.UIAudio.PlayOneShot(allPlayersDeadAudio);
			HUDManager.Instance.gameOverAnimator.SetTrigger("allPlayersDead");
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void StartGameServerRpc()
	{
		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(1089447320u, serverRpcParams, RpcDelivery.Reliable);
			__endSendServerRpc(ref bufferWriter, 1089447320u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
		{
			if (fullyLoadedPlayers.Count >= connectedPlayersAmount + 1 && !travellingToNewLevel)
			{
				StartGame();
			}
			else
			{
				UnityEngine.Object.FindObjectOfType<StartMatchLever>().CancelStartGameClientRpc();
			}
		}
	}

	public void StartGame()
	{
		if (!base.IsServer)
		{
			return;
		}
		if (inShipPhase)
		{
			if (!GameNetworkManager.Instance.gameHasStarted)
			{
				GameNetworkManager.Instance.LeaveLobbyAtGameStart();
				GameNetworkManager.Instance.gameHasStarted = true;
			}
			inShipPhase = false;
			fullyLoadedPlayers.Clear();
			ResetPlayersLoadedValueClientRpc(landingShip: true);
			UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.disabledHoverTip = "[Wait for ship to land]";
			UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.interactable = false;
			currentPlanetAnimator.SetTrigger("LandOnPlanet");
			if (overrideRandomSeed)
			{
				randomMapSeed = overrideSeedNumber;
			}
			else if (isChallengeFile)
			{
				randomMapSeed = new System.Random(GameNetworkManager.Instance.GetWeekNumber() + 51016).Next(0, 100000000);
				Debug.Log($"RANDOM MAP SEED: {randomMapSeed}");
			}
			else
			{
				ChooseNewRandomMapSeed();
			}
			base.NetworkManager.SceneManager.LoadScene(currentLevel.sceneName, LoadSceneMode.Additive);
			Debug.Log("LOADING GAME!!!!!");
			StartCoroutine(OpenShipDoors());
		}
		else
		{
			Debug.Log("Attempted to start game on server but we are not in ship phase");
		}
	}

	public void ChooseNewRandomMapSeed()
	{
		randomMapSeed = UnityEngine.Random.Range(1, 100000000);
	}

	private IEnumerator OpenShipDoors()
	{
		Debug.Log("Waiting for all players to load!");
		yield return new WaitUntil(() => fullyLoadedPlayers.Count >= GameNetworkManager.Instance.connectedPlayers);
		yield return new WaitForSeconds(0.5f);
		RoundManager.Instance.LoadNewLevel(randomMapSeed, currentLevel);
	}

	public IEnumerator openingDoorsSequence()
	{
		yield return new WaitForSeconds(1f);
		HUDManager.Instance.LevellingAudio.Stop();
		StartMatchLever leverScript = UnityEngine.Object.FindObjectOfType<StartMatchLever>();
		leverScript.triggerScript.timeToHold = 0.7f;
		leverScript.triggerScript.interactable = false;
		displayedLevelResults = false;
		Instance.StartTrackingAllPlayerVoices();
		if (!GameNetworkManager.Instance.gameHasStarted)
		{
			GameNetworkManager.Instance.LeaveLobbyAtGameStart();
			GameNetworkManager.Instance.gameHasStarted = true;
		}
		UnityEngine.Object.FindObjectOfType<QuickMenuManager>().DisableInviteFriendsButton();
		if (!GameNetworkManager.Instance.disableSteam)
		{
			GameNetworkManager.Instance.SetSteamFriendGrouping(GameNetworkManager.Instance.steamLobbyName, connectedPlayersAmount + 1, "Landed on " + currentLevel.PlanetName);
		}
		SetDiscordStatusDetails();
		timeSinceRoundStarted = 0f;
		shipLeftAutomatically = false;
		ResetStats();
		inShipPhase = false;
		SwitchMapMonitorPurpose();
		SetPlayerObjectExtrapolate(enable: false);
		shipAnimatorObject.gameObject.GetComponent<Animator>().SetTrigger("OpenShip");
		if (currentLevel.currentWeather != LevelWeatherType.None)
		{
			WeatherEffect weatherEffect = TimeOfDay.Instance.effects[(int)currentLevel.currentWeather];
			weatherEffect.effectEnabled = true;
			if (weatherEffect.effectPermanentObject != null)
			{
				weatherEffect.effectPermanentObject.SetActive(value: true);
			}
		}
		yield return null;
		yield return new WaitForSeconds(0.2f);
		if (TimeOfDay.Instance.currentLevelWeather != LevelWeatherType.None && !currentLevel.overrideWeather)
		{
			TimeOfDay.Instance.effects[(int)TimeOfDay.Instance.currentLevelWeather].effectEnabled = true;
		}
		shipDoorsEnabled = true;
		if (currentLevel.planetHasTime)
		{
			TimeOfDay.Instance.currentDayTimeStarted = true;
			TimeOfDay.Instance.movingGlobalTimeForward = true;
		}
		UnityEngine.Object.FindObjectOfType<HangarShipDoor>().SetDoorButtonsEnabled(doorButtonsEnabled: true);
		TeleportPlayerInShipIfOutOfRoomBounds();
		yield return new WaitForSeconds(0.05f);
		Debug.Log($"startofround: {currentLevel.levelID}; {hoursSinceLastCompanyVisit}");
		if (currentLevel.levelID == 3 && hoursSinceLastCompanyVisit >= 0)
		{
			hoursSinceLastCompanyVisit = 0;
			TimeOfDay.Instance.TimeOfDayMusic.volume = 0.6f;
			Debug.Log("Playing time of day music");
			TimeOfDay.Instance.PlayTimeMusicDelayed(companyVisitMusic, 1f);
		}
		HUDManager.Instance.loadingText.enabled = false;
		HUDManager.Instance.loadingDarkenScreen.enabled = false;
		shipDoorAudioSource.PlayOneShot(openingHangarDoorAudio, 1f);
		yield return new WaitForSeconds(0.8f);
		shipDoorsAnimator.SetBool("Closed", value: false);
		yield return new WaitForSeconds(5f);
		HUDManager.Instance.planetIntroAnimator.SetTrigger("introAnimation");
		HUDManager.Instance.planetInfoHeaderText.text = "CELESTIAL BODY: " + currentLevel.PlanetName;
		HUDManager.Instance.planetInfoSummaryText.text = currentLevel.LevelDescription;
		HUDManager.Instance.planetRiskLevelText.text = currentLevel.riskLevel;
		yield return new WaitForSeconds(10f);
		if (currentLevel.spawnEnemiesAndScrap && currentLevel.planetHasTime)
		{
			HUDManager.Instance.quotaAnimator.SetBool("visible", value: true);
			TimeOfDay.Instance.currentDayTime = TimeOfDay.Instance.CalculatePlanetTime(currentLevel);
			TimeOfDay.Instance.RefreshClockUI();
		}
		yield return new WaitForSeconds(4f);
		OnShipLandedMiscEvents();
		SetPlayerObjectExtrapolate(enable: false);
		shipHasLanded = true;
		leverScript.triggerScript.animationString = "SA_PushLeverBack";
		leverScript.triggerScript.interactable = true;
		leverScript.hasDisplayedTimeWarning = false;
	}

	private void OnShipLandedMiscEvents()
	{
		if (TimeOfDay.Instance.currentLevelWeather == LevelWeatherType.Eclipsed)
		{
			HUDManager.Instance.DisplayTip("Weather alert!", "You have landed in an eclipse. Exercise caution!", isWarning: true, useSave: true, "LC_EclipseTip");
		}
		int num = ES3.Load("TimesLanded", "LCGeneralSaveData", 0);
		ES3.Save("TimesLanded", num + 1, "LCGeneralSaveData");
	}

	public void ForcePlayerIntoShip()
	{
		if (!GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom)
		{
			GameNetworkManager.Instance.localPlayerController.isInElevator = true;
			GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom = true;
			GameNetworkManager.Instance.localPlayerController.TeleportPlayer(GetPlayerSpawnPosition((int)GameNetworkManager.Instance.localPlayerController.playerClientId));
		}
	}

	public void SetPlayerObjectExtrapolate(bool enable)
	{
		if (enable)
		{
			localPlayerController.GetComponent<Rigidbody>().interpolation = RigidbodyInterpolation.Extrapolate;
		}
		else
		{
			localPlayerController.GetComponent<Rigidbody>().interpolation = RigidbodyInterpolation.None;
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void EndGameServerRpc(int playerClientId)
	{
		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(2028434619u, serverRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, playerClientId);
				__endSendServerRpc(ref bufferWriter, 2028434619u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost) && shipHasLanded && !shipLeftAutomatically && (!shipIsLeaving || playerClientId == 0))
			{
				UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.interactable = false;
				shipHasLanded = false;
				EndGameClientRpc(playerClientId);
			}
		}
	}

	[ClientRpc]
	public void EndGameClientRpc(int playerClientId)
	{
		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(794862467u, clientRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, playerClientId);
				__endSendClientRpc(ref bufferWriter, 794862467u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				HUDManager.Instance.AddTextToChatOnServer($"[playerNum{playerClientId}] started the ship.");
				ShipLeave();
			}
		}
	}

	private void ShipLeave()
	{
		shipHasLanded = false;
		shipIsLeaving = true;
		shipAnimator.ResetTrigger("ShipLeave");
		shipAnimator.SetTrigger("ShipLeave");
		_ = localPlayerController.isInElevator;
	}

	public void ShipHasLeft()
	{
		RoundManager.Instance.playersManager.shipDoorsAnimator.SetBool("Closed", value: true);
		UnityEngine.Object.FindObjectOfType<HangarShipDoor>().SetDoorButtonsEnabled(doorButtonsEnabled: false);
		if (base.IsServer)
		{
			StartCoroutine(unloadSceneForAllPlayers());
		}
	}

	private IEnumerator unloadSceneForAllPlayers()
	{
		yield return new WaitForSeconds(2f);
		fullyLoadedPlayers.Clear();
		base.NetworkManager.SceneManager.UnloadScene(SceneManager.GetSceneAt(1));
		yield return null;
		yield return new WaitUntil(() => fullyLoadedPlayers.Count >= GameNetworkManager.Instance.connectedPlayers);
		playersRevived = 0;
		int bodiesInShip = GetBodiesInShip();
		if (connectedPlayersAmount + 1 - livingPlayers == 0 && RoundManager.Instance.valueOfFoundScrapItems > 30)
		{
			daysPlayersSurvivedInARow++;
		}
		else
		{
			daysPlayersSurvivedInARow = 0;
		}
		EndOfGameClientRpc(bodiesInShip, daysPlayersSurvivedInARow, connectedPlayersAmount);
	}

	private int GetBodiesInShip()
	{
		int num = 0;
		DeadBodyInfo[] array = UnityEngine.Object.FindObjectsOfType<DeadBodyInfo>();
		for (int i = 0; i < array.Length; i++)
		{
			if (array[i].isInShip)
			{
				num++;
			}
		}
		return num;
	}

	[ClientRpc]
	public void EndOfGameClientRpc(int bodiesInsured, int daysPlayersSurvived, int connectedPlayersOnServer)
	{
		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(52779490u, clientRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, bodiesInsured);
			BytePacker.WriteValueBitPacked(bufferWriter, daysPlayersSurvived);
			BytePacker.WriteValueBitPacked(bufferWriter, connectedPlayersOnServer);
			__endSendClientRpc(ref bufferWriter, 52779490u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
		{
			SoundManager.Instance.playingOutsideMusic = false;
			UnityEngine.Object.FindObjectOfType<AudioListener>().enabled = true;
			if (currentLevel.planetHasTime)
			{
				WritePlayerNotes();
				HUDManager.Instance.FillEndGameStats(gameStats);
			}
			UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.animationString = "SA_PullLever";
			daysPlayersSurvivedInARow = daysPlayersSurvived;
			StartCoroutine(EndOfGame(bodiesInsured, connectedPlayersOnServer));
		}
	}

	private IEnumerator fadeVolume(float finalVolume)
	{
		float initialVolume = AudioListener.volume;
		for (int i = 0; i < 20; i++)
		{
			yield return new WaitForSeconds(0.015f);
			AudioListener.volume = Mathf.Lerp(initialVolume, finalVolume, (float)i / 20f);
		}
	}

	public void ResetStats()
	{
		for (int i = 0; i < gameStats.allPlayerStats.Length; i++)
		{
			gameStats.allPlayerStats[i].damageTaken = 0;
			gameStats.allPlayerStats[i].jumps = 0;
			gameStats.allPlayerStats[i].playerNotes.Clear();
			gameStats.allPlayerStats[i].stepsTaken = 0;
		}
	}

	public void WritePlayerNotes()
	{
		for (int i = 0; i < gameStats.allPlayerStats.Length; i++)
		{
			gameStats.allPlayerStats[i].isActivePlayer = allPlayerScripts[i].disconnectedMidGame || allPlayerScripts[i].isPlayerDead || allPlayerScripts[i].isPlayerControlled;
		}
		int num = 0;
		int num2 = 0;
		for (int j = 0; j < gameStats.allPlayerStats.Length; j++)
		{
			if (gameStats.allPlayerStats[j].isActivePlayer && (j == 0 || gameStats.allPlayerStats[j].stepsTaken < num))
			{
				num = gameStats.allPlayerStats[j].stepsTaken;
				num2 = j;
			}
		}
		if (connectedPlayersAmount > 0 && num > 10)
		{
			gameStats.allPlayerStats[num2].playerNotes.Add("The laziest employee.");
		}
		num = 0;
		for (int k = 0; k < gameStats.allPlayerStats.Length; k++)
		{
			if (gameStats.allPlayerStats[k].isActivePlayer && gameStats.allPlayerStats[k].turnAmount > num)
			{
				num = gameStats.allPlayerStats[k].turnAmount;
				num2 = k;
			}
		}
		if (connectedPlayersAmount > 0)
		{
			gameStats.allPlayerStats[num2].playerNotes.Add("The most paranoid employee.");
		}
		num = 0;
		for (int l = 0; l < gameStats.allPlayerStats.Length; l++)
		{
			if (gameStats.allPlayerStats[l].isActivePlayer && !allPlayerScripts[l].isPlayerDead && gameStats.allPlayerStats[l].damageTaken > num)
			{
				num = gameStats.allPlayerStats[l].damageTaken;
				num2 = l;
			}
		}
		if (connectedPlayersAmount > 0)
		{
			gameStats.allPlayerStats[num2].playerNotes.Add("Sustained the most injuries.");
		}
		num = 0;
		for (int m = 0; m < gameStats.allPlayerStats.Length; m++)
		{
			if (gameStats.allPlayerStats[m].isActivePlayer && gameStats.allPlayerStats[m].profitable > num)
			{
				num = gameStats.allPlayerStats[m].profitable;
				num2 = m;
			}
		}
		if (connectedPlayersAmount > 0 && num > 50)
		{
			if (num2 == (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				localPlayerWasMostProfitableThisRound = true;
			}
			gameStats.allPlayerStats[num2].playerNotes.Add("Most profitable");
		}
	}

	private IEnumerator EndOfGame(int bodiesInsured = 0, int connectedPlayersOnServer = 0)
	{
		if (!GameNetworkManager.Instance.disableSteam)
		{
			GameNetworkManager.Instance.SetSteamFriendGrouping(GameNetworkManager.Instance.steamLobbyName, connectedPlayersAmount + 1, "Orbiting " + currentLevel.PlanetName);
		}
		shipDoorsEnabled = false;
		if (currentLevel.currentWeather != LevelWeatherType.None)
		{
			WeatherEffect weatherEffect = TimeOfDay.Instance.effects[(int)currentLevel.currentWeather];
			if (weatherEffect != null && weatherEffect.effectPermanentObject != null)
			{
				weatherEffect.effectPermanentObject.SetActive(value: false);
			}
		}
		TimeOfDay.Instance.currentWeatherVariable = 0f;
		TimeOfDay.Instance.currentWeatherVariable2 = 0f;
		TimeOfDay.Instance.DisableAllWeather(deactivateObjects: true);
		TimeOfDay.Instance.currentLevelWeather = LevelWeatherType.None;
		TimeOfDay.Instance.movingGlobalTimeForward = false;
		TimeOfDay.Instance.currentDayTimeStarted = false;
		TimeOfDay.Instance.currentDayTime = 0f;
		TimeOfDay.Instance.dayMode = DayMode.Dawn;
		gameStats.daysSpent++;
		HUDManager.Instance.shipLeavingEarlyIcon.enabled = false;
		HUDManager.Instance.HideHUD(hide: true);
		HUDManager.Instance.quotaAnimator.SetBool("visible", value: false);
		yield return new WaitForSeconds(1f);
		if (currentLevel.planetHasTime)
		{
			if (isChallengeFile)
			{
				HUDManager.Instance.endgameStatsAnimator.SetTrigger("displayStatsChallenge");
			}
			else
			{
				HUDManager.Instance.endgameStatsAnimator.SetTrigger("displayStats");
			}
		}
		SwitchMapMonitorPurpose(displayInfo: true);
		yield return new WaitForSeconds(1f);
		RoundManager.Instance.DespawnPropsAtEndOfRound();
		RoundManager.Instance.scrapCollectedThisRound.Clear();
		ResetPooledObjects();
		if (currentLevel.planetHasTime)
		{
			yield return new WaitForSeconds(8f);
			HUDManager.Instance.SetPlayerLevel(GameNetworkManager.Instance.localPlayerController.isPlayerDead, localPlayerWasMostProfitableThisRound, allPlayersDead);
			if (isChallengeFile)
			{
				HUDManager.Instance.FillChallengeResultsStats();
				yield return new WaitForSeconds(2f);
			}
			displayedLevelResults = true;
		}
		localPlayerWasMostProfitableThisRound = false;
		int playersDead = connectedPlayersAmount + 1 - livingPlayers;
		ReviveDeadPlayers();
		RoundManager.Instance.ResetEnemyVariables();
		yield return new WaitForSeconds(3f);
		if (playersDead > 0 && !isChallengeFile)
		{
			HUDManager.Instance.endgameStatsAnimator.SetTrigger("displayPenalty");
			HUDManager.Instance.ApplyPenalty(playersDead, bodiesInsured);
			yield return new WaitForSeconds(4f);
		}
		PassTimeToNextDay(connectedPlayersOnServer);
		yield return new WaitForSeconds(1.7f);
		HUDManager.Instance.HideHUD(hide: false);
		shipIsLeaving = false;
		if (base.IsServer)
		{
			playersRevived++;
			yield return new WaitUntil(() => playersRevived >= GameNetworkManager.Instance.connectedPlayers);
			playersRevived = 0;
			bool flag = TimeOfDay.Instance.timeUntilDeadline <= 0f;
			if ((float)(TimeOfDay.Instance.profitQuota - TimeOfDay.Instance.quotaFulfilled) <= 0f || isChallengeFile)
			{
				if (!isChallengeFile)
				{
					TimeOfDay.Instance.SetNewProfitQuota();
				}
				AllPlayersHaveRevivedClientRpc();
			}
			else if (flag)
			{
				FirePlayersAfterDeadlineClientRpc(GetEndgameStatsInOrder());
			}
			else
			{
				AllPlayersHaveRevivedClientRpc();
			}
		}
		else
		{
			PlayerHasRevivedServerRpc();
		}
	}

	private int[] GetEndgameStatsInOrder()
	{
		return new int[4] { gameStats.daysSpent, gameStats.scrapValueCollected, gameStats.deaths, gameStats.allStepsTaken };
	}

	private void PassTimeToNextDay(int connectedPlayersOnServer = 0)
	{
		if (isChallengeFile)
		{
			TimeOfDay.Instance.globalTime = 100f;
			SetMapScreenInfoToCurrentLevel();
			return;
		}
		float num = TimeOfDay.Instance.globalTimeAtEndOfDay - TimeOfDay.Instance.globalTime;
		_ = TimeOfDay.Instance.totalTime / TimeOfDay.Instance.lengthOfHours;
		if (currentLevel.planetHasTime || TimeOfDay.Instance.daysUntilDeadline <= 0)
		{
			TimeOfDay.Instance.timeUntilDeadline -= num;
			TimeOfDay.Instance.OnDayChanged();
		}
		TimeOfDay.Instance.globalTime = 100f;
		TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
		if (currentLevel.planetHasTime)
		{
			HUDManager.Instance.DisplayDaysLeft((int)Mathf.Floor(TimeOfDay.Instance.timeUntilDeadline / TimeOfDay.Instance.totalTime));
		}
		UnityEngine.Object.FindObjectOfType<Terminal>().SetItemSales();
		SetMapScreenInfoToCurrentLevel();
		if (TimeOfDay.Instance.timeUntilDeadline > 0f && TimeOfDay.Instance.daysUntilDeadline <= 0 && TimeOfDay.Instance.timesFulfilledQuota <= 0)
		{
			StartCoroutine(playDaysLeftAlertSFXDelayed());
		}
	}

	private IEnumerator playDaysLeftAlertSFXDelayed()
	{
		yield return new WaitForSeconds(3f);
		Instance.speakerAudioSource.PlayOneShot(zeroDaysLeftAlertSFX);
	}

	[ClientRpc]
	public void AllPlayersHaveRevivedClientRpc()
	{
		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(1043433721u, clientRpcParams, RpcDelivery.Reliable);
				__endSendClientRpc(ref bufferWriter, 1043433721u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				SetShipReadyToLand();
			}
		}
	}

	private void AutoSaveShipData()
	{
		HUDManager.Instance.saveDataIconAnimatorB.SetTrigger("save");
		GameNetworkManager.Instance.SaveGame();
	}

	[ServerRpc]
	public void ManuallyEjectPlayersServerRpc()
	{
		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(1482204640u, serverRpcParams, RpcDelivery.Reliable);
			__endSendServerRpc(ref bufferWriter, 1482204640u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost) && inShipPhase && !isChallengeFile && !firingPlayersCutsceneRunning && fullyLoadedPlayers.Count >= GameNetworkManager.Instance.connectedPlayers)
		{
			GameNetworkManager.Instance.gameHasStarted = true;
			firingPlayersCutsceneRunning = true;
			FirePlayersAfterDeadlineClientRpc(GetEndgameStatsInOrder());
		}
	}

	[ClientRpc]
	public void FirePlayersAfterDeadlineClientRpc(int[] endGameStats, bool abridgedVersion = false)
	{
		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(2721053021u, clientRpcParams, RpcDelivery.Reliable);
			bool value = endGameStats != null;
			bufferWriter.WriteValueSafe(in value, default(FastBufferWriter.ForPrimitives));
			if (value)
			{
				bufferWriter.WriteValueSafe(endGameStats, default(FastBufferWriter.ForPrimitives));
			}
			bufferWriter.WriteValueSafe(in abridgedVersion, default(FastBufferWriter.ForPrimitives));
			__endSendClientRpc(ref bufferWriter, 2721053021u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
		{
			firingPlayersCutsceneRunning = true;
			if (UnityEngine.Object.FindObjectOfType<Terminal>().terminalInUse)
			{
				UnityEngine.Object.FindObjectOfType<Terminal>().QuitTerminal();
			}
			if (GameNetworkManager.Instance.localPlayerController.inSpecialInteractAnimation && GameNetworkManager.Instance.localPlayerController.currentTriggerInAnimationWith != null)
			{
				GameNetworkManager.Instance.localPlayerController.currentTriggerInAnimationWith.StopSpecialAnimation();
			}
			HUDManager.Instance.EndOfRunStatsText.text = $"Days on the job: {endGameStats[0]}\n" + $"Scrap value collected: {endGameStats[1]}\n" + $"Deaths: {endGameStats[2]}\n" + $"Steps taken: {endGameStats[3]}";
			gameStats.daysSpent = 0;
			gameStats.scrapValueCollected = 0;
			gameStats.deaths = 0;
			gameStats.allStepsTaken = 0;
			SetDiscordStatusDetails();
			StartCoroutine(playersFiredGameOver(abridgedVersion));
		}
	}

	private IEnumerator playersFiredGameOver(bool abridgedVersion)
	{
		yield return new WaitForSeconds(5f);
		shipAnimatorObject.gameObject.GetComponent<Animator>().SetBool("AlarmRinging", value: true);
		shipRoomLights.SetShipLightsOnLocalClientOnly(setLightsOn: false);
		speakerAudioSource.PlayOneShot(firedVoiceSFX);
		shipDoorAudioSource.PlayOneShot(alarmSFX);
		yield return new WaitForSeconds(9.37f);
		shipDoorsAnimator.SetBool("OpenInOrbit", value: true);
		shipDoorAudioSource.PlayOneShot(airPressureSFX);
		starSphereObject.SetActive(value: true);
		starSphereObject.transform.position = GameNetworkManager.Instance.localPlayerController.transform.position;
		yield return new WaitForSeconds(0.25f);
		suckingPlayersOutOfShip = true;
		suckingFurnitureOutOfShip = true;
		PlaceableShipObject[] array = UnityEngine.Object.FindObjectsOfType<PlaceableShipObject>();
		for (int i = 0; i < array.Length; i++)
		{
			if (array[i].parentObject == null)
			{
				Debug.Log("Error! No parentObject for placeable object: " + unlockablesList.unlockables[array[i].unlockableID].unlockableName);
			}
			array[i].parentObject.StartSuckingOutOfShip();
			if (unlockablesList.unlockables[array[i].unlockableID].spawnPrefab)
			{
				Collider[] componentsInChildren = array[i].parentObject.GetComponentsInChildren<Collider>();
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					componentsInChildren[j].enabled = false;
				}
			}
		}
		GameNetworkManager.Instance.localPlayerController.inSpecialInteractAnimation = true;
		GameNetworkManager.Instance.localPlayerController.DropAllHeldItems();
		HUDManager.Instance.UIAudio.PlayOneShot(suckedIntoSpaceSFX);
		yield return new WaitForSeconds(6f);
		SoundManager.Instance.SetDiageticMixerSnapshot(3, 2f);
		HUDManager.Instance.ShowPlayersFiredScreen(show: true);
		yield return new WaitForSeconds(2f);
		starSphereObject.SetActive(value: false);
		shipDoorAudioSource.Stop();
		speakerAudioSource.Stop();
		suckingFurnitureOutOfShip = false;
		if (base.IsServer)
		{
			GameNetworkManager.Instance.ResetSavedGameValues();
		}
		Debug.Log("Calling reset ship!");
		ResetShip();
		UnityEngine.Object.FindObjectOfType<Terminal>().SetItemSales();
		yield return new WaitForSeconds(6f);
		shipAnimatorObject.gameObject.GetComponent<Animator>().SetBool("AlarmRinging", value: false);
		GameNetworkManager.Instance.localPlayerController.TeleportPlayer(playerSpawnPositions[GameNetworkManager.Instance.localPlayerController.playerClientId].position);
		shipDoorsAnimator.SetBool("OpenInOrbit", value: false);
		currentPlanetPrefab.transform.position = planetContainer.transform.position;
		suckingPlayersOutOfShip = false;
		choseRandomFlyDirForPlayer = false;
		suckingPower = 0f;
		shipRoomLights.SetShipLightsOnLocalClientOnly(setLightsOn: true);
		yield return new WaitForSeconds(2f);
		if (base.IsServer)
		{
			playersRevived++;
			yield return new WaitUntil(() => playersRevived >= GameNetworkManager.Instance.connectedPlayers);
			playersRevived = 0;
			EndPlayersFiredSequenceClientRpc();
		}
		else
		{
			PlayerHasRevivedServerRpc();
		}
	}

	public void ResetShip()
	{
		TimeOfDay.Instance.globalTime = 100f;
		TimeOfDay.Instance.profitQuota = TimeOfDay.Instance.quotaVariables.startingQuota;
		TimeOfDay.Instance.quotaFulfilled = 0;
		TimeOfDay.Instance.timesFulfilledQuota = 0;
		TimeOfDay.Instance.timeUntilDeadline = (int)(TimeOfDay.Instance.totalTime * (float)TimeOfDay.Instance.quotaVariables.deadlineDaysAmount);
		TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
		randomMapSeed++;
		Debug.Log("Reset ship 0");
		companyBuyingRate = 0.3f;
		ChangeLevel(defaultPlanet);
		ChangePlanet();
		SetMapScreenInfoToCurrentLevel();
		Terminal terminal = UnityEngine.Object.FindObjectOfType<Terminal>();
		if (terminal != null)
		{
			terminal.groupCredits = TimeOfDay.Instance.quotaVariables.startingCredits;
		}
		if (base.IsServer)
		{
			for (int i = 0; i < unlockablesList.unlockables.Count; i++)
			{
				if (unlockablesList.unlockables[i].alreadyUnlocked || !unlockablesList.unlockables[i].spawnPrefab)
				{
					continue;
				}
				if (!SpawnedShipUnlockables.TryGetValue(i, out var value))
				{
					SpawnedShipUnlockables.Remove(i);
					continue;
				}
				if (value == null)
				{
					SpawnedShipUnlockables.Remove(i);
					continue;
				}
				SpawnedShipUnlockables.Remove(i);
				NetworkObject component = value.GetComponent<NetworkObject>();
				if (component != null && component.IsSpawned)
				{
					component.Despawn();
				}
			}
			RoundManager.Instance.DespawnPropsAtEndOfRound(despawnAllItems: true);
			closetLeftDoor.SetBoolOnClientOnly(setTo: false);
			closetRightDoor.SetBoolOnClientOnly(setTo: false);
		}
		Debug.Log("Reset ship A");
		PlaceableShipObject[] array = UnityEngine.Object.FindObjectsOfType<PlaceableShipObject>();
		for (int j = 0; j < array.Length; j++)
		{
			if (unlockablesList.unlockables[array[j].unlockableID].alreadyUnlocked && !unlockablesList.unlockables[array[j].unlockableID].spawnPrefab)
			{
				array[j].parentObject.disableObject = false;
				ShipBuildModeManager.Instance.ResetShipObjectToDefaultPosition(array[j]);
			}
		}
		Debug.Log("Reset ship B: Going to reset unlockables list!");
		GameNetworkManager.Instance.ResetUnlockablesListValues();
		Debug.Log("Reset ship C: Reset unlockables list!");
		for (int k = 0; k < unlockablesList.unlockables.Count; k++)
		{
			Debug.Log($"Unl {unlockablesList.unlockables[k].unlockableName} in stor: {unlockablesList.unlockables[k].inStorage}");
		}
		for (int l = 0; l < allPlayerScripts.Length; l++)
		{
			SoundManager.Instance.playerVoicePitchTargets[l] = 1f;
			allPlayerScripts[l].ResetPlayerBloodObjects();
			UnlockableSuit.SwitchSuitForPlayer(allPlayerScripts[l], 0);
		}
		Debug.Log("Reset ship D");
		ResetPooledObjects(destroy: true);
		TimeOfDay.Instance.OnDayChanged();
	}

	[ClientRpc]
	public void EndPlayersFiredSequenceClientRpc()
	{
		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(1068504982u, clientRpcParams, RpcDelivery.Reliable);
				__endSendClientRpc(ref bufferWriter, 1068504982u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				firingPlayersCutsceneRunning = false;
				timeAtStartOfRun = Time.realtimeSinceStartup;
				ReviveDeadPlayers();
				SoundManager.Instance.SetDiageticMixerSnapshot(0, 0.25f);
				HUDManager.Instance.ShowPlayersFiredScreen(show: false);
				GameNetworkManager.Instance.localPlayerController.inSpecialInteractAnimation = false;
				SetShipReadyToLand();
				SetDiscordStatusDetails();
				PlayFirstDayShipAnimation();
			}
		}
	}

	private void PlayFirstDayShipAnimation(bool waitForMenuToClose = false)
	{
		StartCoroutine(firstDayAnimation(waitForMenuToClose));
	}

	private IEnumerator firstDayAnimation(bool waitForMenuToClose)
	{
		yield return new WaitForSeconds(5.5f);
		if (waitForMenuToClose)
		{
			QuickMenuManager quickMenu = UnityEngine.Object.FindObjectOfType<QuickMenuManager>();
			yield return new WaitUntil(() => !quickMenu.isMenuOpen);
			yield return new WaitForSeconds(0.2f);
		}
		speakerAudioSource.PlayOneShot(shipIntroSpeechSFX);
	}

	public void DisableShipSpeaker()
	{
		DisableShipSpeakerLocalClient();
		StopShipSpeakerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
	}

	[ServerRpc(RequireOwnership = false)]
	public void StopShipSpeakerServerRpc(int playerWhoTriggered)
	{
		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(2441193238u, serverRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, playerWhoTriggered);
				__endSendServerRpc(ref bufferWriter, 2441193238u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				StopShipSpeakerClientRpc(playerWhoTriggered);
			}
		}
	}

	[ClientRpc]
	public void StopShipSpeakerClientRpc(int playerWhoTriggered)
	{
		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(907290724u, clientRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, playerWhoTriggered);
				__endSendClientRpc(ref bufferWriter, 907290724u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				DisableShipSpeakerLocalClient();
			}
		}
	}

	private void DisableShipSpeakerLocalClient()
	{
		if (speakerAudioSource.isPlaying)
		{
			speakerAudioSource.Stop();
			speakerAudioSource.PlayOneShot(disableSpeakerSFX);
		}
	}

	public void SetPlanetsWeather(int connectedPlayersOnServer = 0)
	{
		for (int i = 0; i < levels.Length; i++)
		{
			levels[i].currentWeather = LevelWeatherType.None;
			if (levels[i].overrideWeather)
			{
				levels[i].currentWeather = levels[i].overrideWeatherType;
			}
		}
		System.Random random = new System.Random(randomMapSeed + 31);
		List<SelectableLevel> list = levels.ToList();
		float num = 1f;
		if (connectedPlayersOnServer + 1 > 1 && daysPlayersSurvivedInARow > 2 && daysPlayersSurvivedInARow % 3 == 0)
		{
			num = (float)random.Next(15, 25) / 10f;
		}
		int num2 = Mathf.Clamp((int)(Mathf.Clamp(planetsWeatherRandomCurve.Evaluate((float)random.NextDouble()) * num, 0f, 1f) * (float)levels.Length), 0, levels.Length);
		for (int j = 0; j < num2; j++)
		{
			SelectableLevel selectableLevel = list[random.Next(0, list.Count)];
			if (selectableLevel.randomWeathers != null && selectableLevel.randomWeathers.Length != 0)
			{
				selectableLevel.currentWeather = selectableLevel.randomWeathers[random.Next(0, selectableLevel.randomWeathers.Length)].weatherType;
			}
			list.Remove(selectableLevel);
		}
	}

	private void SetShipReadyToLand()
	{
		if (Instance.isChallengeFile)
		{
			hasSubmittedChallengeRank = true;
			TimeOfDay.Instance.timeUntilDeadline = TimeOfDay.Instance.totalTime;
		}
		inShipPhase = true;
		shipLeftAutomatically = false;
		allScrapValueCollected = GetValueOfAllScrap();
		SetDiscordStatusDetails();
		if (currentLevel.planetHasTime && TimeOfDay.Instance.GetDayPhase(TimeOfDay.Instance.CalculatePlanetTime(currentLevel) / TimeOfDay.Instance.totalTime) == DayMode.Midnight)
		{
			UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.disabledHoverTip = "Too late on moon to land!";
		}
		else
		{
			UnityEngine.Object.FindObjectOfType<StartMatchLever>().triggerScript.interactable = true;
		}
		HUDManager.Instance.loadingText.text = "";
		AutoSaveShipData();
		StartCoroutine(playRandomShipAudio());
		SoundManager.Instance.ResetRandomSeed();
	}

	private IEnumerator playRandomShipAudio()
	{
		System.Random shipRandom = new System.Random(randomMapSeed);
		if (shipRandom.Next(0, 100) <= 4)
		{
			yield return new WaitForSeconds(shipRandom.Next(7, 35));
			if (inShipPhase)
			{
				RoundManager.PlayRandomClip(shipAmbianceAudio, shipCreakSFX, randomize: false, (float)shipRandom.Next(0, 10) / 10f);
			}
		}
	}

	private IEnumerator ResetDissonanceCommsComponent()
	{
		voiceChatModule.enabled = false;
		yield return new WaitForSeconds(3f);
		voiceChatModule.enabled = true;
		voiceChatModule.ResetMicrophoneCapture();
	}

	[ServerRpc(RequireOwnership = false)]
	public void PlayerHasRevivedServerRpc()
	{
		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(3083945322u, serverRpcParams, RpcDelivery.Reliable);
				__endSendServerRpc(ref bufferWriter, 3083945322u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				playersRevived++;
			}
		}
	}

	private IEnumerator waitingForOtherPlayersToRevive()
	{
		yield return new WaitForSeconds(2f);
		if (!inShipPhase)
		{
			HUDManager.Instance.loadingText.enabled = true;
			HUDManager.Instance.loadingText.text = "Waiting for crew...";
		}
	}

	public void ReviveDeadPlayers()
	{
		allPlayersDead = false;
		for (int i = 0; i < allPlayerScripts.Length; i++)
		{
			Debug.Log("Reviving players A");
			allPlayerScripts[i].ResetPlayerBloodObjects(allPlayerScripts[i].isPlayerDead);
			if (!allPlayerScripts[i].isPlayerDead && !allPlayerScripts[i].isPlayerControlled)
			{
				continue;
			}
			allPlayerScripts[i].isClimbingLadder = false;
			allPlayerScripts[i].ResetZAndXRotation();
			allPlayerScripts[i].thisController.enabled = true;
			allPlayerScripts[i].health = 100;
			allPlayerScripts[i].disableLookInput = false;
			Debug.Log("Reviving players B");
			if (allPlayerScripts[i].isPlayerDead)
			{
				allPlayerScripts[i].isPlayerDead = false;
				allPlayerScripts[i].isPlayerControlled = true;
				allPlayerScripts[i].isInElevator = true;
				allPlayerScripts[i].isInHangarShipRoom = true;
				allPlayerScripts[i].isInsideFactory = false;
				allPlayerScripts[i].wasInElevatorLastFrame = false;
				SetPlayerObjectExtrapolate(enable: false);
				allPlayerScripts[i].TeleportPlayer(GetPlayerSpawnPosition(i));
				allPlayerScripts[i].setPositionOfDeadPlayer = false;
				allPlayerScripts[i].DisablePlayerModel(allPlayerObjects[i], enable: true, disableLocalArms: true);
				allPlayerScripts[i].helmetLight.enabled = false;
				Debug.Log("Reviving players C");
				allPlayerScripts[i].Crouch(crouch: false);
				allPlayerScripts[i].criticallyInjured = false;
				if (allPlayerScripts[i].playerBodyAnimator != null)
				{
					allPlayerScripts[i].playerBodyAnimator.SetBool("Limp", value: false);
				}
				allPlayerScripts[i].bleedingHeavily = false;
				allPlayerScripts[i].activatingItem = false;
				allPlayerScripts[i].twoHanded = false;
				allPlayerScripts[i].inSpecialInteractAnimation = false;
				allPlayerScripts[i].disableSyncInAnimation = false;
				allPlayerScripts[i].inAnimationWithEnemy = null;
				allPlayerScripts[i].holdingWalkieTalkie = false;
				allPlayerScripts[i].speakingToWalkieTalkie = false;
				Debug.Log("Reviving players D");
				allPlayerScripts[i].isSinking = false;
				allPlayerScripts[i].isUnderwater = false;
				allPlayerScripts[i].sinkingValue = 0f;
				allPlayerScripts[i].statusEffectAudio.Stop();
				allPlayerScripts[i].DisableJetpackControlsLocally();
				allPlayerScripts[i].health = 100;
				Debug.Log("Reviving players E");
				allPlayerScripts[i].mapRadarDotAnimator.SetBool("dead", value: false);
				if (allPlayerScripts[i].IsOwner)
				{
					HUDManager.Instance.gasHelmetAnimator.SetBool("gasEmitting", value: false);
					allPlayerScripts[i].hasBegunSpectating = false;
					HUDManager.Instance.RemoveSpectateUI();
					HUDManager.Instance.gameOverAnimator.SetTrigger("revive");
					allPlayerScripts[i].hinderedMultiplier = 1f;
					allPlayerScripts[i].isMovementHindered = 0;
					allPlayerScripts[i].sourcesCausingSinking = 0;
					Debug.Log("Reviving players E2");
					allPlayerScripts[i].reverbPreset = shipReverb;
				}
			}
			Debug.Log("Reviving players F");
			SoundManager.Instance.earsRingingTimer = 0f;
			allPlayerScripts[i].voiceMuffledByEnemy = false;
			SoundManager.Instance.playerVoicePitchTargets[i] = 1f;
			SoundManager.Instance.SetPlayerPitch(1f, i);
			if (allPlayerScripts[i].currentVoiceChatIngameSettings == null)
			{
				RefreshPlayerVoicePlaybackObjects();
			}
			if (allPlayerScripts[i].currentVoiceChatIngameSettings != null)
			{
				if (allPlayerScripts[i].currentVoiceChatIngameSettings.voiceAudio == null)
				{
					allPlayerScripts[i].currentVoiceChatIngameSettings.InitializeComponents();
				}
				if (allPlayerScripts[i].currentVoiceChatIngameSettings.voiceAudio == null)
				{
					return;
				}
				allPlayerScripts[i].currentVoiceChatIngameSettings.voiceAudio.GetComponent<OccludeAudio>().overridingLowPass = false;
			}
			Debug.Log("Reviving players G");
		}
		PlayerControllerB playerControllerB = GameNetworkManager.Instance.localPlayerController;
		playerControllerB.bleedingHeavily = false;
		playerControllerB.criticallyInjured = false;
		playerControllerB.playerBodyAnimator.SetBool("Limp", value: false);
		playerControllerB.health = 100;
		HUDManager.Instance.UpdateHealthUI(100, hurtPlayer: false);
		playerControllerB.spectatedPlayerScript = null;
		HUDManager.Instance.audioListenerLowPass.enabled = false;
		Debug.Log("Reviving players H");
		SetSpectateCameraToGameOverMode(enableGameOver: false, playerControllerB);
		RagdollGrabbableObject[] array = UnityEngine.Object.FindObjectsOfType<RagdollGrabbableObject>();
		for (int j = 0; j < array.Length; j++)
		{
			if (!array[j].isHeld)
			{
				if (base.IsServer)
				{
					if (array[j].NetworkObject.IsSpawned)
					{
						array[j].NetworkObject.Despawn();
					}
					else
					{
						UnityEngine.Object.Destroy(array[j].gameObject);
					}
				}
			}
			else if (array[j].isHeld && array[j].playerHeldBy != null)
			{
				array[j].playerHeldBy.DropAllHeldItems();
			}
		}
		DeadBodyInfo[] array2 = UnityEngine.Object.FindObjectsOfType<DeadBodyInfo>();
		for (int k = 0; k < array2.Length; k++)
		{
			UnityEngine.Object.Destroy(array2[k].gameObject);
		}
		livingPlayers = connectedPlayersAmount + 1;
		allPlayersDead = false;
		UpdatePlayerVoiceEffects();
		ResetMiscValues();
	}

	private void ResetMiscValues()
	{
		shipAnimator.ResetTrigger("ShipLeave");
	}

	public void RefreshPlayerVoicePlaybackObjects()
	{
		if (GameNetworkManager.Instance == null || GameNetworkManager.Instance.localPlayerController == null)
		{
			return;
		}
		PlayerVoiceIngameSettings[] array = UnityEngine.Object.FindObjectsOfType<PlayerVoiceIngameSettings>(includeInactive: true);
		Debug.Log($"Refreshing voice playback objects. Number of voice objects found: {array.Length}");
		for (int i = 0; i < allPlayerScripts.Length; i++)
		{
			PlayerControllerB playerControllerB = allPlayerScripts[i];
			if (!playerControllerB.isPlayerControlled && !playerControllerB.isPlayerDead)
			{
				Debug.Log($"Skipping player #{i} as they are not controlled or dead");
				continue;
			}
			for (int j = 0; j < array.Length; j++)
			{
				if (array[j]._playerState == null)
				{
					array[j].FindPlayerIfNull();
					if (array[j]._playerState == null)
					{
						Debug.LogError($"Unable to connect player to voice B #{i}; {array[j].isActiveAndEnabled}; {array[j]._playerState == null}");
					}
				}
				else if (!array[j].isActiveAndEnabled)
				{
					Debug.LogError($"Unable to connect player to voice A #{i}; {array[j].isActiveAndEnabled}; {array[j]._playerState == null}");
				}
				else if (array[j]._playerState.Name == playerControllerB.gameObject.GetComponentInChildren<NfgoPlayer>().PlayerId)
				{
					Debug.Log($"Found a match for voice object #{j} and player object #{i}");
					playerControllerB.voicePlayerState = array[j]._playerState;
					playerControllerB.currentVoiceChatAudioSource = array[j].voiceAudio;
					playerControllerB.currentVoiceChatIngameSettings = array[j];
					playerControllerB.currentVoiceChatAudioSource.outputAudioMixerGroup = SoundManager.Instance.playerVoiceMixers[playerControllerB.playerClientId];
					Debug.Log($"player voice chat audiosource: {playerControllerB.currentVoiceChatAudioSource}; set audiomixer to {SoundManager.Instance.playerVoiceMixers[playerControllerB.playerClientId]} ; {playerControllerB.currentVoiceChatAudioSource.outputAudioMixerGroup} ; {playerControllerB.playerClientId}");
				}
			}
		}
	}

	public void UpdatePlayerVoiceEffects()
	{
		if (GameNetworkManager.Instance == null || GameNetworkManager.Instance.localPlayerController == null)
		{
			return;
		}
		updatePlayerVoiceInterval = 2f;
		PlayerControllerB playerControllerB = ((!GameNetworkManager.Instance.localPlayerController.isPlayerDead || !(GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript != null)) ? GameNetworkManager.Instance.localPlayerController : GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript);
		for (int i = 0; i < allPlayerScripts.Length; i++)
		{
			PlayerControllerB playerControllerB2 = allPlayerScripts[i];
			if ((!playerControllerB2.isPlayerControlled && !playerControllerB2.isPlayerDead) || playerControllerB2 == GameNetworkManager.Instance.localPlayerController)
			{
				continue;
			}
			if (playerControllerB2.voicePlayerState == null || playerControllerB2.currentVoiceChatIngameSettings._playerState == null || playerControllerB2.currentVoiceChatAudioSource == null)
			{
				RefreshPlayerVoicePlaybackObjects();
				if (playerControllerB2.voicePlayerState == null || playerControllerB2.currentVoiceChatAudioSource == null)
				{
					Debug.Log($"Was not able to access voice chat object for player #{i}; {playerControllerB2.voicePlayerState == null}; {playerControllerB2.currentVoiceChatAudioSource == null}");
					continue;
				}
			}
			AudioSource currentVoiceChatAudioSource = allPlayerScripts[i].currentVoiceChatAudioSource;
			bool flag = playerControllerB2.speakingToWalkieTalkie && playerControllerB.holdingWalkieTalkie && playerControllerB2 != playerControllerB;
			if (playerControllerB2.isPlayerDead)
			{
				currentVoiceChatAudioSource.GetComponent<AudioLowPassFilter>().enabled = false;
				currentVoiceChatAudioSource.GetComponent<AudioHighPassFilter>().enabled = false;
				currentVoiceChatAudioSource.panStereo = 0f;
				SoundManager.Instance.playerVoicePitchTargets[playerControllerB2.playerClientId] = 1f;
				SoundManager.Instance.SetPlayerPitch(1f, (int)playerControllerB2.playerClientId);
				if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
				{
					currentVoiceChatAudioSource.spatialBlend = 0f;
					playerControllerB2.currentVoiceChatIngameSettings.set2D = true;
					playerControllerB2.voicePlayerState.Volume = 1f;
				}
				else
				{
					currentVoiceChatAudioSource.spatialBlend = 1f;
					playerControllerB2.currentVoiceChatIngameSettings.set2D = false;
					playerControllerB2.voicePlayerState.Volume = 0f;
				}
				continue;
			}
			AudioLowPassFilter component = currentVoiceChatAudioSource.GetComponent<AudioLowPassFilter>();
			OccludeAudio component2 = currentVoiceChatAudioSource.GetComponent<OccludeAudio>();
			component.enabled = true;
			component2.overridingLowPass = flag || allPlayerScripts[i].voiceMuffledByEnemy;
			currentVoiceChatAudioSource.GetComponent<AudioHighPassFilter>().enabled = flag;
			if (!flag)
			{
				currentVoiceChatAudioSource.spatialBlend = 1f;
				playerControllerB2.currentVoiceChatIngameSettings.set2D = false;
				currentVoiceChatAudioSource.bypassListenerEffects = false;
				currentVoiceChatAudioSource.bypassEffects = false;
				currentVoiceChatAudioSource.outputAudioMixerGroup = SoundManager.Instance.playerVoiceMixers[playerControllerB2.playerClientId];
				component.lowpassResonanceQ = 1f;
			}
			else
			{
				currentVoiceChatAudioSource.spatialBlend = 0f;
				playerControllerB2.currentVoiceChatIngameSettings.set2D = true;
				if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
				{
					currentVoiceChatAudioSource.panStereo = 0f;
					currentVoiceChatAudioSource.outputAudioMixerGroup = SoundManager.Instance.playerVoiceMixers[playerControllerB2.playerClientId];
					currentVoiceChatAudioSource.bypassListenerEffects = false;
					currentVoiceChatAudioSource.bypassEffects = false;
				}
				else
				{
					currentVoiceChatAudioSource.panStereo = 0.4f;
					currentVoiceChatAudioSource.bypassListenerEffects = false;
					currentVoiceChatAudioSource.bypassEffects = false;
					currentVoiceChatAudioSource.outputAudioMixerGroup = SoundManager.Instance.playerVoiceMixers[playerControllerB2.playerClientId];
				}
				component2.lowPassOverride = 4000f;
				component.lowpassResonanceQ = 3f;
			}
			if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
			{
				playerControllerB2.voicePlayerState.Volume = 0.8f;
			}
			else
			{
				playerControllerB2.voicePlayerState.Volume = 1f;
			}
		}
	}

	[ServerRpc]
	public void SetShipDoorsOverheatServerRpc()
	{
		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(2578118202u, serverRpcParams, RpcDelivery.Reliable);
			__endSendServerRpc(ref bufferWriter, 2578118202u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
		{
			SetShipDoorsOverheatClientRpc();
		}
	}

	[ClientRpc]
	public void SetShipDoorsOverheatClientRpc()
	{
		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(1864501499u, clientRpcParams, RpcDelivery.Reliable);
				__endSendClientRpc(ref bufferWriter, 1864501499u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsServer)
			{
				HangarShipDoor hangarShipDoor = UnityEngine.Object.FindObjectOfType<HangarShipDoor>();
				hangarShipDoor.PlayDoorAnimation(closed: false);
				hangarShipDoor.overheated = true;
				hangarShipDoor.triggerScript.interactable = false;
			}
		}
	}

	public void SetShipDoorsClosed(bool closed)
	{
		hangarDoorsClosed = closed;
		SetPlayerSafeInShip();
	}

	[ServerRpc(RequireOwnership = false)]
	public void SetDoorsClosedServerRpc(bool closed)
	{
		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(430165634u, serverRpcParams, RpcDelivery.Reliable);
				bufferWriter.WriteValueSafe(in closed, default(FastBufferWriter.ForPrimitives));
				__endSendServerRpc(ref bufferWriter, 430165634u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				SetDoorsClosedClientRpc(closed);
			}
		}
	}

	[ClientRpc]
	public void SetDoorsClosedClientRpc(bool closed)
	{
		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(2810194347u, clientRpcParams, RpcDelivery.Reliable);
				bufferWriter.WriteValueSafe(in closed, default(FastBufferWriter.ForPrimitives));
				__endSendClientRpc(ref bufferWriter, 2810194347u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				SetShipDoorsClosed(closed);
			}
		}
	}

	public void SetPlayerSafeInShip()
	{
		if (GameNetworkManager.Instance == null || GameNetworkManager.Instance.localPlayerController == null)
		{
			return;
		}
		PlayerControllerB playerControllerB = GameNetworkManager.Instance.localPlayerController;
		if (playerControllerB.isPlayerDead && playerControllerB.spectatedPlayerScript != null)
		{
			playerControllerB = playerControllerB.spectatedPlayerScript;
		}
		EnemyAI[] array = UnityEngine.Object.FindObjectsOfType<EnemyAI>();
		if (hangarDoorsClosed && GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom)
		{
			for (int i = 0; i < array.Length; i++)
			{
				array[i].EnableEnemyMesh(array[i].isInsidePlayerShip);
			}
		}
		else
		{
			for (int j = 0; j < array.Length; j++)
			{
				array[j].EnableEnemyMesh(enable: true);
			}
		}
	}

	public bool CanChangeLevels()
	{
		if (!travellingToNewLevel)
		{
			return inShipPhase;
		}
		return false;
	}

	[ServerRpc(RequireOwnership = false)]
	public void ChangeLevelServerRpc(int levelID, int newGroupCreditsAmount)
	{
		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(1134466287u, serverRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, levelID);
			BytePacker.WriteValueBitPacked(bufferWriter, newGroupCreditsAmount);
			__endSendServerRpc(ref bufferWriter, 1134466287u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
		{
			Debug.Log($"Changing level server rpc {levelID}");
			if (!travellingToNewLevel && inShipPhase && newGroupCreditsAmount <= UnityEngine.Object.FindObjectOfType<Terminal>().groupCredits && !isChallengeFile)
			{
				UnityEngine.Object.FindObjectOfType<Terminal>().groupCredits = newGroupCreditsAmount;
				travellingToNewLevel = true;
				ChangeLevelClientRpc(levelID, newGroupCreditsAmount);
			}
			else
			{
				CancelChangeLevelClientRpc(UnityEngine.Object.FindObjectOfType<Terminal>().groupCredits);
			}
		}
	}

	[ClientRpc]
	public void CancelChangeLevelClientRpc(int groupCreditsAmount)
	{
		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(3896714546u, clientRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, groupCreditsAmount);
				__endSendClientRpc(ref bufferWriter, 3896714546u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				UnityEngine.Object.FindObjectOfType<Terminal>().groupCredits = groupCreditsAmount;
				UnityEngine.Object.FindObjectOfType<Terminal>().useCreditsCooldown = false;
			}
		}
	}

	[ClientRpc]
	public void ChangeLevelClientRpc(int levelID, int newGroupCreditsAmount)
	{
		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(167566585u, clientRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, levelID);
			BytePacker.WriteValueBitPacked(bufferWriter, newGroupCreditsAmount);
			__endSendClientRpc(ref bufferWriter, 167566585u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
		{
			UnityEngine.Object.FindObjectOfType<Terminal>().useCreditsCooldown = false;
			ChangeLevel(levelID);
			travellingToNewLevel = true;
			if (shipTravelCoroutine != null)
			{
				StopCoroutine(shipTravelCoroutine);
			}
			shipTravelCoroutine = StartCoroutine(TravelToLevelEffects());
			if (!base.IsServer)
			{
				UnityEngine.Object.FindObjectOfType<Terminal>().groupCredits = newGroupCreditsAmount;
			}
		}
	}

	public void ChangeLevel(int levelID)
	{
		Debug.Log($"level id: {levelID}");
		Debug.Log("Changing level");
		currentLevel = levels[levelID];
		currentLevelID = levelID;
		TimeOfDay.Instance.currentLevel = currentLevel;
		RoundManager.Instance.currentLevel = levels[levelID];
		SoundManager.Instance.ResetSoundType();
	}

	private IEnumerator TravelToLevelEffects()
	{
		StartMatchLever lever = UnityEngine.Object.FindObjectOfType<StartMatchLever>();
		lever.triggerScript.interactable = false;
		shipAmbianceAudio.PlayOneShot(shipDepartSFX);
		currentPlanetAnimator.SetTrigger("FlyAway");
		shipAnimatorObject.gameObject.GetComponent<Animator>().SetBool("FlyingToNewPlanet", value: true);
		HUDManager.Instance.ShakeCamera(ScreenShakeType.Long);
		yield return new WaitForSeconds(2f);
		if (currentPlanetPrefab != null)
		{
			UnityEngine.Object.Destroy(currentPlanetPrefab);
		}
		yield return new WaitForSeconds(currentLevel.timeToArrive);
		ArriveAtLevel();
		if (base.IsServer || GameNetworkManager.Instance.gameHasStarted)
		{
			lever.triggerScript.interactable = true;
		}
		for (int i = 0; i < 20; i++)
		{
			shipAmbianceAudio.volume -= 0.05f;
			yield return null;
		}
		yield return new WaitForSeconds(0.02f);
		shipAmbianceAudio.Stop();
		shipAmbianceAudio.volume = 1f;
		shipAmbianceAudio.PlayOneShot(shipArriveSFX);
	}

	public void ArriveAtLevel()
	{
		Debug.Log($"Level id: {currentLevel.levelID}");
		TimeOfDay timeOfDay = UnityEngine.Object.FindObjectOfType<TimeOfDay>();
		outerSpaceSunAnimator.SetFloat("currentTime", timeOfDay.CalculatePlanetTime(currentLevel) / timeOfDay.totalTime + 1f);
		timeOfDay.currentLevel = currentLevel;
		travellingToNewLevel = false;
		ChangePlanet();
		currentPlanetAnimator.SetTrigger("FlyTo");
		shipAnimatorObject.gameObject.GetComponent<Animator>().SetBool("FlyingToNewPlanet", value: false);
		SetMapScreenInfoToCurrentLevel();
		UnityEngine.Object.FindObjectOfType<StartMatchLever>().hasDisplayedTimeWarning = false;
		if (!GameNetworkManager.Instance.disableSteam)
		{
			GameNetworkManager.Instance.SetSteamFriendGrouping(GameNetworkManager.Instance.steamLobbyName, connectedPlayersAmount + 1, "Orbiting " + currentLevel.PlanetName);
		}
		SetDiscordStatusDetails();
	}

	public void ChangePlanet()
	{
		if (currentPlanetPrefab != null)
		{
			UnityEngine.Object.Destroy(currentPlanetPrefab);
		}
		currentPlanetPrefab = UnityEngine.Object.Instantiate(currentLevel.planetPrefab, planetContainer, worldPositionStays: false);
		currentPlanetAnimator = currentPlanetPrefab.GetComponentInChildren<Animator>();
		UnityEngine.Object.FindObjectOfType<TimeOfDay>().currentLevel = currentLevel;
		SetMapScreenInfoToCurrentLevel();
	}

	public void SetMapScreenInfoToCurrentLevel()
	{
		screenLevelVideoReel.enabled = false;
		screenLevelVideoReel.gameObject.SetActive(value: false);
		screenLevelVideoReel.clip = currentLevel.videoReel;
		TimeOfDay timeOfDay = UnityEngine.Object.FindObjectOfType<TimeOfDay>();
		if (timeOfDay.totalTime == 0f)
		{
			timeOfDay.totalTime = (float)timeOfDay.numberOfHours * timeOfDay.lengthOfHours;
		}
		string text = ((currentLevel.currentWeather == LevelWeatherType.None) ? "" : ("Weather: " + currentLevel.currentWeather));
		string levelDescription = currentLevel.LevelDescription;
		if (isChallengeFile)
		{
			screenLevelDescription.text = "Orbiting: " + GameNetworkManager.Instance.GetNameForWeekNumber() + "\n" + levelDescription + "\n" + text;
		}
		else
		{
			screenLevelDescription.text = "Orbiting: " + currentLevel.PlanetName + "\n" + levelDescription + "\n" + text;
		}
		mapScreen.overrideCameraForOtherUse = true;
		mapScreen.cam.transform.position = new Vector3(0f, 100f, 0f);
		screenLevelDescription.enabled = true;
		if (currentLevel.videoReel != null && !isChallengeFile)
		{
			screenLevelVideoReel.enabled = true;
			screenLevelVideoReel.gameObject.SetActive(value: true);
			screenLevelVideoReel.Play();
		}
	}

	public void SwitchMapMonitorPurpose(bool displayInfo = false)
	{
		if (displayInfo)
		{
			screenLevelVideoReel.enabled = true;
			screenLevelVideoReel.gameObject.SetActive(value: true);
			screenLevelDescription.enabled = true;
			mapScreenPlayerName.enabled = false;
			mapScreen.overrideCameraForOtherUse = true;
			mapScreen.SwitchScreenOn();
			mapScreen.cam.enabled = true;
			Terminal terminal = UnityEngine.Object.FindObjectOfType<Terminal>();
			terminal.displayingPersistentImage = null;
			terminal.terminalImage.enabled = false;
		}
		else
		{
			screenLevelVideoReel.enabled = false;
			screenLevelVideoReel.gameObject.SetActive(value: false);
			screenLevelDescription.enabled = false;
			mapScreenPlayerName.enabled = true;
			mapScreen.overrideCameraForOtherUse = false;
		}
	}

	public void PowerSurgeShip()
	{
		mapScreen.SwitchScreenOn(on: false);
		if (base.IsServer)
		{
			if ((bool)UnityEngine.Object.FindObjectOfType<TVScript>())
			{
				UnityEngine.Object.FindObjectOfType<TVScript>().TurnOffTVServerRpc();
			}
			shipRoomLights.SetShipLightsServerRpc(setLightsOn: false);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void SyncCompanyBuyingRateServerRpc()
	{
		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(2249588995u, serverRpcParams, RpcDelivery.Reliable);
				__endSendServerRpc(ref bufferWriter, 2249588995u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				SyncCompanyBuyingRateClientRpc(companyBuyingRate);
			}
		}
	}

	[ClientRpc]
	public void SyncCompanyBuyingRateClientRpc(float buyingRate)
	{
		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(3519313816u, clientRpcParams, RpcDelivery.Reliable);
				bufferWriter.WriteValueSafe(in buyingRate, default(FastBufferWriter.ForPrimitives));
				__endSendClientRpc(ref bufferWriter, 3519313816u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
			{
				companyBuyingRate = buyingRate;
			}
		}
	}

	private void TeleportPlayerInShipIfOutOfRoomBounds()
	{
		if (!(testRoom != null) && !shipInnerRoomBounds.bounds.Contains(GameNetworkManager.Instance.localPlayerController.transform.position))
		{
			GameNetworkManager.Instance.localPlayerController.TeleportPlayer(GetPlayerSpawnPosition((int)GameNetworkManager.Instance.localPlayerController.playerClientId, simpleTeleport: true));
		}
	}

	public void LateUpdate()
	{
		if (GameNetworkManager.Instance == null || GameNetworkManager.Instance.localPlayerController == null)
		{
			return;
		}
		if (updatePlayerVoiceInterval > 5f)
		{
			updatePlayerVoiceInterval = 0f;
			UpdatePlayerVoiceEffects();
		}
		else
		{
			updatePlayerVoiceInterval += Time.deltaTime;
		}
		if (!inShipPhase && shipDoorsEnabled && !suckingPlayersOutOfShip)
		{
			if (GameNetworkManager.Instance.localPlayerController.transform.position.y < -600f)
			{
				GameNetworkManager.Instance.localPlayerController.KillPlayer(Vector3.zero, spawnBody: false, CauseOfDeath.Gravity);
			}
			else if (GameNetworkManager.Instance.localPlayerController.isInElevator && !shipBounds.bounds.Contains(GameNetworkManager.Instance.localPlayerController.transform.position) && GameNetworkManager.Instance.localPlayerController.thisController.isGrounded)
			{
				GameNetworkManager.Instance.localPlayerController.SetAllItemsInElevator(inShipRoom: false, inElevator: false);
				GameNetworkManager.Instance.localPlayerController.isInElevator = false;
				GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom = false;
			}
			else if (!GameNetworkManager.Instance.localPlayerController.isInElevator && shipBounds.bounds.Contains(GameNetworkManager.Instance.localPlayerController.transform.position) && GameNetworkManager.Instance.localPlayerController.thisController.isGrounded)
			{
				GameNetworkManager.Instance.localPlayerController.isInElevator = true;
				if (shipInnerRoomBounds.bounds.Contains(GameNetworkManager.Instance.localPlayerController.transform.position) && GameNetworkManager.Instance.localPlayerController.thisController.isGrounded)
				{
					GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom = true;
				}
				else
				{
					GameNetworkManager.Instance.localPlayerController.SetAllItemsInElevator(inShipRoom: false, inElevator: true);
				}
			}
		}
		else if (!suckingPlayersOutOfShip)
		{
			TeleportPlayerInShipIfOutOfRoomBounds();
		}
		if (suckingPlayersOutOfShip)
		{
			starSphereObject.transform.position = GameNetworkManager.Instance.localPlayerController.transform.position;
			currentPlanetPrefab.transform.position = GameNetworkManager.Instance.localPlayerController.transform.position + new Vector3(-101f, -65f, 160f);
		}
		if (fearLevelIncreasing)
		{
			fearLevelIncreasing = false;
		}
		else if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
		{
			fearLevel -= Time.deltaTime * 0.5f;
		}
		else
		{
			fearLevel -= Time.deltaTime * 0.055f;
		}
	}

	public override void OnDestroy()
	{
		base.OnDestroy();
	}

	[ServerRpc]
	public void Debug_EnableTestRoomServerRpc(bool enable)
	{
		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(3050994254u, serverRpcParams, RpcDelivery.Reliable);
			bufferWriter.WriteValueSafe(in enable, default(FastBufferWriter.ForPrimitives));
			__endSendServerRpc(ref bufferWriter, 3050994254u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Server || (!networkManager.IsServer && !networkManager.IsHost) || !Application.isEditor)
		{
			return;
		}
		if (enable)
		{
			testRoom = UnityEngine.Object.Instantiate(testRoomPrefab, testRoomSpawnPosition.position, testRoomSpawnPosition.rotation, testRoomSpawnPosition);
			testRoom.GetComponent<NetworkObject>().Spawn();
		}
		else if (Instance.testRoom != null)
		{
			if (!testRoom.GetComponent<NetworkObject>().IsSpawned)
			{
				UnityEngine.Object.Destroy(testRoom);
			}
			else
			{
				testRoom.GetComponent<NetworkObject>().Despawn();
			}
		}
		if (enable)
		{
			Debug_EnableTestRoomClientRpc(enable, testRoom.GetComponent<NetworkObject>());
		}
		else
		{
			Debug_EnableTestRoomClientRpc(enable);
		}
	}

	public bool IsClientFriendsWithHost()
	{
		if (!GameNetworkManager.Instance.disableSteam && !NetworkManager.Singleton.IsServer)
		{
			SteamFriends.GetFriends().ToList();
			Friend friend = new Friend(allPlayerScripts[0].playerSteamId);
			Debug.Log($"Host steam friend id: {allPlayerScripts[0].playerSteamId}, user: {friend.Name}; is friend?: {friend.IsFriend}");
			if (!friend.IsFriend)
			{
				return false;
			}
		}
		return true;
	}

	[ClientRpc]
	public void Debug_EnableTestRoomClientRpc(bool enable, NetworkObjectReference objectRef = default(NetworkObjectReference))
	{
		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(375322246u, clientRpcParams, RpcDelivery.Reliable);
			bufferWriter.WriteValueSafe(in enable, default(FastBufferWriter.ForPrimitives));
			bufferWriter.WriteValueSafe(in objectRef, default(FastBufferWriter.ForNetworkSerializable));
			__endSendClientRpc(ref bufferWriter, 375322246u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !(GameNetworkManager.Instance.localPlayerController == null) && IsClientFriendsWithHost())
		{
			QuickMenuManager quickMenuManager = UnityEngine.Object.FindObjectOfType<QuickMenuManager>();
			for (int i = 0; i < quickMenuManager.doorGameObjects.Length; i++)
			{
				quickMenuManager.doorGameObjects[i].SetActive(!enable);
			}
			quickMenuManager.outOfBoundsCollider.enabled = !enable;
			if (enable)
			{
				StartCoroutine(SetTestRoomDebug(objectRef));
			}
			else if (testRoom != null)
			{
				UnityEngine.Object.Destroy(testRoom);
			}
		}
	}

	private IEnumerator SetTestRoomDebug(NetworkObjectReference objectRef)
	{
		NetworkObject testRoomNetObject = null;
		yield return new WaitUntil(() => objectRef.TryGet(out testRoomNetObject));
		if (!(testRoomNetObject == null))
		{
			Instance.testRoom = testRoomNetObject.gameObject;
		}
	}

	[ServerRpc]
	public void Debug_ToggleAllowDeathServerRpc()
	{
		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(3186641109u, serverRpcParams, RpcDelivery.Reliable);
			__endSendServerRpc(ref bufferWriter, 3186641109u, serverRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost) && Application.isEditor)
		{
			allowLocalPlayerDeath = !allowLocalPlayerDeath;
			Debug_ToggleAllowDeathClientRpc(allowLocalPlayerDeath);
		}
	}

	[ClientRpc]
	public void Debug_ToggleAllowDeathClientRpc(bool allowDeath)
	{
		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(348115853u, clientRpcParams, RpcDelivery.Reliable);
				bufferWriter.WriteValueSafe(in allowDeath, default(FastBufferWriter.ForPrimitives));
				__endSendClientRpc(ref bufferWriter, 348115853u, clientRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && IsClientFriendsWithHost() && !base.IsServer)
			{
				allowLocalPlayerDeath = allowDeath;
			}
		}
	}

	public void SetDiscordStatusDetails()
	{
		if (DiscordController.Instance == null || GameNetworkManager.Instance.disableSteam)
		{
			return;
		}
		DiscordController.Instance.status_largeText = "";
		if (currentLevel != null)
		{
			if (firingPlayersCutsceneRunning)
			{
				DiscordController.Instance.status_Details = "Getting fired";
				DiscordController.Instance.status_largeImage = "mapfired";
			}
			else if (!GameNetworkManager.Instance.gameHasStarted)
			{
				DiscordController.Instance.status_Details = "In orbit (Waiting for crew)";
				DiscordController.Instance.status_largeImage = "mapshipicon";
			}
			else if (inShipPhase)
			{
				DiscordController.Instance.status_Details = "Orbiting " + currentLevel.PlanetName;
				DiscordController.Instance.status_largeImage = "mapshipicon";
			}
			else
			{
				DiscordController.Instance.status_Details = HUDManager.Instance.SetClock(TimeOfDay.Instance.normalizedTimeOfDay, TimeOfDay.Instance.numberOfHours, createNewLine: false);
				DiscordController.Instance.status_largeText = "On " + currentLevel.PlanetName;
				if (currentLevel.levelIconString != "")
				{
					DiscordController.Instance.status_largeImage = currentLevel.levelIconString;
				}
			}
			if (GameNetworkManager.Instance.localPlayerController != null)
			{
				if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
				{
					DiscordController.Instance.status_smallText = "Deceased";
					DiscordController.Instance.status_smallImage = "faceiconwhitev1big";
				}
				else
				{
					DiscordController.Instance.status_smallText = "";
					DiscordController.Instance.status_smallImage = "faceiconorangev1big";
				}
			}
		}
		else
		{
			DiscordController.Instance.status_Details = "In orbit";
			DiscordController.Instance.status_smallText = "";
			DiscordController.Instance.status_smallImage = "faceiconorangev1big";
		}
		DiscordController.Instance.currentPartySize = connectedPlayersAmount + 1;
		DiscordController.Instance.maxPartySize = GameNetworkManager.Instance.maxAllowedPlayers;
		if (RoundManager.Instance != null && inShipPhase)
		{
			float num = (float)GetValueOfAllScrap() / (float)TimeOfDay.Instance.profitQuota * 100f;
			DiscordController.Instance.status_State = $"{(int)num}% of quota | {TimeOfDay.Instance.daysUntilDeadline} days left";
		}
		DiscordController.Instance.timeElapsed = (int)(Time.realtimeSinceStartup - timeAtStartOfRun) / 60;
		if (GameNetworkManager.Instance.currentLobby.HasValue)
		{
			DiscordController.Instance.status_partyId = Convert.ToString(GameNetworkManager.Instance.currentLobby.Value.Owner.Id);
		}
		DiscordController.Instance.UpdateStatus(clear: false);
	}

	public int GetValueOfAllScrap(bool onlyScrapCollected = true)
	{
		GrabbableObject[] array = UnityEngine.Object.FindObjectsOfType<GrabbableObject>();
		int num = 0;
		for (int i = 0; i < array.Length; i++)
		{
			if (array[i].itemProperties.isScrap && !array[i].deactivated && !array[i].itemUsedUp && (array[i].isInShipRoom || !onlyScrapCollected))
			{
				num += array[i].scrapValue;
			}
		}
		return num;
	}

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

	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeRPCS_StartOfRound()
	{
		NetworkManager.__rpc_func_table.Add(4249638645u, __rpc_handler_4249638645);
		NetworkManager.__rpc_func_table.Add(462348217u, __rpc_handler_462348217);
		NetworkManager.__rpc_func_table.Add(161788012u, __rpc_handler_161788012);
		NetworkManager.__rpc_func_table.Add(3953483456u, __rpc_handler_3953483456);
		NetworkManager.__rpc_func_table.Add(418581783u, __rpc_handler_418581783);
		NetworkManager.__rpc_func_table.Add(3380566632u, __rpc_handler_3380566632);
		NetworkManager.__rpc_func_table.Add(1076853239u, __rpc_handler_1076853239);
		NetworkManager.__rpc_func_table.Add(1846610026u, __rpc_handler_1846610026);
		NetworkManager.__rpc_func_table.Add(2369901769u, __rpc_handler_2369901769);
		NetworkManager.__rpc_func_table.Add(475465488u, __rpc_handler_475465488);
		NetworkManager.__rpc_func_table.Add(886676601u, __rpc_handler_886676601);
		NetworkManager.__rpc_func_table.Add(682230258u, __rpc_handler_682230258);
		NetworkManager.__rpc_func_table.Add(1613265729u, __rpc_handler_1613265729);
		NetworkManager.__rpc_func_table.Add(744998938u, __rpc_handler_744998938);
		NetworkManager.__rpc_func_table.Add(4156335180u, __rpc_handler_4156335180);
		NetworkManager.__rpc_func_table.Add(1089447320u, __rpc_handler_1089447320);
		NetworkManager.__rpc_func_table.Add(2028434619u, __rpc_handler_2028434619);
		NetworkManager.__rpc_func_table.Add(794862467u, __rpc_handler_794862467);
		NetworkManager.__rpc_func_table.Add(52779490u, __rpc_handler_52779490);
		NetworkManager.__rpc_func_table.Add(1043433721u, __rpc_handler_1043433721);
		NetworkManager.__rpc_func_table.Add(1482204640u, __rpc_handler_1482204640);
		NetworkManager.__rpc_func_table.Add(2721053021u, __rpc_handler_2721053021);
		NetworkManager.__rpc_func_table.Add(1068504982u, __rpc_handler_1068504982);
		NetworkManager.__rpc_func_table.Add(2441193238u, __rpc_handler_2441193238);
		NetworkManager.__rpc_func_table.Add(907290724u, __rpc_handler_907290724);
		NetworkManager.__rpc_func_table.Add(3083945322u, __rpc_handler_3083945322);
		NetworkManager.__rpc_func_table.Add(2578118202u, __rpc_handler_2578118202);
		NetworkManager.__rpc_func_table.Add(1864501499u, __rpc_handler_1864501499);
		NetworkManager.__rpc_func_table.Add(430165634u, __rpc_handler_430165634);
		NetworkManager.__rpc_func_table.Add(2810194347u, __rpc_handler_2810194347);
		NetworkManager.__rpc_func_table.Add(1134466287u, __rpc_handler_1134466287);
		NetworkManager.__rpc_func_table.Add(3896714546u, __rpc_handler_3896714546);
		NetworkManager.__rpc_func_table.Add(167566585u, __rpc_handler_167566585);
		NetworkManager.__rpc_func_table.Add(2249588995u, __rpc_handler_2249588995);
		NetworkManager.__rpc_func_table.Add(3519313816u, __rpc_handler_3519313816);
		NetworkManager.__rpc_func_table.Add(3050994254u, __rpc_handler_3050994254);
		NetworkManager.__rpc_func_table.Add(375322246u, __rpc_handler_375322246);
		NetworkManager.__rpc_func_table.Add(3186641109u, __rpc_handler_3186641109);
		NetworkManager.__rpc_func_table.Add(348115853u, __rpc_handler_348115853);
	}

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

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

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

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

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

	private static void __rpc_handler_3380566632(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;
			((StartOfRound)target).ReturnUnlockableFromStorageServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1076853239(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;
			((StartOfRound)target).ReturnUnlockableFromStorageClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1846610026(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;
			((StartOfRound)target).SyncSuitsServerRpc();
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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

	private static void __rpc_handler_475465488(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 ulong value2);
			ClientRpcParams client = rpcParams.Client;
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((StartOfRound)target).OnClientDisconnectClientRpc(value, value2, client);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_886676601(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			ByteUnpacker.ReadValueBitPacked(reader, out ulong value);
			ByteUnpacker.ReadValueBitPacked(reader, out int value2);
			reader.ReadValueSafe(out bool value3, default(FastBufferWriter.ForPrimitives));
			ulong[] value4 = null;
			if (value3)
			{
				reader.ReadValueSafe(out value4, default(FastBufferWriter.ForPrimitives));
			}
			ByteUnpacker.ReadValueBitPacked(reader, out int value5);
			ByteUnpacker.ReadValueBitPacked(reader, out int value6);
			ByteUnpacker.ReadValueBitPacked(reader, out int value7);
			ByteUnpacker.ReadValueBitPacked(reader, out int value8);
			ByteUnpacker.ReadValueBitPacked(reader, out int value9);
			ByteUnpacker.ReadValueBitPacked(reader, out int value10);
			ByteUnpacker.ReadValueBitPacked(reader, out int value11);
			reader.ReadValueSafe(out bool value12, default(FastBufferWriter.ForPrimitives));
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((StartOfRound)target).OnPlayerConnectedClientRpc(value, value2, value4, value5, value6, value7, value8, value9, value10, value11, value12);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_682230258(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;
			((StartOfRound)target).SyncAlreadyHeldObjectsServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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

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

	private static void __rpc_handler_4156335180(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));
			reader.ReadValueSafe(out bool value4, default(FastBufferWriter.ForPrimitives));
			Vector3[] value5 = null;
			if (value4)
			{
				reader.ReadValueSafe(out value5);
			}
			reader.ReadValueSafe(out bool value6, default(FastBufferWriter.ForPrimitives));
			Vector3[] value7 = null;
			if (value6)
			{
				reader.ReadValueSafe(out value7);
			}
			reader.ReadValueSafe(out bool value8, default(FastBufferWriter.ForPrimitives));
			int[] value9 = null;
			if (value8)
			{
				reader.ReadValueSafe(out value9, default(FastBufferWriter.ForPrimitives));
			}
			reader.ReadValueSafe(out bool value10, default(FastBufferWriter.ForPrimitives));
			int[] value11 = null;
			if (value10)
			{
				reader.ReadValueSafe(out value11, default(FastBufferWriter.ForPrimitives));
			}
			reader.ReadValueSafe(out bool value12, default(FastBufferWriter.ForPrimitives));
			int[] value13 = null;
			if (value12)
			{
				reader.ReadValueSafe(out value13, default(FastBufferWriter.ForPrimitives));
			}
			reader.ReadValueSafe(out bool value14, default(FastBufferWriter.ForPrimitives));
			int[] value15 = null;
			if (value14)
			{
				reader.ReadValueSafe(out value15, default(FastBufferWriter.ForPrimitives));
			}
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((StartOfRound)target).SyncShipUnlockablesClientRpc(value2, value3, value5, value7, value9, value11, value13, value15);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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

	private static void __rpc_handler_2028434619(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;
			((StartOfRound)target).EndGameServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_794862467(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;
			((StartOfRound)target).EndGameClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_52779490(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);
			ByteUnpacker.ReadValueBitPacked(reader, out int value3);
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((StartOfRound)target).EndOfGameClientRpc(value, value2, value3);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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

	private static void __rpc_handler_1482204640(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;
			((StartOfRound)target).ManuallyEjectPlayersServerRpc();
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_2721053021(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));
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((StartOfRound)target).FirePlayersAfterDeadlineClientRpc(value2, value3);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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

	private static void __rpc_handler_2441193238(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;
			((StartOfRound)target).StopShipSpeakerServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_907290724(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;
			((StartOfRound)target).StopShipSpeakerClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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

	private static void __rpc_handler_2578118202(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;
			((StartOfRound)target).SetShipDoorsOverheatServerRpc();
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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

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

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

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

	private static void __rpc_handler_3896714546(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;
			((StartOfRound)target).CancelChangeLevelClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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

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

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

	private static void __rpc_handler_3050994254(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
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((StartOfRound)target).Debug_EnableTestRoomServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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

	private static void __rpc_handler_3186641109(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;
			((StartOfRound)target).Debug_ToggleAllowDeathServerRpc();
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

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

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