2156 lines
71 KiB
C#
2156 lines
71 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using GameNetcodeStuff;
|
|
using Unity.Netcode;
|
|
using UnityEngine;
|
|
using UnityEngine.AI;
|
|
using UnityEngine.Animations.Rigging;
|
|
|
|
public class MaskedPlayerEnemy : EnemyAI
|
|
{
|
|
public SkinnedMeshRenderer rendererLOD0;
|
|
|
|
public SkinnedMeshRenderer rendererLOD1;
|
|
|
|
public SkinnedMeshRenderer rendererLOD2;
|
|
|
|
private Ray enemyRay;
|
|
|
|
private RaycastHit enemyRayHit;
|
|
|
|
private int currentFootstepSurfaceIndex;
|
|
|
|
private int previousFootstepClip;
|
|
|
|
public AudioSource movementAudio;
|
|
|
|
private bool sprinting;
|
|
|
|
private int previousBehaviourState = -1;
|
|
|
|
public float walkCheckInterval;
|
|
|
|
private Vector3 positionLastCheck;
|
|
|
|
private Coroutine teleportCoroutine;
|
|
|
|
public ParticleSystem teleportParticle;
|
|
|
|
public AISearchRoutine searchForPlayers;
|
|
|
|
private Vector3 agentLocalVelocity;
|
|
|
|
private Vector3 previousPosition;
|
|
|
|
private float velX;
|
|
|
|
private float velZ;
|
|
|
|
public Transform animationContainer;
|
|
|
|
private Vector3 currentRandomLookDirection;
|
|
|
|
private Vector3 focusOnPosition;
|
|
|
|
private float verticalLookAngle;
|
|
|
|
private float currentLookAngle;
|
|
|
|
public Transform headTiltTarget;
|
|
|
|
private float lookAtPositionTimer;
|
|
|
|
private float randomLookTimer;
|
|
|
|
private bool lostPlayerInChase;
|
|
|
|
private float lostLOSTimer;
|
|
|
|
private bool running;
|
|
|
|
private bool crouching;
|
|
|
|
[Space(3f)]
|
|
public PlayerControllerB mimickingPlayer;
|
|
|
|
public bool allowSpawningWithoutPlayer;
|
|
|
|
[Space(3f)]
|
|
public Transform lerpTarget;
|
|
|
|
public float turnSpeedMultiplier;
|
|
|
|
public MultiRotationConstraint lookRig1;
|
|
|
|
public MultiRotationConstraint lookRig2;
|
|
|
|
private float stopAndStareTimer;
|
|
|
|
public Transform stareAtTransform;
|
|
|
|
private bool handsOut;
|
|
|
|
private bool inKillAnimation;
|
|
|
|
public bool startingKillAnimationLocalClient;
|
|
|
|
private Coroutine killAnimationCoroutine;
|
|
|
|
private Ray playerRay;
|
|
|
|
public MeshRenderer[] maskEyesGlow;
|
|
|
|
public Light maskEyesGlowLight;
|
|
|
|
public ParticleSystem maskFloodParticle;
|
|
|
|
private PlayerControllerB lastPlayerKilled;
|
|
|
|
private float timeLookingAtLastNoise;
|
|
|
|
private Vector3 shipHidingSpot;
|
|
|
|
private float staminaTimer;
|
|
|
|
private bool runningRandomly;
|
|
|
|
private bool enemyEnabled;
|
|
|
|
public GameObject[] maskTypes;
|
|
|
|
public int maskTypeIndex;
|
|
|
|
private Vector3 mainEntrancePosition;
|
|
|
|
private float timeAtLastUsingEntrance;
|
|
|
|
private float interestInShipCooldown;
|
|
|
|
private List<int> playersKilled = new List<int>();
|
|
|
|
public override void Start()
|
|
{
|
|
try
|
|
{
|
|
agent = base.gameObject.GetComponentInChildren<NavMeshAgent>();
|
|
skinnedMeshRenderers = base.gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
|
|
meshRenderers = base.gameObject.GetComponentsInChildren<MeshRenderer>();
|
|
if (creatureAnimator == null)
|
|
{
|
|
creatureAnimator = base.gameObject.GetComponentInChildren<Animator>();
|
|
}
|
|
thisNetworkObject = base.gameObject.GetComponentInChildren<NetworkObject>();
|
|
serverPosition = base.transform.position;
|
|
thisEnemyIndex = RoundManager.Instance.numberOfEnemiesInScene;
|
|
RoundManager.Instance.numberOfEnemiesInScene++;
|
|
isOutside = base.transform.position.y > -80f;
|
|
mainEntrancePosition = RoundManager.FindMainEntrancePosition(getTeleportPosition: true, isOutside);
|
|
if (isOutside)
|
|
{
|
|
if (allAINodes == null || allAINodes.Length == 0)
|
|
{
|
|
allAINodes = GameObject.FindGameObjectsWithTag("OutsideAINode");
|
|
}
|
|
if (GameNetworkManager.Instance.localPlayerController != null)
|
|
{
|
|
EnableEnemyMesh(!StartOfRound.Instance.hangarDoorsClosed || !GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom);
|
|
}
|
|
}
|
|
else if (allAINodes == null || allAINodes.Length == 0)
|
|
{
|
|
allAINodes = GameObject.FindGameObjectsWithTag("AINode");
|
|
}
|
|
path1 = new NavMeshPath();
|
|
openDoorSpeedMultiplier = enemyType.doorSpeedMultiplier;
|
|
if (base.IsOwner)
|
|
{
|
|
SyncPositionToClients();
|
|
}
|
|
else
|
|
{
|
|
SetClientCalculatingAI(enable: false);
|
|
}
|
|
}
|
|
catch (Exception arg)
|
|
{
|
|
Debug.LogError($"Error when initializing enemy variables for {base.gameObject.name} : {arg}");
|
|
}
|
|
lerpTarget.SetParent(RoundManager.Instance.mapPropsContainer.transform);
|
|
enemyRayHit = default(RaycastHit);
|
|
addPlayerVelocityToDestination = 3f;
|
|
if (base.IsServer && mimickingPlayer == null)
|
|
{
|
|
SetEnemyAsHavingNoPlayerServerRpc();
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void SetEnemyAsHavingNoPlayerServerRpc()
|
|
{
|
|
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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
return;
|
|
}
|
|
ServerRpcParams serverRpcParams = default(ServerRpcParams);
|
|
FastBufferWriter bufferWriter = __beginSendServerRpc(3110137062u, serverRpcParams, RpcDelivery.Reliable);
|
|
__endSendServerRpc(ref bufferWriter, 3110137062u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
SetEnemyAsHavingNoPlayerClientRpc();
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void SetEnemyAsHavingNoPlayerClientRpc()
|
|
{
|
|
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(1038760037u, clientRpcParams, RpcDelivery.Reliable);
|
|
__endSendClientRpc(ref bufferWriter, 1038760037u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
allowSpawningWithoutPlayer = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
SetVisibilityOfMaskedEnemy();
|
|
}
|
|
|
|
private void LookAndRunRandomly(bool canStartRunning = false, bool onlySetRunning = false)
|
|
{
|
|
randomLookTimer -= AIIntervalTime;
|
|
if (!runningRandomly && !running)
|
|
{
|
|
staminaTimer = Mathf.Min(6f, staminaTimer + AIIntervalTime);
|
|
}
|
|
else
|
|
{
|
|
staminaTimer = Mathf.Max(0f, staminaTimer - AIIntervalTime);
|
|
}
|
|
if (!(randomLookTimer <= 0f))
|
|
{
|
|
return;
|
|
}
|
|
randomLookTimer = UnityEngine.Random.Range(0.7f, 5f);
|
|
if (!runningRandomly)
|
|
{
|
|
int num = ((!isOutside) ? 20 : 35);
|
|
if (onlySetRunning)
|
|
{
|
|
num /= 3;
|
|
}
|
|
if (staminaTimer >= 5f && UnityEngine.Random.Range(0, 100) < num)
|
|
{
|
|
running = true;
|
|
runningRandomly = true;
|
|
creatureAnimator.SetBool("Running", value: true);
|
|
SetRunningServerRpc(running: true);
|
|
}
|
|
else if (!onlySetRunning)
|
|
{
|
|
Vector3 onUnitSphere = UnityEngine.Random.onUnitSphere;
|
|
float y = 0f;
|
|
if (Physics.Raycast(eye.position, onUnitSphere, 5f, StartOfRound.Instance.collidersRoomMaskDefaultAndPlayers))
|
|
{
|
|
y = RoundManager.Instance.YRotationThatFacesTheFarthestFromPosition(eye.position, 12f, 5);
|
|
}
|
|
onUnitSphere.y = y;
|
|
LookAtDirectionServerRpc(onUnitSphere, UnityEngine.Random.Range(0.25f, 2f), UnityEngine.Random.Range(-60f, 60f));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int num2 = ((!isOutside) ? 30 : 80);
|
|
if (onlySetRunning)
|
|
{
|
|
num2 /= 5;
|
|
}
|
|
if (UnityEngine.Random.Range(0, 100) > num2 || staminaTimer <= 0f)
|
|
{
|
|
running = false;
|
|
runningRandomly = false;
|
|
staminaTimer = -6f;
|
|
creatureAnimator.SetBool("Running", value: false);
|
|
SetRunningServerRpc(running: false);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TeleportMaskedEnemyAndSync(Vector3 pos, bool setOutside)
|
|
{
|
|
if (base.IsOwner)
|
|
{
|
|
TeleportMaskedEnemy(pos, setOutside);
|
|
TeleportMaskedEnemyServerRpc(pos, setOutside);
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void TeleportMaskedEnemyServerRpc(Vector3 pos, bool setOutside)
|
|
{
|
|
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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
return;
|
|
}
|
|
ServerRpcParams serverRpcParams = default(ServerRpcParams);
|
|
FastBufferWriter bufferWriter = __beginSendServerRpc(657232826u, serverRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in pos);
|
|
bufferWriter.WriteValueSafe(in setOutside, default(FastBufferWriter.ForPrimitives));
|
|
__endSendServerRpc(ref bufferWriter, 657232826u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
TeleportMaskedEnemyClientRpc(pos, setOutside);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void TeleportMaskedEnemyClientRpc(Vector3 pos, bool setOutside)
|
|
{
|
|
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(2539470808u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in pos);
|
|
bufferWriter.WriteValueSafe(in setOutside, default(FastBufferWriter.ForPrimitives));
|
|
__endSendClientRpc(ref bufferWriter, 2539470808u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsOwner)
|
|
{
|
|
TeleportMaskedEnemy(pos, setOutside);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TeleportMaskedEnemy(Vector3 pos, bool setOutside)
|
|
{
|
|
timeAtLastUsingEntrance = Time.realtimeSinceStartup;
|
|
Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(pos);
|
|
if (base.IsOwner)
|
|
{
|
|
agent.enabled = false;
|
|
base.transform.position = navMeshPosition;
|
|
agent.enabled = true;
|
|
}
|
|
else
|
|
{
|
|
base.transform.position = navMeshPosition;
|
|
}
|
|
serverPosition = navMeshPosition;
|
|
SetEnemyOutside(setOutside);
|
|
EntranceTeleport entranceTeleport = RoundManager.FindMainEntranceScript(setOutside);
|
|
if (entranceTeleport.doorAudios != null && entranceTeleport.doorAudios.Length != 0)
|
|
{
|
|
entranceTeleport.entrancePointAudio.PlayOneShot(entranceTeleport.doorAudios[0]);
|
|
WalkieTalkie.TransmitOneShotAudio(entranceTeleport.entrancePointAudio, entranceTeleport.doorAudios[0]);
|
|
}
|
|
}
|
|
|
|
public override void DoAIInterval()
|
|
{
|
|
base.DoAIInterval();
|
|
if (isEnemyDead)
|
|
{
|
|
agent.speed = 0f;
|
|
return;
|
|
}
|
|
PlayerControllerB playerControllerB = null;
|
|
switch (currentBehaviourStateIndex)
|
|
{
|
|
case 0:
|
|
LookAndRunRandomly(canStartRunning: true);
|
|
if (Time.realtimeSinceStartup - timeAtLastUsingEntrance > 3f && !GetClosestPlayer() && !PathIsIntersectedByLineOfSight(mainEntrancePosition, calculatePathDistance: false, avoidLineOfSight: false))
|
|
{
|
|
if (Vector3.Distance(base.transform.position, mainEntrancePosition) < 1f)
|
|
{
|
|
TeleportMaskedEnemyAndSync(RoundManager.FindMainEntrancePosition(getTeleportPosition: true, !isOutside), !isOutside);
|
|
return;
|
|
}
|
|
if (searchForPlayers.inProgress)
|
|
{
|
|
StopSearch(searchForPlayers);
|
|
}
|
|
SetDestinationToPosition(mainEntrancePosition);
|
|
return;
|
|
}
|
|
if (!searchForPlayers.inProgress)
|
|
{
|
|
StartSearch(base.transform.position, searchForPlayers);
|
|
}
|
|
playerControllerB = CheckLineOfSightForClosestPlayer();
|
|
if (playerControllerB != null)
|
|
{
|
|
LookAtPlayerServerRpc((int)playerControllerB.playerClientId);
|
|
SetMovingTowardsTargetPlayer(playerControllerB);
|
|
SwitchToBehaviourState(1);
|
|
break;
|
|
}
|
|
interestInShipCooldown += AIIntervalTime;
|
|
if (interestInShipCooldown >= 17f && Vector3.Distance(base.transform.position, StartOfRound.Instance.elevatorTransform.position) < 22f)
|
|
{
|
|
SwitchToBehaviourState(2);
|
|
}
|
|
break;
|
|
case 1:
|
|
LookAndRunRandomly(canStartRunning: true, onlySetRunning: true);
|
|
playerControllerB = CheckLineOfSightForClosestPlayer(70f, 50, 1, 3f);
|
|
if (playerControllerB != null)
|
|
{
|
|
lostPlayerInChase = false;
|
|
lostLOSTimer = 0f;
|
|
if (playerControllerB != targetPlayer)
|
|
{
|
|
SetMovingTowardsTargetPlayer(playerControllerB);
|
|
LookAtPlayerServerRpc((int)playerControllerB.playerClientId);
|
|
}
|
|
if (mostOptimalDistance > 17f)
|
|
{
|
|
if (handsOut)
|
|
{
|
|
handsOut = false;
|
|
SetHandsOutServerRpc(setOut: false);
|
|
}
|
|
if (!running)
|
|
{
|
|
running = true;
|
|
creatureAnimator.SetBool("Running", value: true);
|
|
Debug.Log(string.Format("Setting running to true 8; {0}", creatureAnimator.GetBool("Running")));
|
|
SetRunningServerRpc(running: true);
|
|
}
|
|
}
|
|
else if (mostOptimalDistance < 6f)
|
|
{
|
|
if (!handsOut)
|
|
{
|
|
handsOut = true;
|
|
SetHandsOutServerRpc(setOut: true);
|
|
}
|
|
}
|
|
else if (mostOptimalDistance < 12f)
|
|
{
|
|
if (handsOut)
|
|
{
|
|
handsOut = false;
|
|
SetHandsOutServerRpc(setOut: false);
|
|
}
|
|
if (running && !runningRandomly)
|
|
{
|
|
running = false;
|
|
creatureAnimator.SetBool("Running", value: false);
|
|
Debug.Log(string.Format("Setting running to false 1; {0}", creatureAnimator.GetBool("Running")));
|
|
SetRunningServerRpc(running: false);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
lostLOSTimer += AIIntervalTime;
|
|
if (lostLOSTimer > 10f)
|
|
{
|
|
SwitchToBehaviourState(0);
|
|
targetPlayer = null;
|
|
}
|
|
else if (lostLOSTimer > 3.5f)
|
|
{
|
|
lostPlayerInChase = true;
|
|
StopLookingAtTransformServerRpc();
|
|
targetPlayer = null;
|
|
if (running)
|
|
{
|
|
running = false;
|
|
creatureAnimator.SetBool("Running", value: false);
|
|
Debug.Log(string.Format("Setting running to false 2; {0}", creatureAnimator.GetBool("Running")));
|
|
SetRunningServerRpc(running: false);
|
|
}
|
|
if (handsOut)
|
|
{
|
|
handsOut = false;
|
|
SetHandsOutServerRpc(setOut: false);
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
if (!isInsidePlayerShip)
|
|
{
|
|
interestInShipCooldown -= AIIntervalTime;
|
|
}
|
|
if (Vector3.Distance(base.transform.position, StartOfRound.Instance.insideShipPositions[0].position) > 27f || interestInShipCooldown <= 0f)
|
|
{
|
|
SwitchToBehaviourState(0);
|
|
break;
|
|
}
|
|
PlayerControllerB closestPlayer = GetClosestPlayer();
|
|
if (closestPlayer != null)
|
|
{
|
|
PlayerControllerB playerControllerB2 = CheckLineOfSightForClosestPlayer(70f, 20, 0);
|
|
if (playerControllerB2 != null)
|
|
{
|
|
if (stareAtTransform != playerControllerB2.gameplayCamera.transform)
|
|
{
|
|
LookAtPlayerServerRpc((int)playerControllerB2.playerClientId);
|
|
}
|
|
SetMovingTowardsTargetPlayer(playerControllerB2);
|
|
SwitchToBehaviourState(1);
|
|
}
|
|
else if (isInsidePlayerShip && closestPlayer.HasLineOfSightToPosition(base.transform.position + Vector3.up * 0.7f, 4f, 20))
|
|
{
|
|
if (stareAtTransform != closestPlayer.gameplayCamera.transform)
|
|
{
|
|
LookAtPlayerServerRpc((int)closestPlayer.playerClientId);
|
|
}
|
|
SetMovingTowardsTargetPlayer(closestPlayer);
|
|
SwitchToBehaviourState(1);
|
|
}
|
|
else if (mostOptimalDistance < 6f)
|
|
{
|
|
if (stareAtTransform != closestPlayer.gameplayCamera.transform)
|
|
{
|
|
stareAtTransform = closestPlayer.gameplayCamera.transform;
|
|
LookAtPlayerServerRpc((int)closestPlayer.playerClientId);
|
|
}
|
|
}
|
|
else if (mostOptimalDistance > 12f && stareAtTransform != null)
|
|
{
|
|
stareAtTransform = null;
|
|
StopLookingAtTransformServerRpc();
|
|
}
|
|
}
|
|
SetDestinationToPosition(shipHidingSpot);
|
|
if (!crouching && Vector3.Distance(base.transform.position, shipHidingSpot) < 0.4f)
|
|
{
|
|
agent.speed = 0f;
|
|
crouching = true;
|
|
SetCrouchingServerRpc(setOut: true);
|
|
}
|
|
else if (crouching && Vector3.Distance(base.transform.position, shipHidingSpot) > 1f)
|
|
{
|
|
crouching = false;
|
|
SetCrouchingServerRpc(setOut: false);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!(targetPlayer != null) || !PlayerIsTargetable(targetPlayer) || (currentBehaviourStateIndex != 1 && currentBehaviourStateIndex != 2))
|
|
{
|
|
return;
|
|
}
|
|
if (lostPlayerInChase)
|
|
{
|
|
movingTowardsTargetPlayer = false;
|
|
if (!searchForPlayers.inProgress)
|
|
{
|
|
StartSearch(base.transform.position, searchForPlayers);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (searchForPlayers.inProgress)
|
|
{
|
|
StopSearch(searchForPlayers);
|
|
}
|
|
SetMovingTowardsTargetPlayer(targetPlayer);
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void LookAtDirectionServerRpc(Vector3 dir, float time, float vertLookAngle)
|
|
{
|
|
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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
return;
|
|
}
|
|
ServerRpcParams serverRpcParams = default(ServerRpcParams);
|
|
FastBufferWriter bufferWriter = __beginSendServerRpc(2502006210u, serverRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in dir);
|
|
bufferWriter.WriteValueSafe(in time, default(FastBufferWriter.ForPrimitives));
|
|
bufferWriter.WriteValueSafe(in vertLookAngle, default(FastBufferWriter.ForPrimitives));
|
|
__endSendServerRpc(ref bufferWriter, 2502006210u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
LookAtDirectionClientRpc(dir, time, vertLookAngle);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void LookAtDirectionClientRpc(Vector3 dir, float time, float vertLookAngle)
|
|
{
|
|
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(3625708449u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in dir);
|
|
bufferWriter.WriteValueSafe(in time, default(FastBufferWriter.ForPrimitives));
|
|
bufferWriter.WriteValueSafe(in vertLookAngle, default(FastBufferWriter.ForPrimitives));
|
|
__endSendClientRpc(ref bufferWriter, 3625708449u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
LookAtDirection(dir, time, vertLookAngle);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void LookAtPositionServerRpc(Vector3 pos, float time)
|
|
{
|
|
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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
return;
|
|
}
|
|
ServerRpcParams serverRpcParams = default(ServerRpcParams);
|
|
FastBufferWriter bufferWriter = __beginSendServerRpc(675153417u, serverRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in pos);
|
|
bufferWriter.WriteValueSafe(in time, default(FastBufferWriter.ForPrimitives));
|
|
__endSendServerRpc(ref bufferWriter, 675153417u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
LookAtPositionClientRpc(pos, time);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void LookAtPositionClientRpc(Vector3 pos, float time)
|
|
{
|
|
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(432295350u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in pos);
|
|
bufferWriter.WriteValueSafe(in time, default(FastBufferWriter.ForPrimitives));
|
|
__endSendClientRpc(ref bufferWriter, 432295350u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
LookAtPosition(pos, time);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void LookAtPlayerServerRpc(int playerId)
|
|
{
|
|
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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
return;
|
|
}
|
|
ServerRpcParams serverRpcParams = default(ServerRpcParams);
|
|
FastBufferWriter bufferWriter = __beginSendServerRpc(1141953697u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendServerRpc(ref bufferWriter, 1141953697u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
LookAtPlayerClientRpc(playerId);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void LookAtPlayerClientRpc(int playerId)
|
|
{
|
|
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(2397761797u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendClientRpc(ref bufferWriter, 2397761797u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
stareAtTransform = StartOfRound.Instance.allPlayerScripts[playerId].gameplayCamera.transform;
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void StopLookingAtTransformServerRpc()
|
|
{
|
|
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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
return;
|
|
}
|
|
ServerRpcParams serverRpcParams = default(ServerRpcParams);
|
|
FastBufferWriter bufferWriter = __beginSendServerRpc(1407409549u, serverRpcParams, RpcDelivery.Reliable);
|
|
__endSendServerRpc(ref bufferWriter, 1407409549u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
StopLookingAtTransformClientRpc();
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void StopLookingAtTransformClientRpc()
|
|
{
|
|
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(1561581057u, clientRpcParams, RpcDelivery.Reliable);
|
|
__endSendClientRpc(ref bufferWriter, 1561581057u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
stareAtTransform = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void SetHandsOutServerRpc(bool setOut)
|
|
{
|
|
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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
return;
|
|
}
|
|
ServerRpcParams serverRpcParams = default(ServerRpcParams);
|
|
FastBufferWriter bufferWriter = __beginSendServerRpc(519961256u, serverRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in setOut, default(FastBufferWriter.ForPrimitives));
|
|
__endSendServerRpc(ref bufferWriter, 519961256u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
SetHandsOutClientRpc(setOut);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void SetHandsOutClientRpc(bool setOut)
|
|
{
|
|
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(222504553u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in setOut, default(FastBufferWriter.ForPrimitives));
|
|
__endSendClientRpc(ref bufferWriter, 222504553u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
handsOut = setOut;
|
|
creatureAnimator.SetBool("HandsOut", setOut);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void SetCrouchingServerRpc(bool setOut)
|
|
{
|
|
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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
return;
|
|
}
|
|
ServerRpcParams serverRpcParams = default(ServerRpcParams);
|
|
FastBufferWriter bufferWriter = __beginSendServerRpc(2560207573u, serverRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in setOut, default(FastBufferWriter.ForPrimitives));
|
|
__endSendServerRpc(ref bufferWriter, 2560207573u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
SetCrouchingClientRpc(setOut);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void SetCrouchingClientRpc(bool setCrouch)
|
|
{
|
|
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(1162325818u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in setCrouch, default(FastBufferWriter.ForPrimitives));
|
|
__endSendClientRpc(ref bufferWriter, 1162325818u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
crouching = setCrouch;
|
|
creatureAnimator.SetBool("Crouching", setCrouch);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void LookAtFocusedPosition()
|
|
{
|
|
if (inSpecialAnimation)
|
|
{
|
|
verticalLookAngle = Mathf.Lerp(verticalLookAngle, 0f, 10f * Time.deltaTime);
|
|
currentLookAngle = Mathf.Lerp(currentLookAngle, verticalLookAngle, 7f);
|
|
headTiltTarget.localEulerAngles = new Vector3(currentLookAngle, 0f, 0f);
|
|
return;
|
|
}
|
|
if (lookAtPositionTimer <= 0f)
|
|
{
|
|
if (stareAtTransform != null)
|
|
{
|
|
if (!(Vector3.Distance(stareAtTransform.position, base.transform.position) > 80f))
|
|
{
|
|
agent.angularSpeed = 0f;
|
|
RoundManager.Instance.tempTransform.position = base.transform.position;
|
|
RoundManager.Instance.tempTransform.LookAt(stareAtTransform);
|
|
base.transform.rotation = Quaternion.Lerp(base.transform.rotation, RoundManager.Instance.tempTransform.rotation, turnSpeedMultiplier * Time.deltaTime);
|
|
base.transform.eulerAngles = new Vector3(0f, base.transform.eulerAngles.y, 0f);
|
|
headTiltTarget.LookAt(stareAtTransform);
|
|
headTiltTarget.localEulerAngles = new Vector3(headTiltTarget.localEulerAngles.x, 0f, 0f);
|
|
}
|
|
return;
|
|
}
|
|
agent.angularSpeed = 450f;
|
|
verticalLookAngle = Mathf.Clamp(verticalLookAngle, -30f, 10f);
|
|
}
|
|
else
|
|
{
|
|
Debug.Log($"Looking at focused position {focusOnPosition}");
|
|
agent.angularSpeed = 0f;
|
|
lookAtPositionTimer -= Time.deltaTime;
|
|
RoundManager.Instance.tempTransform.position = base.transform.position;
|
|
RoundManager.Instance.tempTransform.LookAt(focusOnPosition);
|
|
base.transform.rotation = Quaternion.Lerp(base.transform.rotation, RoundManager.Instance.tempTransform.rotation, turnSpeedMultiplier * Time.deltaTime);
|
|
base.transform.eulerAngles = new Vector3(0f, base.transform.eulerAngles.y, 0f);
|
|
verticalLookAngle = Mathf.Clamp(verticalLookAngle + UnityEngine.Random.Range(-3f * Time.deltaTime, 3f * Time.deltaTime), -70f, 70f);
|
|
}
|
|
currentLookAngle = Mathf.Lerp(currentLookAngle, verticalLookAngle, 7f);
|
|
headTiltTarget.localEulerAngles = new Vector3(currentLookAngle, 0f, 0f);
|
|
}
|
|
|
|
public void LookAtDirection(Vector3 direction, float lookAtTime = 1f, float vertLookAngle = 0f)
|
|
{
|
|
verticalLookAngle = vertLookAngle;
|
|
direction = Vector3.Normalize(direction * 100f);
|
|
focusOnPosition = base.transform.position + direction * 1000f;
|
|
lookAtPositionTimer = lookAtTime;
|
|
}
|
|
|
|
public void LookAtPosition(Vector3 pos, float lookAtTime = 1f)
|
|
{
|
|
Debug.Log($"Look at position {pos} called! lookatpositiontimer setting to {lookAtTime}");
|
|
focusOnPosition = pos;
|
|
lookAtPositionTimer = lookAtTime;
|
|
float num = Vector3.Angle(base.transform.forward, pos - base.transform.position);
|
|
if (pos.y - headTiltTarget.position.y < 0f)
|
|
{
|
|
num *= -1f;
|
|
}
|
|
verticalLookAngle = num;
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void SetRunningServerRpc(bool running)
|
|
{
|
|
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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
return;
|
|
}
|
|
ServerRpcParams serverRpcParams = default(ServerRpcParams);
|
|
FastBufferWriter bufferWriter = __beginSendServerRpc(3309468324u, serverRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in running, default(FastBufferWriter.ForPrimitives));
|
|
__endSendServerRpc(ref bufferWriter, 3309468324u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
SetRunningClientRpc(running);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void SetRunningClientRpc(bool setRunning)
|
|
{
|
|
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(3512011720u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in setRunning, default(FastBufferWriter.ForPrimitives));
|
|
__endSendClientRpc(ref bufferWriter, 3512011720u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
running = setRunning;
|
|
creatureAnimator.SetBool("Running", setRunning);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CalculateAnimationDirection(float maxSpeed = 1f)
|
|
{
|
|
creatureAnimator.SetBool("IsMoving", Vector3.Distance(base.transform.position, previousPosition) > 0f);
|
|
agentLocalVelocity = animationContainer.InverseTransformDirection(Vector3.ClampMagnitude(base.transform.position - previousPosition, 1f) / (Time.deltaTime * 2f));
|
|
velX = Mathf.Lerp(velX, agentLocalVelocity.x, 10f * Time.deltaTime);
|
|
creatureAnimator.SetFloat("VelocityX", Mathf.Clamp(velX, 0f - maxSpeed, maxSpeed));
|
|
velZ = Mathf.Lerp(velZ, agentLocalVelocity.z, 10f * Time.deltaTime);
|
|
creatureAnimator.SetFloat("VelocityZ", Mathf.Clamp(velZ, 0f - maxSpeed, maxSpeed));
|
|
previousPosition = base.transform.position;
|
|
}
|
|
|
|
public override void DetectNoise(Vector3 noisePosition, float noiseLoudness, int timesPlayedInOneSpot = 0, int noiseID = 0)
|
|
{
|
|
base.DetectNoise(noisePosition, noiseLoudness, timesPlayedInOneSpot, noiseID);
|
|
if (!base.IsOwner || isEnemyDead || inSpecialAnimation)
|
|
{
|
|
return;
|
|
}
|
|
if (Vector3.Distance(noisePosition, base.transform.position + Vector3.up * 0.4f) < 0.75f)
|
|
{
|
|
Debug.Log("Can't hear noise reason A");
|
|
return;
|
|
}
|
|
if (handsOut || (stareAtTransform != null && Vector3.Distance(noisePosition, stareAtTransform.position) < 2f))
|
|
{
|
|
Debug.Log("Can't hear noise reason B");
|
|
return;
|
|
}
|
|
float num = Vector3.Distance(noisePosition, base.transform.position);
|
|
float num2 = noiseLoudness / num;
|
|
Debug.Log($"Noise heard relative loudness: {num2}");
|
|
if (!(num2 < 0.12f) && !(Time.realtimeSinceStartup - timeLookingAtLastNoise < 3f))
|
|
{
|
|
timeLookingAtLastNoise = Time.realtimeSinceStartup;
|
|
LookAtPositionServerRpc(noisePosition, Mathf.Min(num2 * 6f, 2f));
|
|
}
|
|
}
|
|
|
|
public void LateUpdate()
|
|
{
|
|
if (!(stunNormalizedTimer >= 0f) && !isEnemyDead)
|
|
{
|
|
LookAtFocusedPosition();
|
|
}
|
|
}
|
|
|
|
public void SetVisibilityOfMaskedEnemy()
|
|
{
|
|
if (allowSpawningWithoutPlayer)
|
|
{
|
|
if (mimickingPlayer != null && mimickingPlayer.deadBody != null && !mimickingPlayer.deadBody.deactivated)
|
|
{
|
|
if (enemyEnabled)
|
|
{
|
|
enemyEnabled = false;
|
|
EnableEnemyMesh(enable: false);
|
|
}
|
|
}
|
|
else if (!enemyEnabled)
|
|
{
|
|
enemyEnabled = true;
|
|
EnableEnemyMesh(enable: true);
|
|
}
|
|
}
|
|
else if (mimickingPlayer == null || (mimickingPlayer.deadBody != null && !mimickingPlayer.deadBody.deactivated))
|
|
{
|
|
if (enemyEnabled)
|
|
{
|
|
enemyEnabled = false;
|
|
EnableEnemyMesh(enable: false);
|
|
}
|
|
}
|
|
else if (!enemyEnabled)
|
|
{
|
|
enemyEnabled = true;
|
|
EnableEnemyMesh(enable: true);
|
|
}
|
|
}
|
|
|
|
public override void Update()
|
|
{
|
|
base.Update();
|
|
CalculateAnimationDirection();
|
|
SetVisibilityOfMaskedEnemy();
|
|
if (isEnemyDead)
|
|
{
|
|
agent.speed = 0f;
|
|
if (inSpecialAnimation)
|
|
{
|
|
FinishKillAnimation();
|
|
}
|
|
return;
|
|
}
|
|
if (lastPlayerKilled != null && lastPlayerKilled.deadBody != null && !lastPlayerKilled.deadBody.deactivated)
|
|
{
|
|
Debug.Log($"Deactivating body of killed player! {lastPlayerKilled.playerClientId}; {isEnemyDead}");
|
|
lastPlayerKilled.deadBody.DeactivateBody(setActive: false);
|
|
lastPlayerKilled = null;
|
|
}
|
|
if (!enemyEnabled)
|
|
{
|
|
return;
|
|
}
|
|
if (ventAnimationFinished)
|
|
{
|
|
lookRig1.weight = 0.452f;
|
|
lookRig2.weight = 1f;
|
|
creatureAnimator.SetBool("Stunned", stunNormalizedTimer >= 0f);
|
|
if (stunNormalizedTimer >= 0f)
|
|
{
|
|
agent.speed = 0f;
|
|
if (base.IsOwner && searchForPlayers.inProgress)
|
|
{
|
|
StopSearch(searchForPlayers);
|
|
}
|
|
if (inSpecialAnimation)
|
|
{
|
|
FinishKillAnimation();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (inSpecialAnimation)
|
|
{
|
|
return;
|
|
}
|
|
if (walkCheckInterval <= 0f)
|
|
{
|
|
walkCheckInterval = 0.1f;
|
|
positionLastCheck = base.transform.position;
|
|
}
|
|
else
|
|
{
|
|
walkCheckInterval -= Time.deltaTime;
|
|
}
|
|
switch (currentBehaviourStateIndex)
|
|
{
|
|
case 0:
|
|
if (previousBehaviourState != currentBehaviourStateIndex)
|
|
{
|
|
stareAtTransform = null;
|
|
running = false;
|
|
runningRandomly = false;
|
|
creatureAnimator.SetBool("Running", value: false);
|
|
handsOut = false;
|
|
creatureAnimator.SetBool("HandsOut", value: false);
|
|
crouching = false;
|
|
creatureAnimator.SetBool("Crouching", value: false);
|
|
previousBehaviourState = currentBehaviourStateIndex;
|
|
}
|
|
if (running || runningRandomly)
|
|
{
|
|
agent.speed = 7f;
|
|
}
|
|
else
|
|
{
|
|
agent.speed = 3.8f;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (previousBehaviourState != currentBehaviourStateIndex)
|
|
{
|
|
lookAtPositionTimer = 0f;
|
|
if (previousBehaviourState == 0)
|
|
{
|
|
stopAndStareTimer = UnityEngine.Random.Range(2f, 5f);
|
|
}
|
|
runningRandomly = false;
|
|
running = false;
|
|
creatureAnimator.SetBool("Running", value: false);
|
|
crouching = false;
|
|
creatureAnimator.SetBool("Crouching", value: false);
|
|
previousBehaviourState = currentBehaviourStateIndex;
|
|
}
|
|
if (!base.IsOwner)
|
|
{
|
|
break;
|
|
}
|
|
stopAndStareTimer -= Time.deltaTime;
|
|
if (stopAndStareTimer >= 0f)
|
|
{
|
|
agent.speed = 0f;
|
|
break;
|
|
}
|
|
if (stopAndStareTimer <= -5f)
|
|
{
|
|
stopAndStareTimer = UnityEngine.Random.Range(0f, 3f);
|
|
}
|
|
if (running || runningRandomly)
|
|
{
|
|
agent.speed = 8f;
|
|
}
|
|
else
|
|
{
|
|
agent.speed = 3.8f;
|
|
}
|
|
break;
|
|
case 2:
|
|
if (previousBehaviourState != currentBehaviourStateIndex)
|
|
{
|
|
movingTowardsTargetPlayer = false;
|
|
interestInShipCooldown = 17f;
|
|
agent.speed = 5f;
|
|
runningRandomly = false;
|
|
running = false;
|
|
creatureAnimator.SetBool("Running", value: false);
|
|
handsOut = false;
|
|
creatureAnimator.SetBool("HandsOut", value: false);
|
|
if (base.IsOwner)
|
|
{
|
|
ChooseShipHidingSpot();
|
|
}
|
|
previousBehaviourState = currentBehaviourStateIndex;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lookRig1.weight = 0f;
|
|
lookRig2.weight = 0f;
|
|
}
|
|
}
|
|
|
|
private void ChooseShipHidingSpot()
|
|
{
|
|
bool flag = false;
|
|
for (int i = 0; i < StartOfRound.Instance.insideShipPositions.Length; i++)
|
|
{
|
|
if (Physics.Linecast(StartOfRound.Instance.shipDoorAudioSource.transform.position, StartOfRound.Instance.insideShipPositions[i].position, StartOfRound.Instance.collidersAndRoomMaskAndDefault, QueryTriggerInteraction.Ignore) && SetDestinationToPosition(StartOfRound.Instance.insideShipPositions[i].position, checkForPath: true))
|
|
{
|
|
flag = true;
|
|
shipHidingSpot = destination;
|
|
break;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
shipHidingSpot = StartOfRound.Instance.insideShipPositions[UnityEngine.Random.Range(0, StartOfRound.Instance.insideShipPositions.Length)].position;
|
|
}
|
|
}
|
|
|
|
public override void ShipTeleportEnemy()
|
|
{
|
|
base.ShipTeleportEnemy();
|
|
if (teleportCoroutine != null)
|
|
{
|
|
StopCoroutine(teleportCoroutine);
|
|
}
|
|
StartCoroutine(teleportMasked());
|
|
}
|
|
|
|
private IEnumerator teleportMasked()
|
|
{
|
|
teleportParticle.Play();
|
|
movementAudio.PlayOneShot(UnityEngine.Object.FindObjectOfType<ShipTeleporter>().beamUpPlayerBodySFX);
|
|
yield return new WaitForSeconds(3f);
|
|
if (StartOfRound.Instance.shipIsLeaving)
|
|
{
|
|
yield break;
|
|
}
|
|
SetEnemyOutside(outside: true);
|
|
isInsidePlayerShip = true;
|
|
ShipTeleporter[] array = UnityEngine.Object.FindObjectsOfType<ShipTeleporter>();
|
|
ShipTeleporter shipTeleporter = null;
|
|
if (array != null)
|
|
{
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
if (!array[i].isInverseTeleporter)
|
|
{
|
|
shipTeleporter = array[i];
|
|
}
|
|
}
|
|
}
|
|
if (shipTeleporter != null)
|
|
{
|
|
if (base.IsOwner)
|
|
{
|
|
agent.enabled = false;
|
|
base.transform.position = shipTeleporter.teleporterPosition.position;
|
|
agent.enabled = true;
|
|
isInsidePlayerShip = true;
|
|
}
|
|
serverPosition = shipTeleporter.teleporterPosition.position;
|
|
}
|
|
}
|
|
|
|
public void SetEnemyOutside(bool outside = false)
|
|
{
|
|
isOutside = outside;
|
|
mainEntrancePosition = RoundManager.FindMainEntrancePosition(getTeleportPosition: true, isOutside);
|
|
if (outside)
|
|
{
|
|
allAINodes = GameObject.FindGameObjectsWithTag("OutsideAINode");
|
|
}
|
|
else
|
|
{
|
|
allAINodes = GameObject.FindGameObjectsWithTag("AINode");
|
|
}
|
|
if (searchForPlayers.inProgress)
|
|
{
|
|
StopSearch(searchForPlayers);
|
|
}
|
|
}
|
|
|
|
public override void OnDestroy()
|
|
{
|
|
base.OnDestroy();
|
|
}
|
|
|
|
public override void KillEnemy(bool destroy = false)
|
|
{
|
|
base.KillEnemy(destroy);
|
|
creatureAnimator.SetBool("Stunned", value: false);
|
|
creatureAnimator.SetBool("Dead", value: true);
|
|
}
|
|
|
|
public override void HitEnemy(int force = 1, PlayerControllerB playerWhoHit = null, bool playHitSFX = false)
|
|
{
|
|
base.HitEnemy(force, playerWhoHit, playHitSFX);
|
|
enemyHP -= force;
|
|
stunNormalizedTimer = 0.5f;
|
|
creatureAnimator.SetTrigger("HitEnemy");
|
|
stopAndStareTimer = 0f;
|
|
if (((float)UnityEngine.Random.Range(0, 100) < 40f || enemyHP == 1) && !running)
|
|
{
|
|
running = true;
|
|
runningRandomly = true;
|
|
creatureAnimator.SetBool("Running", value: true);
|
|
SetRunningServerRpc(running: true);
|
|
staminaTimer = 5f;
|
|
}
|
|
if (enemyHP <= 0)
|
|
{
|
|
KillEnemyOnOwnerClient();
|
|
}
|
|
}
|
|
|
|
public override void OnCollideWithPlayer(Collider other)
|
|
{
|
|
base.OnCollideWithPlayer(other);
|
|
if (!(stunNormalizedTimer >= 0f) && !isEnemyDead && !(Time.realtimeSinceStartup - timeAtLastUsingEntrance < 1.75f))
|
|
{
|
|
PlayerControllerB playerControllerB = MeetsStandardPlayerCollisionConditions(other, inKillAnimation || startingKillAnimationLocalClient || !enemyEnabled);
|
|
if (playerControllerB != null)
|
|
{
|
|
KillPlayerAnimationServerRpc((int)playerControllerB.playerClientId);
|
|
startingKillAnimationLocalClient = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void KillPlayerAnimationServerRpc(int playerObjectId)
|
|
{
|
|
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(3192502457u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObjectId);
|
|
__endSendServerRpc(ref bufferWriter, 3192502457u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
if (!inKillAnimation && !playersKilled.Contains(playerObjectId))
|
|
{
|
|
inSpecialAnimationWithPlayer = StartOfRound.Instance.allPlayerScripts[playerObjectId];
|
|
inSpecialAnimationWithPlayer.inAnimationWithEnemy = this;
|
|
inKillAnimation = true;
|
|
inSpecialAnimation = true;
|
|
isClientCalculatingAI = false;
|
|
KillPlayerAnimationClientRpc(playerObjectId);
|
|
}
|
|
else
|
|
{
|
|
CancelKillAnimationClientRpc(playerObjectId);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void CancelKillAnimationClientRpc(int playerObjectId)
|
|
{
|
|
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(4032958935u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObjectId);
|
|
__endSendClientRpc(ref bufferWriter, 4032958935u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && (int)GameNetworkManager.Instance.localPlayerController.playerClientId == playerObjectId)
|
|
{
|
|
startingKillAnimationLocalClient = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void KillPlayerAnimationClientRpc(int playerObjectId)
|
|
{
|
|
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(3071650946u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObjectId);
|
|
__endSendClientRpc(ref bufferWriter, 3071650946u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost))
|
|
{
|
|
return;
|
|
}
|
|
if (searchForPlayers.inProgress)
|
|
{
|
|
StopSearch(searchForPlayers);
|
|
}
|
|
inSpecialAnimationWithPlayer = StartOfRound.Instance.allPlayerScripts[playerObjectId];
|
|
if (inSpecialAnimationWithPlayer == GameNetworkManager.Instance.localPlayerController)
|
|
{
|
|
startingKillAnimationLocalClient = false;
|
|
}
|
|
if (inSpecialAnimationWithPlayer == null || inSpecialAnimationWithPlayer.isPlayerDead || !inSpecialAnimationWithPlayer.isInsideFactory)
|
|
{
|
|
FinishKillAnimation();
|
|
return;
|
|
}
|
|
inSpecialAnimationWithPlayer.inAnimationWithEnemy = this;
|
|
if (inSpecialAnimationWithPlayer == GameNetworkManager.Instance.localPlayerController)
|
|
{
|
|
inSpecialAnimationWithPlayer.CancelSpecialTriggerAnimations();
|
|
}
|
|
inKillAnimation = true;
|
|
inSpecialAnimation = true;
|
|
creatureAnimator.SetBool("killing", value: true);
|
|
agent.enabled = false;
|
|
inSpecialAnimationWithPlayer.inSpecialInteractAnimation = true;
|
|
inSpecialAnimationWithPlayer.snapToServerPosition = true;
|
|
Vector3 origin = ((!inSpecialAnimationWithPlayer.IsOwner) ? inSpecialAnimationWithPlayer.transform.parent.TransformPoint(inSpecialAnimationWithPlayer.serverPlayerPosition) : inSpecialAnimationWithPlayer.transform.position);
|
|
Vector3 vector = base.transform.position - base.transform.forward * 2f;
|
|
vector.y = origin.y;
|
|
playerRay = new Ray(origin, vector - inSpecialAnimationWithPlayer.transform.position);
|
|
if (killAnimationCoroutine != null)
|
|
{
|
|
StopCoroutine(killAnimationCoroutine);
|
|
}
|
|
killAnimationCoroutine = StartCoroutine(killAnimation());
|
|
}
|
|
|
|
private IEnumerator killAnimation()
|
|
{
|
|
WalkieTalkie.TransmitOneShotAudio(creatureSFX, enemyType.audioClips[0]);
|
|
creatureSFX.PlayOneShot(enemyType.audioClips[0]);
|
|
Vector3 endPosition = playerRay.GetPoint(0.7f);
|
|
if (isOutside && endPosition.y < -80f)
|
|
{
|
|
SetEnemyOutside();
|
|
}
|
|
else if (!isOutside && endPosition.y > -80f)
|
|
{
|
|
SetEnemyOutside(outside: true);
|
|
}
|
|
inSpecialAnimationWithPlayer.disableSyncInAnimation = true;
|
|
inSpecialAnimationWithPlayer.disableLookInput = true;
|
|
RoundManager.Instance.tempTransform.position = inSpecialAnimationWithPlayer.transform.position;
|
|
RoundManager.Instance.tempTransform.LookAt(endPosition);
|
|
Quaternion startingPlayerRot = inSpecialAnimationWithPlayer.transform.rotation;
|
|
Quaternion targetRot = RoundManager.Instance.tempTransform.rotation;
|
|
Vector3 startingPosition = base.transform.position;
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
base.transform.LookAt(inSpecialAnimationWithPlayer.transform.position);
|
|
base.transform.eulerAngles = new Vector3(0f, base.transform.eulerAngles.y, 0f);
|
|
}
|
|
base.transform.position = Vector3.Lerp(startingPosition, endPosition, (float)i / 8f);
|
|
inSpecialAnimationWithPlayer.transform.rotation = Quaternion.Lerp(startingPlayerRot, targetRot, (float)i / 8f);
|
|
inSpecialAnimationWithPlayer.transform.eulerAngles = new Vector3(0f, inSpecialAnimationWithPlayer.transform.eulerAngles.y, 0f);
|
|
yield return null;
|
|
}
|
|
base.transform.position = endPosition;
|
|
inSpecialAnimationWithPlayer.transform.rotation = targetRot;
|
|
inSpecialAnimationWithPlayer.transform.eulerAngles = new Vector3(0f, inSpecialAnimationWithPlayer.transform.eulerAngles.y, 0f);
|
|
yield return new WaitForSeconds(0.3f);
|
|
SetMaskGlow(enable: true);
|
|
yield return new WaitForSeconds(1.2f);
|
|
maskFloodParticle.Play();
|
|
if (inSpecialAnimationWithPlayer == GameNetworkManager.Instance.localPlayerController)
|
|
{
|
|
HUDManager.Instance.HUDAnimator.SetBool("biohazardDamage", value: true);
|
|
}
|
|
creatureSFX.PlayOneShot(enemyType.audioClips[2]);
|
|
WalkieTalkie.TransmitOneShotAudio(creatureSFX, enemyType.audioClips[2]);
|
|
yield return new WaitForSeconds(1.5f);
|
|
lastPlayerKilled = inSpecialAnimationWithPlayer;
|
|
if (inSpecialAnimationWithPlayer != null)
|
|
{
|
|
bool flag = inSpecialAnimationWithPlayer.transform.position.y < -80f;
|
|
inSpecialAnimationWithPlayer.KillPlayer(Vector3.zero, spawnBody: false, CauseOfDeath.Strangulation, 4);
|
|
inSpecialAnimationWithPlayer.snapToServerPosition = false;
|
|
if (base.IsServer)
|
|
{
|
|
playersKilled.Add((int)inSpecialAnimationWithPlayer.playerClientId);
|
|
NetworkObjectReference netObjectRef = RoundManager.Instance.SpawnEnemyGameObject(GetGroundPosition(playerRay.origin), inSpecialAnimationWithPlayer.transform.eulerAngles.y, -1, enemyType);
|
|
if (netObjectRef.TryGet(out var networkObject))
|
|
{
|
|
MaskedPlayerEnemy component = networkObject.GetComponent<MaskedPlayerEnemy>();
|
|
component.SetSuit(inSpecialAnimationWithPlayer.currentSuitID);
|
|
component.mimickingPlayer = inSpecialAnimationWithPlayer;
|
|
component.SetEnemyOutside(!flag);
|
|
inSpecialAnimationWithPlayer.redirectToEnemy = component;
|
|
if (inSpecialAnimationWithPlayer.deadBody != null)
|
|
{
|
|
inSpecialAnimationWithPlayer.deadBody.DeactivateBody(setActive: false);
|
|
}
|
|
}
|
|
CreateMimicClientRpc(netObjectRef, flag, (int)inSpecialAnimationWithPlayer.playerClientId);
|
|
}
|
|
FinishKillAnimation(killedPlayer: true);
|
|
}
|
|
else
|
|
{
|
|
FinishKillAnimation();
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void CreateMimicClientRpc(NetworkObjectReference netObjectRef, bool inFactory, int playerKilled)
|
|
{
|
|
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(1687215509u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in netObjectRef, default(FastBufferWriter.ForNetworkSerializable));
|
|
bufferWriter.WriteValueSafe(in inFactory, default(FastBufferWriter.ForPrimitives));
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerKilled);
|
|
__endSendClientRpc(ref bufferWriter, 1687215509u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsServer)
|
|
{
|
|
StartCoroutine(waitForMimicEnemySpawn(netObjectRef, inFactory, playerKilled));
|
|
}
|
|
}
|
|
}
|
|
|
|
private IEnumerator waitForMimicEnemySpawn(NetworkObjectReference netObjectRef, bool inFactory, int playerKilled)
|
|
{
|
|
PlayerControllerB player = StartOfRound.Instance.allPlayerScripts[playerKilled];
|
|
NetworkObject netObject = null;
|
|
float startTime = Time.realtimeSinceStartup;
|
|
yield return new WaitUntil(() => Time.realtimeSinceStartup - startTime > 20f || netObjectRef.TryGet(out netObject));
|
|
if (player.deadBody == null)
|
|
{
|
|
startTime = Time.realtimeSinceStartup;
|
|
yield return new WaitUntil(() => Time.realtimeSinceStartup - startTime > 20f || player.deadBody != null);
|
|
}
|
|
if (!(player.deadBody == null))
|
|
{
|
|
player.deadBody.DeactivateBody(setActive: false);
|
|
if (netObject != null)
|
|
{
|
|
MaskedPlayerEnemy component = netObject.GetComponent<MaskedPlayerEnemy>();
|
|
component.mimickingPlayer = player;
|
|
component.SetSuit(player.currentSuitID);
|
|
component.SetEnemyOutside(!inFactory);
|
|
player.redirectToEnemy = component;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void CancelSpecialAnimationWithPlayer()
|
|
{
|
|
FinishKillAnimation();
|
|
base.CancelSpecialAnimationWithPlayer();
|
|
if (inSpecialAnimationWithPlayer == GameNetworkManager.Instance.localPlayerController)
|
|
{
|
|
HUDManager.Instance.HUDAnimator.SetBool("biohazardDamage", value: false);
|
|
}
|
|
}
|
|
|
|
public void FinishKillAnimation(bool killedPlayer = false)
|
|
{
|
|
if (!killedPlayer)
|
|
{
|
|
creatureSFX.Stop();
|
|
}
|
|
if (killAnimationCoroutine != null)
|
|
{
|
|
StopCoroutine(killAnimationCoroutine);
|
|
}
|
|
inSpecialAnimation = false;
|
|
inKillAnimation = false;
|
|
creatureAnimator.SetBool("killing", value: false);
|
|
startingKillAnimationLocalClient = false;
|
|
if (inSpecialAnimationWithPlayer != null)
|
|
{
|
|
inSpecialAnimationWithPlayer.disableSyncInAnimation = false;
|
|
inSpecialAnimationWithPlayer.disableLookInput = false;
|
|
inSpecialAnimationWithPlayer.inSpecialInteractAnimation = false;
|
|
inSpecialAnimationWithPlayer.snapToServerPosition = false;
|
|
inSpecialAnimationWithPlayer.inAnimationWithEnemy = null;
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("masked enemy inSpecialAnimationWithPlayer is null");
|
|
}
|
|
SetMaskGlow(enable: false);
|
|
maskFloodParticle.Stop(withChildren: true, ParticleSystemStopBehavior.StopEmitting);
|
|
stopAndStareTimer = 3f;
|
|
movingTowardsTargetPlayer = false;
|
|
if (base.IsOwner)
|
|
{
|
|
base.transform.position = GetGroundPosition(base.transform.position);
|
|
agent.enabled = true;
|
|
isClientCalculatingAI = true;
|
|
}
|
|
if (base.NetworkObject.IsSpawned)
|
|
{
|
|
SwitchToBehaviourStateOnLocalClient(0);
|
|
if (base.IsServer)
|
|
{
|
|
SwitchToBehaviourState(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
private Vector3 GetGroundPosition(Vector3 startingPos)
|
|
{
|
|
Vector3 pos = startingPos;
|
|
pos = RoundManager.Instance.GetNavMeshPosition(pos, default(NavMeshHit), 3f);
|
|
if (!RoundManager.Instance.GotNavMeshPositionResult)
|
|
{
|
|
if (Physics.Raycast(startingPos + Vector3.up * 0.15f, -Vector3.up, out var hitInfo, 50f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, QueryTriggerInteraction.Ignore))
|
|
{
|
|
pos = RoundManager.Instance.GetNavMeshPosition(hitInfo.point, default(NavMeshHit), 10f);
|
|
}
|
|
else
|
|
{
|
|
int num = UnityEngine.Random.Range(0, allAINodes.Length);
|
|
if (allAINodes != null && allAINodes[num] != null)
|
|
{
|
|
pos = allAINodes[num].transform.position;
|
|
}
|
|
}
|
|
}
|
|
return pos;
|
|
}
|
|
|
|
public void SetSuit(int suitId)
|
|
{
|
|
Material suitMaterial = StartOfRound.Instance.unlockablesList.unlockables[suitId].suitMaterial;
|
|
rendererLOD0.material = suitMaterial;
|
|
rendererLOD1.material = suitMaterial;
|
|
rendererLOD2.material = suitMaterial;
|
|
}
|
|
|
|
public void SetMaskType(int maskType)
|
|
{
|
|
switch (maskType)
|
|
{
|
|
case 4:
|
|
maskTypes[0].SetActive(value: true);
|
|
maskTypes[1].SetActive(value: false);
|
|
maskTypeIndex = 0;
|
|
break;
|
|
case 5:
|
|
maskTypes[1].SetActive(value: true);
|
|
maskTypes[0].SetActive(value: false);
|
|
maskTypeIndex = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void GetMaterialStandingOn()
|
|
{
|
|
enemyRay = new Ray(base.transform.position + Vector3.up, -Vector3.up);
|
|
if (Physics.Raycast(enemyRay, out enemyRayHit, 6f, StartOfRound.Instance.walkableSurfacesMask, QueryTriggerInteraction.Ignore))
|
|
{
|
|
if (enemyRayHit.collider.CompareTag(StartOfRound.Instance.footstepSurfaces[currentFootstepSurfaceIndex].surfaceTag))
|
|
{
|
|
return;
|
|
}
|
|
for (int i = 0; i < StartOfRound.Instance.footstepSurfaces.Length; i++)
|
|
{
|
|
if (enemyRayHit.collider.CompareTag(StartOfRound.Instance.footstepSurfaces[i].surfaceTag))
|
|
{
|
|
currentFootstepSurfaceIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.DrawRay(enemyRay.origin, enemyRay.direction, Color.white, 0.3f);
|
|
}
|
|
}
|
|
|
|
public void PlayFootstepSound()
|
|
{
|
|
GetMaterialStandingOn();
|
|
int num = UnityEngine.Random.Range(0, StartOfRound.Instance.footstepSurfaces[currentFootstepSurfaceIndex].clips.Length);
|
|
if (num == previousFootstepClip)
|
|
{
|
|
num = (num + 1) % StartOfRound.Instance.footstepSurfaces[currentFootstepSurfaceIndex].clips.Length;
|
|
}
|
|
movementAudio.pitch = UnityEngine.Random.Range(0.93f, 1.07f);
|
|
float num2 = 0.95f;
|
|
if (!sprinting)
|
|
{
|
|
num2 = 0.75f;
|
|
}
|
|
movementAudio.PlayOneShot(StartOfRound.Instance.footstepSurfaces[currentFootstepSurfaceIndex].clips[num], num2);
|
|
previousFootstepClip = num;
|
|
WalkieTalkie.TransmitOneShotAudio(movementAudio, StartOfRound.Instance.footstepSurfaces[currentFootstepSurfaceIndex].clips[num], num2);
|
|
}
|
|
|
|
public override void AnimationEventA()
|
|
{
|
|
base.AnimationEventA();
|
|
PlayFootstepSound();
|
|
}
|
|
|
|
public void SetMaskGlow(bool enable)
|
|
{
|
|
maskEyesGlow[maskTypeIndex].enabled = enable;
|
|
maskEyesGlowLight.enabled = enable;
|
|
if (enable)
|
|
{
|
|
creatureSFX.PlayOneShot(enemyType.audioClips[1]);
|
|
}
|
|
}
|
|
|
|
protected override void __initializeVariables()
|
|
{
|
|
base.__initializeVariables();
|
|
}
|
|
|
|
[RuntimeInitializeOnLoadMethod]
|
|
internal static void InitializeRPCS_MaskedPlayerEnemy()
|
|
{
|
|
NetworkManager.__rpc_func_table.Add(3110137062u, __rpc_handler_3110137062);
|
|
NetworkManager.__rpc_func_table.Add(1038760037u, __rpc_handler_1038760037);
|
|
NetworkManager.__rpc_func_table.Add(657232826u, __rpc_handler_657232826);
|
|
NetworkManager.__rpc_func_table.Add(2539470808u, __rpc_handler_2539470808);
|
|
NetworkManager.__rpc_func_table.Add(2502006210u, __rpc_handler_2502006210);
|
|
NetworkManager.__rpc_func_table.Add(3625708449u, __rpc_handler_3625708449);
|
|
NetworkManager.__rpc_func_table.Add(675153417u, __rpc_handler_675153417);
|
|
NetworkManager.__rpc_func_table.Add(432295350u, __rpc_handler_432295350);
|
|
NetworkManager.__rpc_func_table.Add(1141953697u, __rpc_handler_1141953697);
|
|
NetworkManager.__rpc_func_table.Add(2397761797u, __rpc_handler_2397761797);
|
|
NetworkManager.__rpc_func_table.Add(1407409549u, __rpc_handler_1407409549);
|
|
NetworkManager.__rpc_func_table.Add(1561581057u, __rpc_handler_1561581057);
|
|
NetworkManager.__rpc_func_table.Add(519961256u, __rpc_handler_519961256);
|
|
NetworkManager.__rpc_func_table.Add(222504553u, __rpc_handler_222504553);
|
|
NetworkManager.__rpc_func_table.Add(2560207573u, __rpc_handler_2560207573);
|
|
NetworkManager.__rpc_func_table.Add(1162325818u, __rpc_handler_1162325818);
|
|
NetworkManager.__rpc_func_table.Add(3309468324u, __rpc_handler_3309468324);
|
|
NetworkManager.__rpc_func_table.Add(3512011720u, __rpc_handler_3512011720);
|
|
NetworkManager.__rpc_func_table.Add(3192502457u, __rpc_handler_3192502457);
|
|
NetworkManager.__rpc_func_table.Add(4032958935u, __rpc_handler_4032958935);
|
|
NetworkManager.__rpc_func_table.Add(3071650946u, __rpc_handler_3071650946);
|
|
NetworkManager.__rpc_func_table.Add(1687215509u, __rpc_handler_1687215509);
|
|
}
|
|
|
|
private static void __rpc_handler_3110137062(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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((MaskedPlayerEnemy)target).SetEnemyAsHavingNoPlayerServerRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1038760037(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((MaskedPlayerEnemy)target).SetEnemyAsHavingNoPlayerClientRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_657232826(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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
reader.ReadValueSafe(out Vector3 value);
|
|
reader.ReadValueSafe(out bool value2, default(FastBufferWriter.ForPrimitives));
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((MaskedPlayerEnemy)target).TeleportMaskedEnemyServerRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2539470808(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
reader.ReadValueSafe(out Vector3 value);
|
|
reader.ReadValueSafe(out bool value2, default(FastBufferWriter.ForPrimitives));
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((MaskedPlayerEnemy)target).TeleportMaskedEnemyClientRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2502006210(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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
return;
|
|
}
|
|
reader.ReadValueSafe(out Vector3 value);
|
|
reader.ReadValueSafe(out float value2, default(FastBufferWriter.ForPrimitives));
|
|
reader.ReadValueSafe(out float value3, default(FastBufferWriter.ForPrimitives));
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((MaskedPlayerEnemy)target).LookAtDirectionServerRpc(value, value2, value3);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
|
|
private static void __rpc_handler_3625708449(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
reader.ReadValueSafe(out Vector3 value);
|
|
reader.ReadValueSafe(out float value2, default(FastBufferWriter.ForPrimitives));
|
|
reader.ReadValueSafe(out float value3, default(FastBufferWriter.ForPrimitives));
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((MaskedPlayerEnemy)target).LookAtDirectionClientRpc(value, value2, value3);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_675153417(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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
reader.ReadValueSafe(out Vector3 value);
|
|
reader.ReadValueSafe(out float value2, default(FastBufferWriter.ForPrimitives));
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((MaskedPlayerEnemy)target).LookAtPositionServerRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_432295350(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
reader.ReadValueSafe(out Vector3 value);
|
|
reader.ReadValueSafe(out float value2, default(FastBufferWriter.ForPrimitives));
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((MaskedPlayerEnemy)target).LookAtPositionClientRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1141953697(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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value);
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((MaskedPlayerEnemy)target).LookAtPlayerServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2397761797(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;
|
|
((MaskedPlayerEnemy)target).LookAtPlayerClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1407409549(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 <= LogLevel.Normal)
|
|
{
|
|
Debug.LogError("Only the owner can invoke a ServerRpc that requires ownership!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((MaskedPlayerEnemy)target).StopLookingAtTransformServerRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1561581057(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((MaskedPlayerEnemy)target).StopLookingAtTransformClientRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_519961256(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 <= 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;
|
|
((MaskedPlayerEnemy)target).SetHandsOutServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_222504553(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;
|
|
((MaskedPlayerEnemy)target).SetHandsOutClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2560207573(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 <= 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;
|
|
((MaskedPlayerEnemy)target).SetCrouchingServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1162325818(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;
|
|
((MaskedPlayerEnemy)target).SetCrouchingClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3309468324(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 <= 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;
|
|
((MaskedPlayerEnemy)target).SetRunningServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3512011720(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;
|
|
((MaskedPlayerEnemy)target).SetRunningClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3192502457(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;
|
|
((MaskedPlayerEnemy)target).KillPlayerAnimationServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_4032958935(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;
|
|
((MaskedPlayerEnemy)target).CancelKillAnimationClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3071650946(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;
|
|
((MaskedPlayerEnemy)target).KillPlayerAnimationClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1687215509(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
reader.ReadValueSafe(out NetworkObjectReference value, default(FastBufferWriter.ForNetworkSerializable));
|
|
reader.ReadValueSafe(out bool value2, default(FastBufferWriter.ForPrimitives));
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value3);
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((MaskedPlayerEnemy)target).CreateMimicClientRpc(value, value2, value3);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
protected internal override string __getTypeName()
|
|
{
|
|
return "MaskedPlayerEnemy";
|
|
}
|
|
}
|