792 lines
26 KiB
C#
792 lines
26 KiB
C#
using System.Collections;
|
|
using GameNetcodeStuff;
|
|
using Unity.Netcode;
|
|
using UnityEngine;
|
|
|
|
public class CrawlerAI : EnemyAI
|
|
{
|
|
public AISearchRoutine searchForPlayers;
|
|
|
|
private float checkLineOfSightInterval;
|
|
|
|
public float maxSearchAndRoamRadius = 100f;
|
|
|
|
[Space(5f)]
|
|
public float noticePlayerTimer;
|
|
|
|
private bool hasEnteredChaseMode;
|
|
|
|
private bool lostPlayerInChase;
|
|
|
|
private bool beginningChasingThisClient;
|
|
|
|
private Collider[] nearPlayerColliders;
|
|
|
|
public AudioClip shortRoar;
|
|
|
|
public AudioClip[] hitWallSFX;
|
|
|
|
public AudioClip bitePlayerSFX;
|
|
|
|
private Vector3 previousPosition;
|
|
|
|
private float previousVelocity;
|
|
|
|
private float wallCollisionSFXDebounce;
|
|
|
|
private float timeSinceHittingPlayer;
|
|
|
|
private bool ateTargetPlayerBody;
|
|
|
|
private Coroutine eatPlayerBodyCoroutine;
|
|
|
|
public Transform mouthTarget;
|
|
|
|
public AudioClip eatPlayerSFX;
|
|
|
|
public AudioClip[] hitCrawlerSFX;
|
|
|
|
public AudioClip[] longRoarSFX;
|
|
|
|
public DeadBodyInfo currentlyHeldBody;
|
|
|
|
private bool pullingSecondLimb;
|
|
|
|
private float agentSpeedWithNegative;
|
|
|
|
private Vector3 lastPositionOfSeenPlayer;
|
|
|
|
public override void Start()
|
|
{
|
|
base.Start();
|
|
nearPlayerColliders = new Collider[4];
|
|
}
|
|
|
|
public override void DoAIInterval()
|
|
{
|
|
base.DoAIInterval();
|
|
if (StartOfRound.Instance.livingPlayers == 0 || isEnemyDead)
|
|
{
|
|
return;
|
|
}
|
|
switch (currentBehaviourStateIndex)
|
|
{
|
|
case 0:
|
|
if (!searchForPlayers.inProgress)
|
|
{
|
|
StartSearch(base.transform.position, searchForPlayers);
|
|
Debug.Log($"Crawler: Started new search; is searching?: {searchForPlayers.inProgress}");
|
|
}
|
|
break;
|
|
case 1:
|
|
CheckForVeryClosePlayer();
|
|
if (lostPlayerInChase)
|
|
{
|
|
movingTowardsTargetPlayer = false;
|
|
if (!searchForPlayers.inProgress)
|
|
{
|
|
searchForPlayers.searchWidth = 30f;
|
|
StartSearch(lastPositionOfSeenPlayer, searchForPlayers);
|
|
Debug.Log("Crawler: Lost player in chase; beginning search where the player was last seen");
|
|
}
|
|
}
|
|
else if (searchForPlayers.inProgress)
|
|
{
|
|
StopSearch(searchForPlayers);
|
|
movingTowardsTargetPlayer = true;
|
|
Debug.Log("Crawler: Found player during chase; stopping search coroutine and moving after target player");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public override void FinishedCurrentSearchRoutine()
|
|
{
|
|
base.FinishedCurrentSearchRoutine();
|
|
searchForPlayers.searchWidth = Mathf.Clamp(searchForPlayers.searchWidth + 10f, 1f, maxSearchAndRoamRadius);
|
|
}
|
|
|
|
public override void Update()
|
|
{
|
|
base.Update();
|
|
if (isEnemyDead)
|
|
{
|
|
return;
|
|
}
|
|
if (!base.IsOwner)
|
|
{
|
|
inSpecialAnimation = false;
|
|
}
|
|
CalculateAgentSpeed();
|
|
timeSinceHittingPlayer += Time.deltaTime;
|
|
if (GameNetworkManager.Instance.localPlayerController.HasLineOfSightToPosition(base.transform.position + Vector3.up * 0.25f, 80f, 25, 5f))
|
|
{
|
|
if (currentBehaviourStateIndex == 1)
|
|
{
|
|
GameNetworkManager.Instance.localPlayerController.IncreaseFearLevelOverTime(0.8f);
|
|
}
|
|
else
|
|
{
|
|
GameNetworkManager.Instance.localPlayerController.IncreaseFearLevelOverTime(0.8f, 0.5f);
|
|
}
|
|
}
|
|
switch (currentBehaviourStateIndex)
|
|
{
|
|
case 0:
|
|
{
|
|
if (hasEnteredChaseMode)
|
|
{
|
|
hasEnteredChaseMode = false;
|
|
searchForPlayers.searchWidth = 25f;
|
|
beginningChasingThisClient = false;
|
|
noticePlayerTimer = 0f;
|
|
useSecondaryAudiosOnAnimatedObjects = false;
|
|
openDoorSpeedMultiplier = 0.6f;
|
|
agent.stoppingDistance = 0f;
|
|
agent.speed = 7f;
|
|
}
|
|
if (checkLineOfSightInterval <= 0.05f)
|
|
{
|
|
checkLineOfSightInterval += Time.deltaTime;
|
|
break;
|
|
}
|
|
checkLineOfSightInterval = 0f;
|
|
PlayerControllerB playerControllerB3;
|
|
if (stunnedByPlayer != null)
|
|
{
|
|
playerControllerB3 = stunnedByPlayer;
|
|
noticePlayerTimer = 1f;
|
|
}
|
|
else
|
|
{
|
|
playerControllerB3 = CheckLineOfSightForPlayer(55f);
|
|
}
|
|
if (playerControllerB3 == GameNetworkManager.Instance.localPlayerController)
|
|
{
|
|
noticePlayerTimer = Mathf.Clamp(noticePlayerTimer + 0.05f, 0f, 10f);
|
|
if (noticePlayerTimer > 0.2f && !beginningChasingThisClient)
|
|
{
|
|
beginningChasingThisClient = true;
|
|
BeginChasingPlayerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
|
|
ChangeOwnershipOfEnemy(playerControllerB3.actualClientId);
|
|
Debug.Log("Begin chasing on local client");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
noticePlayerTimer -= Time.deltaTime;
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
if (!hasEnteredChaseMode)
|
|
{
|
|
hasEnteredChaseMode = true;
|
|
lostPlayerInChase = false;
|
|
checkLineOfSightInterval = 0f;
|
|
noticePlayerTimer = 0f;
|
|
beginningChasingThisClient = false;
|
|
useSecondaryAudiosOnAnimatedObjects = true;
|
|
openDoorSpeedMultiplier = 1.5f;
|
|
agent.stoppingDistance = 0.5f;
|
|
agent.speed = 0f;
|
|
}
|
|
if (!base.IsOwner || stunNormalizedTimer > 0f)
|
|
{
|
|
break;
|
|
}
|
|
if (checkLineOfSightInterval <= 0.075f)
|
|
{
|
|
checkLineOfSightInterval += Time.deltaTime;
|
|
break;
|
|
}
|
|
checkLineOfSightInterval = 0f;
|
|
if (!ateTargetPlayerBody && targetPlayer != null && targetPlayer.deadBody != null && targetPlayer.deadBody.grabBodyObject != null && targetPlayer.deadBody.grabBodyObject.grabbableToEnemies && eatPlayerBodyCoroutine == null && Vector3.Distance(base.transform.position, targetPlayer.deadBody.bodyParts[0].transform.position) < 3.3f)
|
|
{
|
|
Debug.Log("Crawler: Eat player body start");
|
|
ateTargetPlayerBody = true;
|
|
inSpecialAnimation = true;
|
|
eatPlayerBodyCoroutine = StartCoroutine(EatPlayerBodyAnimation((int)targetPlayer.playerClientId));
|
|
EatPlayerBodyServerRpc((int)targetPlayer.playerClientId);
|
|
}
|
|
if (inSpecialAnimation)
|
|
{
|
|
break;
|
|
}
|
|
if (lostPlayerInChase)
|
|
{
|
|
PlayerControllerB playerControllerB = CheckLineOfSightForPlayer(55f);
|
|
if ((bool)playerControllerB)
|
|
{
|
|
noticePlayerTimer = 0f;
|
|
lostPlayerInChase = false;
|
|
MakeScreechNoiseServerRpc();
|
|
if (playerControllerB != targetPlayer)
|
|
{
|
|
SetMovingTowardsTargetPlayer(playerControllerB);
|
|
ateTargetPlayerBody = false;
|
|
ChangeOwnershipOfEnemy(playerControllerB.actualClientId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
noticePlayerTimer -= 0.075f;
|
|
if (noticePlayerTimer < -15f)
|
|
{
|
|
SwitchToBehaviourState(0);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
PlayerControllerB playerControllerB2 = CheckLineOfSightForPlayer(65f, 80);
|
|
if (playerControllerB2 != null)
|
|
{
|
|
noticePlayerTimer = 0f;
|
|
lastPositionOfSeenPlayer = playerControllerB2.transform.position;
|
|
if (playerControllerB2 != targetPlayer)
|
|
{
|
|
targetPlayer = playerControllerB2;
|
|
ateTargetPlayerBody = false;
|
|
ChangeOwnershipOfEnemy(targetPlayer.actualClientId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
noticePlayerTimer += 0.075f;
|
|
if (noticePlayerTimer > 1.5f)
|
|
{
|
|
lostPlayerInChase = true;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CalculateAgentSpeed()
|
|
{
|
|
if (stunNormalizedTimer >= 0f)
|
|
{
|
|
agent.speed = 0.1f;
|
|
agent.acceleration = 200f;
|
|
creatureAnimator.SetBool("stunned", value: true);
|
|
return;
|
|
}
|
|
creatureAnimator.SetBool("stunned", value: false);
|
|
creatureAnimator.SetFloat("speedMultiplier", Vector3.ClampMagnitude(base.transform.position - previousPosition, 1f).sqrMagnitude / (Time.deltaTime / 1.4f));
|
|
float num = (previousPosition - base.transform.position).sqrMagnitude / (Time.deltaTime / 1.4f);
|
|
if (base.IsOwner && previousVelocity - num > Mathf.Clamp(num * 0.25f, 2f, 100f))
|
|
{
|
|
agent.speed = 0f;
|
|
if (currentBehaviourStateIndex == 1)
|
|
{
|
|
if (wallCollisionSFXDebounce > 0.5f)
|
|
{
|
|
if (base.IsServer)
|
|
{
|
|
CollideWithWallServerRpc();
|
|
}
|
|
else
|
|
{
|
|
CollideWithWallClientRpc();
|
|
}
|
|
}
|
|
wallCollisionSFXDebounce = 0f;
|
|
}
|
|
}
|
|
wallCollisionSFXDebounce += Time.deltaTime;
|
|
previousVelocity = num;
|
|
previousPosition = base.transform.position;
|
|
if (currentBehaviourStateIndex == 0)
|
|
{
|
|
agent.speed = 8f;
|
|
agent.acceleration = 26f;
|
|
}
|
|
else if (currentBehaviourStateIndex == 1)
|
|
{
|
|
agentSpeedWithNegative += Time.deltaTime * 1.5f;
|
|
agent.speed = Mathf.Clamp(agentSpeedWithNegative, -3f, 16f);
|
|
agent.acceleration = Mathf.Clamp(45f - num * 12f, 4f, 80f);
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void CollideWithWallServerRpc()
|
|
{
|
|
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(3661877694u, serverRpcParams, RpcDelivery.Reliable);
|
|
__endSendServerRpc(ref bufferWriter, 3661877694u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
CollideWithWallClientRpc();
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void CollideWithWallClientRpc()
|
|
{
|
|
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(461029090u, clientRpcParams, RpcDelivery.Reliable);
|
|
__endSendClientRpc(ref bufferWriter, 461029090u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
RoundManager.PlayRandomClip(creatureSFX, hitWallSFX);
|
|
float num = Vector3.Distance(GameNetworkManager.Instance.localPlayerController.transform.position, base.transform.position);
|
|
if (num < 15f)
|
|
{
|
|
HUDManager.Instance.ShakeCamera(ScreenShakeType.Big);
|
|
}
|
|
else if (num < 24f)
|
|
{
|
|
HUDManager.Instance.ShakeCamera(ScreenShakeType.Small);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CheckForVeryClosePlayer()
|
|
{
|
|
if (Physics.OverlapSphereNonAlloc(base.transform.position, 1.5f, nearPlayerColliders, 8, QueryTriggerInteraction.Ignore) > 0)
|
|
{
|
|
PlayerControllerB component = nearPlayerColliders[0].transform.GetComponent<PlayerControllerB>();
|
|
if (component != null && component != targetPlayer && !Physics.Linecast(base.transform.position + Vector3.up * 0.3f, component.transform.position, StartOfRound.Instance.collidersAndRoomMask))
|
|
{
|
|
targetPlayer = component;
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void BeginChasingPlayerServerRpc(int playerObjectId)
|
|
{
|
|
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(869452445u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObjectId);
|
|
__endSendServerRpc(ref bufferWriter, 869452445u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
BeginChasingPlayerClientRpc(playerObjectId);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void BeginChasingPlayerClientRpc(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(1964892800u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObjectId);
|
|
__endSendClientRpc(ref bufferWriter, 1964892800u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
MakeScreech();
|
|
SwitchToBehaviourStateOnLocalClient(1);
|
|
SetMovingTowardsTargetPlayer(StartOfRound.Instance.allPlayerScripts[playerObjectId]);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void MakeScreechNoiseServerRpc()
|
|
{
|
|
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(2716706397u, serverRpcParams, RpcDelivery.Reliable);
|
|
__endSendServerRpc(ref bufferWriter, 2716706397u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
MakeScreechNoiseClientRpc();
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void MakeScreechNoiseClientRpc()
|
|
{
|
|
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(3572529702u, clientRpcParams, RpcDelivery.Reliable);
|
|
__endSendClientRpc(ref bufferWriter, 3572529702u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
MakeScreech();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MakeScreech()
|
|
{
|
|
int num = Random.Range(0, longRoarSFX.Length);
|
|
creatureVoice.PlayOneShot(longRoarSFX[num]);
|
|
WalkieTalkie.TransmitOneShotAudio(creatureVoice, longRoarSFX[num]);
|
|
if (Vector3.Distance(GameNetworkManager.Instance.localPlayerController.transform.position, base.transform.position) < 15f)
|
|
{
|
|
GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(0.75f);
|
|
}
|
|
}
|
|
|
|
public override void OnCollideWithPlayer(Collider other)
|
|
{
|
|
base.OnCollideWithPlayer(other);
|
|
if (!(timeSinceHittingPlayer < 0.65f))
|
|
{
|
|
PlayerControllerB playerControllerB = MeetsStandardPlayerCollisionConditions(other);
|
|
if (playerControllerB != null)
|
|
{
|
|
timeSinceHittingPlayer = 0f;
|
|
playerControllerB.DamagePlayer(40, hasDamageSFX: true, callRPC: true, CauseOfDeath.Mauling);
|
|
agent.speed = 0f;
|
|
HitPlayerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
|
|
GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(1f);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void HitPlayerServerRpc(int playerId)
|
|
{
|
|
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(3352518565u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendServerRpc(ref bufferWriter, 3352518565u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
HitPlayerClientRpc(playerId);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void HitPlayerClientRpc(int playerId)
|
|
{
|
|
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(880045462u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendClientRpc(ref bufferWriter, 880045462u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
if (!inSpecialAnimation)
|
|
{
|
|
creatureAnimator.SetTrigger("HitPlayer");
|
|
}
|
|
creatureVoice.PlayOneShot(bitePlayerSFX);
|
|
agentSpeedWithNegative = Random.Range(0.25f, 4f);
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void EatPlayerBodyServerRpc(int playerId)
|
|
{
|
|
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(3781293737u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendServerRpc(ref bufferWriter, 3781293737u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
EatPlayerBodyClientRpc(playerId);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void EatPlayerBodyClientRpc(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(2460625110u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendClientRpc(ref bufferWriter, 2460625110u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsOwner && eatPlayerBodyCoroutine == null)
|
|
{
|
|
StartCoroutine(EatPlayerBodyAnimation(playerId));
|
|
}
|
|
}
|
|
}
|
|
|
|
private IEnumerator EatPlayerBodyAnimation(int playerId)
|
|
{
|
|
PlayerControllerB playerScript = StartOfRound.Instance.allPlayerScripts[playerId];
|
|
float startTime = Time.realtimeSinceStartup;
|
|
yield return new WaitUntil(() => (playerScript.deadBody != null && playerScript.deadBody.grabBodyObject != null) || Time.realtimeSinceStartup - startTime > 2f);
|
|
DeadBodyInfo deadBody = null;
|
|
if (StartOfRound.Instance.allPlayerScripts[playerId].deadBody != null)
|
|
{
|
|
deadBody = StartOfRound.Instance.allPlayerScripts[playerId].deadBody;
|
|
}
|
|
yield return null;
|
|
if (deadBody != null && deadBody.grabBodyObject != null && !deadBody.isInShip && !deadBody.grabBodyObject.isHeld && !isEnemyDead && Vector3.Distance(base.transform.position, deadBody.bodyParts[0].transform.position) < 6.7f)
|
|
{
|
|
creatureAnimator.SetTrigger("EatPlayer");
|
|
creatureVoice.pitch = Random.Range(0.85f, 1.1f);
|
|
creatureVoice.PlayOneShot(eatPlayerSFX);
|
|
deadBody.canBeGrabbedBackByPlayers = false;
|
|
currentlyHeldBody = deadBody;
|
|
pullingSecondLimb = deadBody.attachedTo != null;
|
|
if (pullingSecondLimb)
|
|
{
|
|
deadBody.secondaryAttachedLimb = deadBody.bodyParts[3];
|
|
deadBody.secondaryAttachedTo = mouthTarget;
|
|
}
|
|
else
|
|
{
|
|
deadBody.attachedLimb = deadBody.bodyParts[0];
|
|
deadBody.attachedTo = mouthTarget;
|
|
}
|
|
yield return new WaitForSeconds(2.75f);
|
|
}
|
|
Debug.Log("Crawler: leaving special animation");
|
|
inSpecialAnimation = false;
|
|
DropPlayerBody();
|
|
eatPlayerBodyCoroutine = null;
|
|
}
|
|
|
|
private void DropPlayerBody()
|
|
{
|
|
if (currentlyHeldBody != null)
|
|
{
|
|
if (pullingSecondLimb)
|
|
{
|
|
currentlyHeldBody.secondaryAttachedLimb = null;
|
|
currentlyHeldBody.secondaryAttachedTo = null;
|
|
}
|
|
else
|
|
{
|
|
currentlyHeldBody.attachedLimb = null;
|
|
currentlyHeldBody.attachedTo = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void KillEnemy(bool destroy = false)
|
|
{
|
|
base.KillEnemy();
|
|
if (eatPlayerBodyCoroutine != null)
|
|
{
|
|
StopCoroutine(eatPlayerBodyCoroutine);
|
|
}
|
|
DropPlayerBody();
|
|
}
|
|
|
|
public override void HitEnemy(int force = 1, PlayerControllerB playerWhoHit = null, bool playHitSFX = false)
|
|
{
|
|
base.HitEnemy(force, playerWhoHit);
|
|
if (!isEnemyDead)
|
|
{
|
|
agent.speed = 2f;
|
|
agentSpeedWithNegative = Random.Range(-0.25f, 3f);
|
|
if (!inSpecialAnimation)
|
|
{
|
|
creatureAnimator.SetTrigger("HurtEnemy");
|
|
}
|
|
enemyHP -= force;
|
|
RoundManager.PlayRandomClip(creatureVoice, hitCrawlerSFX);
|
|
if (enemyHP <= 0 && base.IsOwner)
|
|
{
|
|
KillEnemyOnOwnerClient();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void __initializeVariables()
|
|
{
|
|
base.__initializeVariables();
|
|
}
|
|
|
|
[RuntimeInitializeOnLoadMethod]
|
|
internal static void InitializeRPCS_CrawlerAI()
|
|
{
|
|
NetworkManager.__rpc_func_table.Add(3661877694u, __rpc_handler_3661877694);
|
|
NetworkManager.__rpc_func_table.Add(461029090u, __rpc_handler_461029090);
|
|
NetworkManager.__rpc_func_table.Add(869452445u, __rpc_handler_869452445);
|
|
NetworkManager.__rpc_func_table.Add(1964892800u, __rpc_handler_1964892800);
|
|
NetworkManager.__rpc_func_table.Add(2716706397u, __rpc_handler_2716706397);
|
|
NetworkManager.__rpc_func_table.Add(3572529702u, __rpc_handler_3572529702);
|
|
NetworkManager.__rpc_func_table.Add(3352518565u, __rpc_handler_3352518565);
|
|
NetworkManager.__rpc_func_table.Add(880045462u, __rpc_handler_880045462);
|
|
NetworkManager.__rpc_func_table.Add(3781293737u, __rpc_handler_3781293737);
|
|
NetworkManager.__rpc_func_table.Add(2460625110u, __rpc_handler_2460625110);
|
|
}
|
|
|
|
private static void __rpc_handler_3661877694(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((CrawlerAI)target).CollideWithWallServerRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_461029090(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((CrawlerAI)target).CollideWithWallClientRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_869452445(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;
|
|
((CrawlerAI)target).BeginChasingPlayerServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1964892800(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;
|
|
((CrawlerAI)target).BeginChasingPlayerClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2716706397(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((CrawlerAI)target).MakeScreechNoiseServerRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3572529702(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((CrawlerAI)target).MakeScreechNoiseClientRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3352518565(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;
|
|
((CrawlerAI)target).HitPlayerServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_880045462(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;
|
|
((CrawlerAI)target).HitPlayerClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3781293737(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;
|
|
((CrawlerAI)target).EatPlayerBodyServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2460625110(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;
|
|
((CrawlerAI)target).EatPlayerBodyClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
protected internal override string __getTypeName()
|
|
{
|
|
return "CrawlerAI";
|
|
}
|
|
}
|