428 lines
12 KiB
C#
428 lines
12 KiB
C#
using System.Collections;
|
|
using GameNetcodeStuff;
|
|
using Unity.Netcode;
|
|
using UnityEngine;
|
|
|
|
public class ManualCameraRenderer : NetworkBehaviour
|
|
{
|
|
public Camera cam;
|
|
|
|
public CameraView[] cameraViews;
|
|
|
|
public int cameraViewIndex;
|
|
|
|
public bool currentCameraDisabled;
|
|
|
|
[Space(5f)]
|
|
public MeshRenderer mesh;
|
|
|
|
public Material offScreenMat;
|
|
|
|
public Material onScreenMat;
|
|
|
|
public int materialIndex;
|
|
|
|
private bool isScreenOn;
|
|
|
|
public bool overrideCameraForOtherUse;
|
|
|
|
public bool renderAtLowerFramerate;
|
|
|
|
public float fps = 60f;
|
|
|
|
private float elapsed;
|
|
|
|
public PlayerControllerB targetPlayer;
|
|
|
|
public int targetPlayerIndex;
|
|
|
|
public Camera mapCamera;
|
|
|
|
public Animator mapCameraAnimator;
|
|
|
|
private bool mapCameraMaxFramerate;
|
|
|
|
private Coroutine updateMapCameraCoroutine;
|
|
|
|
private bool syncingTargetPlayer;
|
|
|
|
private bool syncingSwitchScreen;
|
|
|
|
private bool screenEnabledOnLocalClient;
|
|
|
|
private Vector3 targetDeathPosition;
|
|
|
|
public Transform mapCameraStationaryUI;
|
|
|
|
public Transform shipArrowPointer;
|
|
|
|
public GameObject shipArrowUI;
|
|
|
|
private void Start()
|
|
{
|
|
if (cam == null)
|
|
{
|
|
cam = GetComponent<Camera>();
|
|
}
|
|
if (!isScreenOn)
|
|
{
|
|
cam.enabled = false;
|
|
}
|
|
targetPlayer = StartOfRound.Instance.allPlayerScripts[0];
|
|
targetDeathPosition = new Vector3(0f, -100f, 0f);
|
|
}
|
|
|
|
public void SwitchScreenButton()
|
|
{
|
|
bool on = !isScreenOn;
|
|
SwitchScreenOn(on);
|
|
syncingSwitchScreen = true;
|
|
SwitchScreenOnServerRpc(on);
|
|
}
|
|
|
|
public void SwitchScreenOn(bool on = true)
|
|
{
|
|
isScreenOn = on;
|
|
currentCameraDisabled = !on;
|
|
Material[] sharedMaterials = mesh.sharedMaterials;
|
|
if (on)
|
|
{
|
|
sharedMaterials[materialIndex] = onScreenMat;
|
|
mapCameraAnimator.SetTrigger("Transition");
|
|
}
|
|
else
|
|
{
|
|
sharedMaterials[materialIndex] = offScreenMat;
|
|
}
|
|
mesh.sharedMaterials = sharedMaterials;
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void SwitchScreenOnServerRpc(bool on)
|
|
{
|
|
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(1937545459u, serverRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in on, default(FastBufferWriter.ForPrimitives));
|
|
__endSendServerRpc(ref bufferWriter, 1937545459u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
SwitchScreenOnClientRpc(on);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void SwitchScreenOnClientRpc(bool on)
|
|
{
|
|
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(2637643520u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in on, default(FastBufferWriter.ForPrimitives));
|
|
__endSendClientRpc(ref bufferWriter, 2637643520u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
if (syncingSwitchScreen)
|
|
{
|
|
syncingSwitchScreen = false;
|
|
}
|
|
else
|
|
{
|
|
SwitchScreenOn(on);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SwitchCameraView(bool switchForward = true, int switchToView = -1)
|
|
{
|
|
cam.enabled = false;
|
|
cameraViewIndex = (cameraViewIndex + 1) % cameraViews.Length;
|
|
cam = cameraViews[cameraViewIndex].camera;
|
|
onScreenMat = cameraViews[cameraViewIndex].cameraMaterial;
|
|
}
|
|
|
|
public void SwitchMapCameraTargetPlayer(int syncTargetIndex = -1)
|
|
{
|
|
if (!isScreenOn)
|
|
{
|
|
if (syncTargetIndex == -1)
|
|
{
|
|
return;
|
|
}
|
|
SwitchScreenOn();
|
|
}
|
|
if (updateMapCameraCoroutine != null)
|
|
{
|
|
StopCoroutine(updateMapCameraCoroutine);
|
|
}
|
|
updateMapCameraCoroutine = StartCoroutine(updateMapTarget(syncTargetIndex));
|
|
}
|
|
|
|
private IEnumerator updateMapTarget(int syncTargetIndex = -1)
|
|
{
|
|
if (screenEnabledOnLocalClient)
|
|
{
|
|
mapCameraMaxFramerate = true;
|
|
mapCameraAnimator.SetTrigger("Transition");
|
|
}
|
|
yield return new WaitForSeconds(0.035f);
|
|
if (syncTargetIndex != -1)
|
|
{
|
|
targetPlayerIndex = syncTargetIndex;
|
|
targetPlayer = StartOfRound.Instance.allPlayerScripts[syncTargetIndex];
|
|
StartOfRound.Instance.mapScreenPlayerName.text = "MONITORING: " + targetPlayer.playerUsername;
|
|
}
|
|
else
|
|
{
|
|
int num = StartOfRound.Instance.allPlayerScripts.Length;
|
|
string text = "";
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
targetPlayerIndex = (targetPlayerIndex + 1) % num;
|
|
targetPlayer = StartOfRound.Instance.allPlayerScripts[targetPlayerIndex];
|
|
text = "MONITORING: " + targetPlayer.playerUsername;
|
|
if (targetPlayer.isPlayerControlled || targetPlayer.isPlayerDead)
|
|
{
|
|
break;
|
|
}
|
|
Debug.Log($"Skipped player on map screen: {targetPlayer.isPlayerControlled}; {targetPlayer.isPlayerDead}");
|
|
}
|
|
StartOfRound.Instance.mapScreenPlayerName.text = text;
|
|
syncingTargetPlayer = true;
|
|
SwitchMapCameraTargetServerRpc(targetPlayerIndex);
|
|
}
|
|
mapCameraMaxFramerate = false;
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void SwitchMapCameraTargetServerRpc(int targetIndex)
|
|
{
|
|
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(1252373737u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, targetIndex);
|
|
__endSendServerRpc(ref bufferWriter, 1252373737u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
SwitchMapCameraTargetClientRpc(targetIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void SwitchMapCameraTargetClientRpc(int targetIndex)
|
|
{
|
|
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(3804991398u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, targetIndex);
|
|
__endSendClientRpc(ref bufferWriter, 3804991398u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
if (syncingTargetPlayer)
|
|
{
|
|
syncingTargetPlayer = false;
|
|
}
|
|
else
|
|
{
|
|
SwitchMapCameraTargetPlayer(targetIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MapCameraFocusOnPosition(Vector3 pos)
|
|
{
|
|
if (targetPlayer.isInHangarShipRoom)
|
|
{
|
|
mapCamera.nearClipPlane = -0.96f;
|
|
}
|
|
else
|
|
{
|
|
mapCamera.nearClipPlane = -2.47f;
|
|
}
|
|
mapCamera.transform.position = new Vector3(pos.x, pos.y + 3.636f, pos.z);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (GameNetworkManager.Instance.localPlayerController == null || NetworkManager.Singleton == null)
|
|
{
|
|
return;
|
|
}
|
|
if (overrideCameraForOtherUse)
|
|
{
|
|
if (shipArrowUI != null)
|
|
{
|
|
shipArrowUI.SetActive(value: false);
|
|
}
|
|
return;
|
|
}
|
|
if (cam == mapCamera)
|
|
{
|
|
if (targetPlayer.isPlayerDead)
|
|
{
|
|
if (targetPlayer.deadBody != null)
|
|
{
|
|
MapCameraFocusOnPosition(targetPlayer.deadBody.transform.position);
|
|
targetDeathPosition = targetPlayer.deadBody.spawnPosition;
|
|
}
|
|
else
|
|
{
|
|
MapCameraFocusOnPosition(targetPlayer.placeOfDeath);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MapCameraFocusOnPosition(targetPlayer.transform.position);
|
|
}
|
|
if (mapCameraMaxFramerate)
|
|
{
|
|
mapCamera.enabled = true;
|
|
return;
|
|
}
|
|
}
|
|
PlayerControllerB player = ((!GameNetworkManager.Instance.localPlayerController.isPlayerDead || !(GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript != null)) ? GameNetworkManager.Instance.localPlayerController : GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript);
|
|
if (!MeetsCameraEnabledConditions(player))
|
|
{
|
|
screenEnabledOnLocalClient = false;
|
|
cam.enabled = false;
|
|
return;
|
|
}
|
|
if (cam == mapCamera)
|
|
{
|
|
if (targetPlayer != null && Vector3.Distance(targetPlayer.transform.position, StartOfRound.Instance.elevatorTransform.transform.position) > 16f && !targetPlayer.isInsideFactory)
|
|
{
|
|
shipArrowPointer.LookAt(StartOfRound.Instance.elevatorTransform);
|
|
shipArrowPointer.eulerAngles = new Vector3(0f, shipArrowPointer.eulerAngles.y, 0f);
|
|
shipArrowUI.SetActive(value: true);
|
|
}
|
|
else
|
|
{
|
|
shipArrowUI.SetActive(value: false);
|
|
}
|
|
}
|
|
screenEnabledOnLocalClient = true;
|
|
if (renderAtLowerFramerate)
|
|
{
|
|
cam.enabled = false;
|
|
elapsed += Time.deltaTime;
|
|
if (elapsed > 1f / fps)
|
|
{
|
|
elapsed = 0f;
|
|
cam.Render();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cam.enabled = true;
|
|
}
|
|
}
|
|
|
|
private bool MeetsCameraEnabledConditions(PlayerControllerB player)
|
|
{
|
|
if (currentCameraDisabled)
|
|
{
|
|
return false;
|
|
}
|
|
if (mesh != null && !mesh.isVisible)
|
|
{
|
|
return false;
|
|
}
|
|
if (!StartOfRound.Instance.inShipPhase && (!player.isInHangarShipRoom || (!StartOfRound.Instance.shipDoorsEnabled && (StartOfRound.Instance.currentPlanetPrefab == null || !StartOfRound.Instance.currentPlanetPrefab.activeSelf))))
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
protected override void __initializeVariables()
|
|
{
|
|
base.__initializeVariables();
|
|
}
|
|
|
|
[RuntimeInitializeOnLoadMethod]
|
|
internal static void InitializeRPCS_ManualCameraRenderer()
|
|
{
|
|
NetworkManager.__rpc_func_table.Add(1937545459u, __rpc_handler_1937545459);
|
|
NetworkManager.__rpc_func_table.Add(2637643520u, __rpc_handler_2637643520);
|
|
NetworkManager.__rpc_func_table.Add(1252373737u, __rpc_handler_1252373737);
|
|
NetworkManager.__rpc_func_table.Add(3804991398u, __rpc_handler_3804991398);
|
|
}
|
|
|
|
private static void __rpc_handler_1937545459(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;
|
|
((ManualCameraRenderer)target).SwitchScreenOnServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2637643520(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;
|
|
((ManualCameraRenderer)target).SwitchScreenOnClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1252373737(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;
|
|
((ManualCameraRenderer)target).SwitchMapCameraTargetServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3804991398(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;
|
|
((ManualCameraRenderer)target).SwitchMapCameraTargetClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
protected internal override string __getTypeName()
|
|
{
|
|
return "ManualCameraRenderer";
|
|
}
|
|
}
|