LethalCompany/Lethal Company/ExportedProject/Assets/Scripts/Assembly-CSharp/Turret.cs
2023-12-22 18:30:10 -05:00

818 lines
25 KiB
C#

using System.Collections;
using GameNetcodeStuff;
using Unity.Netcode;
using UnityEngine;
public class Turret : NetworkBehaviour, IHittable
{
[Header("Effects")]
public AudioSource mainAudio;
[Header("Effects")]
public AudioSource bulletCollisionAudio;
[Header("Effects")]
public AudioSource farAudio;
public AudioClip firingSFX;
public AudioClip chargingSFX;
public AudioClip detectPlayerSFX;
public AudioClip firingFarSFX;
public AudioClip bulletsHitWallSFX;
public AudioClip turretActivate;
public AudioClip turretDeactivate;
public ParticleSystem bulletParticles;
public Animator turretAnimator;
[Header("Variables")]
public bool turretActive = true;
[Space(5f)]
public TurretMode turretMode;
private TurretMode turretModeLastFrame;
public Transform turretRod;
public float targetRotation;
public float rotationSpeed = 20f;
public Transform turnTowardsObjectCompass;
public Transform forwardFacingPos;
public Transform aimPoint;
public Transform centerPoint;
public PlayerControllerB targetPlayerWithRotation;
public Transform targetTransform;
private bool targetingDeadPlayer;
public float rotationRange = 45f;
public float currentRotation;
public bool rotatingOnInterval = true;
private bool rotatingRight;
private float switchRotationTimer;
private bool hasLineOfSight;
private float lostLOSTimer;
private bool wasTargetingPlayerLastFrame;
private RaycastHit hit;
private int wallAndPlayerMask = 2824;
private float turretInterval;
private string previousHitLog;
private bool rotatingSmoothly = true;
private Ray shootRay;
private Coroutine fadeBulletAudioCoroutine;
public Transform tempTransform;
private bool rotatingClockwise;
private float berserkTimer;
public AudioSource berserkAudio;
private bool enteringBerserkMode;
private void Start()
{
rotationRange = Mathf.Abs(rotationRange);
rotationSpeed = 28f;
}
private IEnumerator FadeBulletAudio()
{
float initialVolume = bulletCollisionAudio.volume;
for (int i = 0; i <= 30; i++)
{
yield return new WaitForSeconds(0.012f);
bulletCollisionAudio.volume = Mathf.Lerp(initialVolume, 0f, (float)i / 30f);
}
bulletCollisionAudio.Stop();
}
private void Update()
{
if (!turretActive)
{
wasTargetingPlayerLastFrame = false;
turretMode = TurretMode.Detection;
targetPlayerWithRotation = null;
return;
}
if (targetPlayerWithRotation != null)
{
if (!wasTargetingPlayerLastFrame)
{
wasTargetingPlayerLastFrame = true;
if (turretMode == TurretMode.Detection)
{
turretMode = TurretMode.Charging;
}
}
SetTargetToPlayerBody();
TurnTowardsTargetIfHasLOS();
}
else if (wasTargetingPlayerLastFrame)
{
wasTargetingPlayerLastFrame = false;
turretMode = TurretMode.Detection;
}
switch (turretMode)
{
case TurretMode.Detection:
if (turretModeLastFrame != 0)
{
turretModeLastFrame = TurretMode.Detection;
rotatingClockwise = false;
mainAudio.Stop();
farAudio.Stop();
berserkAudio.Stop();
if (fadeBulletAudioCoroutine != null)
{
StopCoroutine(fadeBulletAudioCoroutine);
}
fadeBulletAudioCoroutine = StartCoroutine(FadeBulletAudio());
bulletParticles.Stop(withChildren: true, ParticleSystemStopBehavior.StopEmitting);
rotationSpeed = 28f;
rotatingSmoothly = true;
turretAnimator.SetInteger("TurretMode", 0);
turretInterval = Random.Range(0f, 0.15f);
}
if (!base.IsServer)
{
break;
}
if (switchRotationTimer >= 7f)
{
switchRotationTimer = 0f;
bool setRotateRight = !rotatingRight;
SwitchRotationClientRpc(setRotateRight);
SwitchRotationOnInterval(setRotateRight);
}
else
{
switchRotationTimer += Time.deltaTime;
}
if (turretInterval >= 0.25f)
{
turretInterval = 0f;
PlayerControllerB playerControllerB = CheckForPlayersInLineOfSight(1.35f, angleRangeCheck: true);
if (playerControllerB != null && !playerControllerB.isPlayerDead)
{
targetPlayerWithRotation = playerControllerB;
SwitchTurretMode(1);
SwitchTargetedPlayerClientRpc((int)playerControllerB.playerClientId, setModeToCharging: true);
}
}
else
{
turretInterval += Time.deltaTime;
}
break;
case TurretMode.Charging:
if (turretModeLastFrame != TurretMode.Charging)
{
turretModeLastFrame = TurretMode.Charging;
rotatingClockwise = false;
mainAudio.PlayOneShot(detectPlayerSFX);
berserkAudio.Stop();
WalkieTalkie.TransmitOneShotAudio(mainAudio, detectPlayerSFX);
rotationSpeed = 95f;
rotatingSmoothly = false;
lostLOSTimer = 0f;
turretAnimator.SetInteger("TurretMode", 1);
}
if (!base.IsServer)
{
break;
}
if (turretInterval >= 1.5f)
{
turretInterval = 0f;
Debug.Log("Charging timer is up, setting to firing mode");
if (!hasLineOfSight)
{
Debug.Log("hasLineOfSight is false");
targetPlayerWithRotation = null;
RemoveTargetedPlayerClientRpc();
}
else
{
SwitchTurretMode(2);
SetToModeClientRpc(2);
}
}
else
{
turretInterval += Time.deltaTime;
}
break;
case TurretMode.Firing:
if (turretModeLastFrame != TurretMode.Firing)
{
turretModeLastFrame = TurretMode.Firing;
berserkAudio.Stop();
mainAudio.clip = firingSFX;
mainAudio.Play();
farAudio.clip = firingFarSFX;
farAudio.Play();
bulletParticles.Play(withChildren: true);
bulletCollisionAudio.Play();
if (fadeBulletAudioCoroutine != null)
{
StopCoroutine(fadeBulletAudioCoroutine);
}
bulletCollisionAudio.volume = 1f;
rotatingSmoothly = false;
lostLOSTimer = 0f;
turretAnimator.SetInteger("TurretMode", 2);
}
if (turretInterval >= 0.21f)
{
turretInterval = 0f;
if (CheckForPlayersInLineOfSight(3f) == GameNetworkManager.Instance.localPlayerController)
{
if (GameNetworkManager.Instance.localPlayerController.health > 50)
{
GameNetworkManager.Instance.localPlayerController.DamagePlayer(50, hasDamageSFX: true, callRPC: true, CauseOfDeath.Gunshots);
}
else
{
GameNetworkManager.Instance.localPlayerController.KillPlayer(aimPoint.forward * 40f, spawnBody: true, CauseOfDeath.Gunshots);
}
}
shootRay = new Ray(aimPoint.position, aimPoint.forward);
if (Physics.Raycast(shootRay, out hit, 30f, StartOfRound.Instance.collidersAndRoomMask, QueryTriggerInteraction.Ignore))
{
bulletCollisionAudio.transform.position = shootRay.GetPoint(hit.distance - 0.5f);
}
}
else
{
turretInterval += Time.deltaTime;
}
break;
case TurretMode.Berserk:
if (turretModeLastFrame != TurretMode.Berserk)
{
turretModeLastFrame = TurretMode.Berserk;
turretAnimator.SetInteger("TurretMode", 1);
berserkTimer = 1.3f;
berserkAudio.Play();
rotationSpeed = 77f;
enteringBerserkMode = true;
rotatingSmoothly = true;
lostLOSTimer = 0f;
wasTargetingPlayerLastFrame = false;
targetPlayerWithRotation = null;
}
if (enteringBerserkMode)
{
berserkTimer -= Time.deltaTime;
if (berserkTimer <= 0f)
{
enteringBerserkMode = false;
rotatingClockwise = true;
berserkTimer = 9f;
turretAnimator.SetInteger("TurretMode", 2);
mainAudio.clip = firingSFX;
mainAudio.Play();
farAudio.clip = firingFarSFX;
farAudio.Play();
bulletParticles.Play(withChildren: true);
bulletCollisionAudio.Play();
if (fadeBulletAudioCoroutine != null)
{
StopCoroutine(fadeBulletAudioCoroutine);
}
bulletCollisionAudio.volume = 1f;
}
break;
}
if (turretInterval >= 0.21f)
{
turretInterval = 0f;
if (CheckForPlayersInLineOfSight(3f) == GameNetworkManager.Instance.localPlayerController)
{
if (GameNetworkManager.Instance.localPlayerController.health > 50)
{
GameNetworkManager.Instance.localPlayerController.DamagePlayer(50, hasDamageSFX: true, callRPC: true, CauseOfDeath.Gunshots);
}
else
{
GameNetworkManager.Instance.localPlayerController.KillPlayer(aimPoint.forward * 40f, spawnBody: true, CauseOfDeath.Gunshots);
}
}
shootRay = new Ray(aimPoint.position, aimPoint.forward);
if (Physics.Raycast(shootRay, out hit, 30f, StartOfRound.Instance.collidersAndRoomMask, QueryTriggerInteraction.Ignore))
{
bulletCollisionAudio.transform.position = shootRay.GetPoint(hit.distance - 0.5f);
}
}
else
{
turretInterval += Time.deltaTime;
}
if (base.IsServer)
{
berserkTimer -= Time.deltaTime;
if (berserkTimer <= 0f)
{
SwitchTurretMode(0);
SetToModeClientRpc(0);
}
}
break;
}
if (rotatingClockwise)
{
turnTowardsObjectCompass.localEulerAngles = new Vector3(-180f, turretRod.localEulerAngles.y - Time.deltaTime * 20f, 180f);
turretRod.rotation = Quaternion.RotateTowards(turretRod.rotation, turnTowardsObjectCompass.rotation, rotationSpeed * Time.deltaTime);
return;
}
if (rotatingSmoothly)
{
turnTowardsObjectCompass.localEulerAngles = new Vector3(-180f, Mathf.Clamp(targetRotation, 0f - rotationRange, rotationRange), 180f);
}
turretRod.rotation = Quaternion.RotateTowards(turretRod.rotation, turnTowardsObjectCompass.rotation, rotationSpeed * Time.deltaTime);
}
private void SetTargetToPlayerBody()
{
if (targetPlayerWithRotation.isPlayerDead)
{
if (!targetingDeadPlayer)
{
targetingDeadPlayer = true;
}
if (targetPlayerWithRotation.deadBody != null)
{
targetTransform = targetPlayerWithRotation.deadBody.bodyParts[5].transform;
}
}
else
{
targetingDeadPlayer = false;
targetTransform = targetPlayerWithRotation.gameplayCamera.transform;
}
}
private void TurnTowardsTargetIfHasLOS()
{
bool flag = true;
if (targetingDeadPlayer || Vector3.Angle(targetTransform.position - centerPoint.position, forwardFacingPos.forward) > rotationRange)
{
flag = false;
}
if (Physics.Linecast(aimPoint.position, targetTransform.position, StartOfRound.Instance.collidersAndRoomMask, QueryTriggerInteraction.Ignore))
{
flag = false;
}
if (flag)
{
hasLineOfSight = true;
lostLOSTimer = 0f;
tempTransform.position = targetTransform.position;
tempTransform.position -= Vector3.up * 0.15f;
turnTowardsObjectCompass.LookAt(tempTransform);
return;
}
if (hasLineOfSight)
{
hasLineOfSight = false;
lostLOSTimer = 0f;
}
if (!base.IsServer)
{
return;
}
lostLOSTimer += Time.deltaTime;
if (lostLOSTimer >= 2f)
{
lostLOSTimer = 0f;
Debug.Log("Turret: LOS timer ended on server. checking for new player target");
PlayerControllerB playerControllerB = CheckForPlayersInLineOfSight();
if (playerControllerB != null)
{
targetPlayerWithRotation = playerControllerB;
SwitchTargetedPlayerClientRpc((int)playerControllerB.playerClientId);
Debug.Log("Turret: Got new player target");
}
else
{
Debug.Log("Turret: No new player to target; returning to detection mode.");
targetPlayerWithRotation = null;
RemoveTargetedPlayerClientRpc();
}
}
}
public PlayerControllerB CheckForPlayersInLineOfSight(float radius = 2f, bool angleRangeCheck = false)
{
Vector3 forward = aimPoint.forward;
forward = Quaternion.Euler(0f, (float)(int)(0f - rotationRange) / radius, 0f) * forward;
float num = rotationRange / radius * 2f;
for (int i = 0; i <= 6; i++)
{
shootRay = new Ray(centerPoint.position, forward);
if (Physics.Raycast(shootRay, out hit, 30f, 1051400, QueryTriggerInteraction.Ignore))
{
if (hit.transform.CompareTag("Player"))
{
PlayerControllerB component = hit.transform.GetComponent<PlayerControllerB>();
if (!(component == null))
{
if (angleRangeCheck && Vector3.Angle(component.transform.position + Vector3.up * 1.75f - centerPoint.position, forwardFacingPos.forward) > rotationRange)
{
return null;
}
return component;
}
continue;
}
if ((turretMode == TurretMode.Firing || (turretMode == TurretMode.Berserk && !enteringBerserkMode)) && hit.transform.CompareTag("PlayerRagdoll"))
{
Rigidbody component2 = hit.transform.GetComponent<Rigidbody>();
if (component2 != null)
{
component2.AddForce(forward.normalized * 42f, ForceMode.Impulse);
}
}
}
forward = Quaternion.Euler(0f, num / 6f, 0f) * forward;
}
return null;
}
[ClientRpc]
public void SwitchRotationClientRpc(bool setRotateRight)
{
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(2426770061u, clientRpcParams, RpcDelivery.Reliable);
bufferWriter.WriteValueSafe(in setRotateRight, default(FastBufferWriter.ForPrimitives));
__endSendClientRpc(ref bufferWriter, 2426770061u, clientRpcParams, RpcDelivery.Reliable);
}
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsServer)
{
SwitchRotationOnInterval(setRotateRight);
}
}
}
public void SwitchRotationOnInterval(bool setRotateRight)
{
if (rotatingRight)
{
rotatingRight = false;
targetRotation = rotationRange;
}
else
{
rotatingRight = true;
targetRotation = 0f - rotationRange;
}
}
[ClientRpc]
public void SwitchTargetedPlayerClientRpc(int playerId, bool setModeToCharging = 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(866050294u, clientRpcParams, RpcDelivery.Reliable);
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
bufferWriter.WriteValueSafe(in setModeToCharging, default(FastBufferWriter.ForPrimitives));
__endSendClientRpc(ref bufferWriter, 866050294u, clientRpcParams, RpcDelivery.Reliable);
}
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsServer)
{
targetPlayerWithRotation = StartOfRound.Instance.allPlayerScripts[playerId];
if (setModeToCharging)
{
SwitchTurretMode(1);
}
}
}
[ClientRpc]
public void RemoveTargetedPlayerClientRpc()
{
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(2800017671u, clientRpcParams, RpcDelivery.Reliable);
__endSendClientRpc(ref bufferWriter, 2800017671u, clientRpcParams, RpcDelivery.Reliable);
}
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
{
targetPlayerWithRotation = null;
}
}
}
[ClientRpc]
public void SetToModeClientRpc(int mode)
{
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(3335553538u, clientRpcParams, RpcDelivery.Reliable);
BytePacker.WriteValueBitPacked(bufferWriter, mode);
__endSendClientRpc(ref bufferWriter, 3335553538u, clientRpcParams, RpcDelivery.Reliable);
}
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsServer)
{
SwitchTurretMode(mode);
}
}
}
private void SwitchTurretMode(int mode)
{
turretMode = (TurretMode)mode;
}
public void ToggleTurretEnabled(bool enabled)
{
if (turretActive != enabled)
{
Debug.Log($"Toggling turret to {enabled}!");
ToggleTurretEnabledLocalClient(enabled);
ToggleTurretServerRpc(enabled);
}
}
[ServerRpc(RequireOwnership = false)]
public void ToggleTurretServerRpc(bool enabled)
{
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(2339273208u, serverRpcParams, RpcDelivery.Reliable);
bufferWriter.WriteValueSafe(in enabled, default(FastBufferWriter.ForPrimitives));
__endSendServerRpc(ref bufferWriter, 2339273208u, serverRpcParams, RpcDelivery.Reliable);
}
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
{
Debug.Log($"Toggling turret to {enabled}! serverrpc");
ToggleTurretClientRpc(enabled);
}
}
}
[ClientRpc]
public void ToggleTurretClientRpc(bool enabled)
{
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(1135819343u, clientRpcParams, RpcDelivery.Reliable);
bufferWriter.WriteValueSafe(in enabled, default(FastBufferWriter.ForPrimitives));
__endSendClientRpc(ref bufferWriter, 1135819343u, clientRpcParams, RpcDelivery.Reliable);
}
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
{
Debug.Log($"Toggling turret to {enabled}! clientrpc");
if (turretActive != enabled)
{
ToggleTurretEnabledLocalClient(enabled);
}
}
}
private void ToggleTurretEnabledLocalClient(bool enabled)
{
Debug.Log($"Setting turret active to {enabled}!");
turretActive = enabled;
turretAnimator.SetBool("turretActive", turretActive);
if (enabled)
{
mainAudio.PlayOneShot(turretActivate);
WalkieTalkie.TransmitOneShotAudio(mainAudio, turretActivate);
}
else
{
mainAudio.PlayOneShot(turretDeactivate);
WalkieTalkie.TransmitOneShotAudio(mainAudio, turretDeactivate);
}
}
void IHittable.Hit(int force, Vector3 hitDirection, PlayerControllerB playerWhoHit, bool playHitSFX)
{
if (turretMode != TurretMode.Berserk && turretMode != TurretMode.Firing)
{
SwitchTurretMode(3);
EnterBerserkModeServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
}
}
[ServerRpc(RequireOwnership = false)]
public void EnterBerserkModeServerRpc(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(4195711963u, serverRpcParams, RpcDelivery.Reliable);
BytePacker.WriteValueBitPacked(bufferWriter, playerWhoTriggered);
__endSendServerRpc(ref bufferWriter, 4195711963u, serverRpcParams, RpcDelivery.Reliable);
}
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
{
EnterBerserkModeClientRpc(playerWhoTriggered);
}
}
}
[ClientRpc]
public void EnterBerserkModeClientRpc(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(1436540455u, clientRpcParams, RpcDelivery.Reliable);
BytePacker.WriteValueBitPacked(bufferWriter, playerWhoTriggered);
__endSendClientRpc(ref bufferWriter, 1436540455u, clientRpcParams, RpcDelivery.Reliable);
}
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && playerWhoTriggered != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
{
SwitchTurretMode(3);
}
}
}
protected override void __initializeVariables()
{
base.__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_Turret()
{
NetworkManager.__rpc_func_table.Add(2426770061u, __rpc_handler_2426770061);
NetworkManager.__rpc_func_table.Add(866050294u, __rpc_handler_866050294);
NetworkManager.__rpc_func_table.Add(2800017671u, __rpc_handler_2800017671);
NetworkManager.__rpc_func_table.Add(3335553538u, __rpc_handler_3335553538);
NetworkManager.__rpc_func_table.Add(2339273208u, __rpc_handler_2339273208);
NetworkManager.__rpc_func_table.Add(1135819343u, __rpc_handler_1135819343);
NetworkManager.__rpc_func_table.Add(4195711963u, __rpc_handler_4195711963);
NetworkManager.__rpc_func_table.Add(1436540455u, __rpc_handler_1436540455);
}
private static void __rpc_handler_2426770061(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;
((Turret)target).SwitchRotationClientRpc(value);
target.__rpc_exec_stage = __RpcExecStage.None;
}
}
private static void __rpc_handler_866050294(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
NetworkManager networkManager = target.NetworkManager;
if ((object)networkManager != null && networkManager.IsListening)
{
ByteUnpacker.ReadValueBitPacked(reader, out int value);
reader.ReadValueSafe(out bool value2, default(FastBufferWriter.ForPrimitives));
target.__rpc_exec_stage = __RpcExecStage.Client;
((Turret)target).SwitchTargetedPlayerClientRpc(value, value2);
target.__rpc_exec_stage = __RpcExecStage.None;
}
}
private static void __rpc_handler_2800017671(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
NetworkManager networkManager = target.NetworkManager;
if ((object)networkManager != null && networkManager.IsListening)
{
target.__rpc_exec_stage = __RpcExecStage.Client;
((Turret)target).RemoveTargetedPlayerClientRpc();
target.__rpc_exec_stage = __RpcExecStage.None;
}
}
private static void __rpc_handler_3335553538(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;
((Turret)target).SetToModeClientRpc(value);
target.__rpc_exec_stage = __RpcExecStage.None;
}
}
private static void __rpc_handler_2339273208(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;
((Turret)target).ToggleTurretServerRpc(value);
target.__rpc_exec_stage = __RpcExecStage.None;
}
}
private static void __rpc_handler_1135819343(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;
((Turret)target).ToggleTurretClientRpc(value);
target.__rpc_exec_stage = __RpcExecStage.None;
}
}
private static void __rpc_handler_4195711963(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;
((Turret)target).EnterBerserkModeServerRpc(value);
target.__rpc_exec_stage = __RpcExecStage.None;
}
}
private static void __rpc_handler_1436540455(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;
((Turret)target).EnterBerserkModeClientRpc(value);
target.__rpc_exec_stage = __RpcExecStage.None;
}
}
protected internal override string __getTypeName()
{
return "Turret";
}
}