744 lines
22 KiB
C#
744 lines
22 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using GameNetcodeStuff;
|
|
using Unity.Netcode;
|
|
using UnityEngine;
|
|
using UnityEngine.Animations.Rigging;
|
|
|
|
public class MouthDogAI : EnemyAI, INoiseListener
|
|
{
|
|
public float noiseApproximation = 14f;
|
|
|
|
public int suspicionLevel;
|
|
|
|
private Vector3 previousPosition;
|
|
|
|
public DampedTransform neckDampedTransform;
|
|
|
|
private RoundManager roundManager;
|
|
|
|
private float AITimer;
|
|
|
|
private List<GameObject> allAINodesWithinRange = new List<GameObject>();
|
|
|
|
private bool hasEnteredChaseModeFully;
|
|
|
|
private bool startedChaseModeCoroutine;
|
|
|
|
public AudioClip screamSFX;
|
|
|
|
public AudioClip breathingSFX;
|
|
|
|
public AudioClip killPlayerSFX;
|
|
|
|
private float hearNoiseCooldown;
|
|
|
|
private bool inLunge;
|
|
|
|
private float lungeCooldown;
|
|
|
|
private bool inKillAnimation;
|
|
|
|
public Transform mouthGrip;
|
|
|
|
public bool endingLunge;
|
|
|
|
private Ray ray;
|
|
|
|
private RaycastHit rayHit;
|
|
|
|
private Vector3 lastHeardNoisePosition;
|
|
|
|
private Vector3 noisePositionGuess;
|
|
|
|
private float lastHeardNoiseDistanceWhenHeard;
|
|
|
|
private bool heardOtherHowl;
|
|
|
|
private DeadBodyInfo carryingBody;
|
|
|
|
private System.Random enemyRandom;
|
|
|
|
private Coroutine killPlayerCoroutine;
|
|
|
|
private const int suspicionThreshold = 5;
|
|
|
|
private const int alertThreshold = 9;
|
|
|
|
private const int maxSuspicionLevel = 11;
|
|
|
|
public AISearchRoutine roamPlanet;
|
|
|
|
private Collider debugCollider;
|
|
|
|
public override void DoAIInterval()
|
|
{
|
|
base.DoAIInterval();
|
|
_ = StartOfRound.Instance.livingPlayers;
|
|
}
|
|
|
|
public override void Start()
|
|
{
|
|
base.Start();
|
|
roundManager = UnityEngine.Object.FindObjectOfType<RoundManager>();
|
|
useSecondaryAudiosOnAnimatedObjects = true;
|
|
if (UnityEngine.Random.Range(0, 10) < 2)
|
|
{
|
|
creatureVoice.pitch = UnityEngine.Random.Range(0.6f, 1.3f);
|
|
}
|
|
else
|
|
{
|
|
creatureVoice.pitch = UnityEngine.Random.Range(0.9f, 1.1f);
|
|
}
|
|
enemyRandom = new System.Random(StartOfRound.Instance.randomMapSeed + thisEnemyIndex);
|
|
}
|
|
|
|
public override void Update()
|
|
{
|
|
base.Update();
|
|
if (isEnemyDead || !ventAnimationFinished)
|
|
{
|
|
return;
|
|
}
|
|
if (stunNormalizedTimer > 0f)
|
|
{
|
|
if (stunnedByPlayer != null && currentBehaviourStateIndex != 2 && base.IsOwner)
|
|
{
|
|
EnrageDogOnLocalClient(stunnedByPlayer.transform.position, Vector3.Distance(base.transform.position, stunnedByPlayer.transform.position));
|
|
}
|
|
creatureAnimator.SetLayerWeight(1, 1f);
|
|
}
|
|
else
|
|
{
|
|
creatureAnimator.SetLayerWeight(1, 0f);
|
|
}
|
|
hearNoiseCooldown -= Time.deltaTime;
|
|
creatureAnimator.SetFloat("speedMultiplier", Vector3.ClampMagnitude(base.transform.position - previousPosition, 1f).sqrMagnitude / (Time.deltaTime / 4f));
|
|
previousPosition = base.transform.position;
|
|
if (currentBehaviourStateIndex == 2 || currentBehaviourStateIndex == 3)
|
|
{
|
|
if (GameNetworkManager.Instance.localPlayerController.HasLineOfSightToPosition(base.transform.position, 50f, 25, 10f))
|
|
{
|
|
GameNetworkManager.Instance.localPlayerController.IncreaseFearLevelOverTime(0.4f, 0.5f);
|
|
}
|
|
}
|
|
else if (GameNetworkManager.Instance.localPlayerController.HasLineOfSightToPosition(base.transform.position, 50f, 30, 5f))
|
|
{
|
|
GameNetworkManager.Instance.localPlayerController.IncreaseFearLevelOverTime(0.25f, 0.3f);
|
|
}
|
|
switch (currentBehaviourStateIndex)
|
|
{
|
|
case 0:
|
|
neckDampedTransform.weight = 1f;
|
|
if (base.IsOwner)
|
|
{
|
|
agent.speed = 3.5f;
|
|
if (stunNormalizedTimer > 0f)
|
|
{
|
|
agent.speed = 0f;
|
|
}
|
|
if (base.IsOwner && !roamPlanet.inProgress)
|
|
{
|
|
StartSearch(base.transform.position, roamPlanet);
|
|
}
|
|
}
|
|
break;
|
|
case 1:
|
|
if (hasEnteredChaseModeFully)
|
|
{
|
|
hasEnteredChaseModeFully = false;
|
|
creatureVoice.Stop();
|
|
startedChaseModeCoroutine = false;
|
|
creatureAnimator.SetBool("StartedChase", value: false);
|
|
}
|
|
neckDampedTransform.weight = Mathf.Lerp(neckDampedTransform.weight, 1f, 8f * Time.deltaTime);
|
|
if (!base.IsOwner)
|
|
{
|
|
break;
|
|
}
|
|
if (base.IsOwner && roamPlanet.inProgress)
|
|
{
|
|
StopSearch(roamPlanet);
|
|
}
|
|
agent.speed = 4.5f;
|
|
if (stunNormalizedTimer > 0f)
|
|
{
|
|
agent.speed = 0f;
|
|
}
|
|
AITimer -= Time.deltaTime;
|
|
if (AITimer <= 0f)
|
|
{
|
|
AITimer = 4f;
|
|
suspicionLevel--;
|
|
if (suspicionLevel <= 1)
|
|
{
|
|
SwitchToBehaviourState(0);
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
if (!hasEnteredChaseModeFully)
|
|
{
|
|
if (!startedChaseModeCoroutine)
|
|
{
|
|
startedChaseModeCoroutine = true;
|
|
StartCoroutine(enterChaseMode());
|
|
}
|
|
break;
|
|
}
|
|
neckDampedTransform.weight = Mathf.Lerp(neckDampedTransform.weight, 0.2f, 8f * Time.deltaTime);
|
|
if (!base.IsOwner)
|
|
{
|
|
break;
|
|
}
|
|
if (base.IsOwner && roamPlanet.inProgress)
|
|
{
|
|
StopSearch(roamPlanet);
|
|
}
|
|
if (!inLunge)
|
|
{
|
|
lungeCooldown -= Time.deltaTime;
|
|
if (Vector3.Distance(base.transform.position, noisePositionGuess) < 4f && lungeCooldown <= 0f)
|
|
{
|
|
inLunge = true;
|
|
EnterLunge();
|
|
break;
|
|
}
|
|
}
|
|
agent.speed = Mathf.Clamp(agent.speed + Time.deltaTime, 13f, 18f);
|
|
if (stunNormalizedTimer > 0f)
|
|
{
|
|
agent.speed = 0f;
|
|
}
|
|
AITimer -= Time.deltaTime;
|
|
if (AITimer <= 0f)
|
|
{
|
|
AITimer = 3f;
|
|
suspicionLevel--;
|
|
if (Vector3.Distance(base.transform.position, agent.destination) < 3f)
|
|
{
|
|
SearchForPreviouslyHeardSound();
|
|
}
|
|
if (suspicionLevel <= 8)
|
|
{
|
|
SwitchToBehaviourState(1);
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
if (base.IsOwner)
|
|
{
|
|
agent.speed -= Time.deltaTime * 5f;
|
|
if (!endingLunge && agent.speed < 1.5f && !inKillAnimation)
|
|
{
|
|
endingLunge = true;
|
|
lungeCooldown = 0.25f;
|
|
EndLungeServerRpc();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void SearchForPreviouslyHeardSound()
|
|
{
|
|
int num = 0;
|
|
Vector3 vector = base.transform.position;
|
|
while (num < 5 && Vector3.Distance(vector, base.transform.position) < 4f)
|
|
{
|
|
num++;
|
|
vector = roundManager.GetRandomNavMeshPositionInRadius(lastHeardNoisePosition, lastHeardNoiseDistanceWhenHeard / noiseApproximation);
|
|
}
|
|
SetDestinationToPosition(vector);
|
|
noisePositionGuess = vector;
|
|
}
|
|
|
|
private IEnumerator enterChaseMode()
|
|
{
|
|
if (base.IsOwner)
|
|
{
|
|
agent.speed = 0.05f;
|
|
}
|
|
DropCarriedBody();
|
|
creatureVoice.PlayOneShot(screamSFX);
|
|
creatureAnimator.SetTrigger("ChaseHowl");
|
|
if (Vector3.Distance(base.transform.position, GameNetworkManager.Instance.localPlayerController.transform.position) < 16f)
|
|
{
|
|
HUDManager.Instance.ShakeCamera(ScreenShakeType.Long);
|
|
GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(0.5f);
|
|
}
|
|
yield return new WaitForSeconds(0.5f);
|
|
if (!heardOtherHowl)
|
|
{
|
|
CallAllDogsWithHowl();
|
|
}
|
|
heardOtherHowl = false;
|
|
yield return new WaitForSeconds(0.2f);
|
|
creatureVoice.clip = breathingSFX;
|
|
creatureVoice.Play();
|
|
creatureAnimator.SetBool("StartedChase", value: true);
|
|
hasEnteredChaseModeFully = true;
|
|
creatureVoice.PlayOneShot(breathingSFX);
|
|
}
|
|
|
|
private void CallAllDogsWithHowl()
|
|
{
|
|
MouthDogAI[] array = UnityEngine.Object.FindObjectsOfType<MouthDogAI>();
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
if (!(array[i] == this))
|
|
{
|
|
array[i].ReactToOtherDogHowl(base.transform.position);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ReactToOtherDogHowl(Vector3 howlPosition)
|
|
{
|
|
heardOtherHowl = true;
|
|
lastHeardNoiseDistanceWhenHeard = Vector3.Distance(base.transform.position, howlPosition);
|
|
noisePositionGuess = roundManager.GetRandomNavMeshPositionInRadius(howlPosition, lastHeardNoiseDistanceWhenHeard / noiseApproximation);
|
|
SetDestinationToPosition(noisePositionGuess);
|
|
if (currentBehaviourStateIndex < 2)
|
|
{
|
|
SwitchToBehaviourStateOnLocalClient(2);
|
|
}
|
|
suspicionLevel = 8;
|
|
lastHeardNoisePosition = howlPosition;
|
|
Debug.Log($"Setting lastHeardNoisePosition to {howlPosition}");
|
|
}
|
|
|
|
public override void DetectNoise(Vector3 noisePosition, float noiseLoudness, int timesNoisePlayedInOneSpot = 0, int noiseID = 0)
|
|
{
|
|
base.DetectNoise(noisePosition, noiseLoudness, timesNoisePlayedInOneSpot, noiseID);
|
|
if (stunNormalizedTimer > 0f || noiseID == 7 || noiseID == 546 || inKillAnimation || hearNoiseCooldown >= 0f || timesNoisePlayedInOneSpot > 15)
|
|
{
|
|
return;
|
|
}
|
|
hearNoiseCooldown = 0.03f;
|
|
float num = Vector3.Distance(base.transform.position, noisePosition);
|
|
Debug.Log($"dog '{base.gameObject.name}': Heard noise! Distance: {num} meters");
|
|
float num2 = 18f * noiseLoudness;
|
|
if (Physics.Linecast(base.transform.position, noisePosition, 256))
|
|
{
|
|
noiseLoudness /= 2f;
|
|
num2 /= 2f;
|
|
}
|
|
if (noiseLoudness < 0.25f)
|
|
{
|
|
return;
|
|
}
|
|
if (currentBehaviourStateIndex < 2 && num < num2)
|
|
{
|
|
suspicionLevel = 9;
|
|
}
|
|
else
|
|
{
|
|
suspicionLevel++;
|
|
}
|
|
bool fullyEnrage = false;
|
|
if (suspicionLevel >= 9)
|
|
{
|
|
if (currentBehaviourStateIndex < 2)
|
|
{
|
|
fullyEnrage = true;
|
|
}
|
|
}
|
|
else if (suspicionLevel >= 5 && currentBehaviourStateIndex == 0)
|
|
{
|
|
fullyEnrage = false;
|
|
}
|
|
AITimer = 3f;
|
|
EnrageDogOnLocalClient(noisePosition, num, approximatePosition: true, fullyEnrage);
|
|
}
|
|
|
|
private void EnrageDogOnLocalClient(Vector3 targetPosition, float distanceToNoise, bool approximatePosition = true, bool fullyEnrage = false)
|
|
{
|
|
Debug.Log($"Mouth dog targetPos 1: {targetPosition}; distanceToNoise: {distanceToNoise}");
|
|
if (approximatePosition)
|
|
{
|
|
targetPosition = roundManager.GetRandomNavMeshPositionInRadius(targetPosition, distanceToNoise / noiseApproximation);
|
|
}
|
|
noisePositionGuess = targetPosition;
|
|
Debug.Log($"Mouth dog targetPos 2: {targetPosition}");
|
|
if (fullyEnrage)
|
|
{
|
|
if (currentBehaviourStateIndex < 2)
|
|
{
|
|
SwitchToBehaviourState(2);
|
|
suspicionLevel = 12;
|
|
}
|
|
suspicionLevel = Mathf.Clamp(suspicionLevel, 0, 11);
|
|
}
|
|
else if (currentBehaviourStateIndex == 0)
|
|
{
|
|
SwitchToBehaviourState(1);
|
|
}
|
|
if (!base.IsOwner)
|
|
{
|
|
ChangeOwnershipOfEnemy(NetworkManager.Singleton.LocalClientId);
|
|
}
|
|
if (!inLunge)
|
|
{
|
|
SetDestinationToPosition(noisePositionGuess);
|
|
}
|
|
lastHeardNoiseDistanceWhenHeard = distanceToNoise;
|
|
lastHeardNoisePosition = targetPosition;
|
|
Debug.Log($"Dog lastheardnoisePosition: {lastHeardNoisePosition}");
|
|
}
|
|
|
|
private void EnterLunge()
|
|
{
|
|
if (!base.IsOwner)
|
|
{
|
|
ChangeOwnershipOfEnemy(NetworkManager.Singleton.LocalClientId);
|
|
}
|
|
SwitchToBehaviourState(3);
|
|
endingLunge = false;
|
|
ray = new Ray(base.transform.position + Vector3.up, base.transform.forward);
|
|
Vector3 pos = ((!Physics.Raycast(ray, out rayHit, 17f, StartOfRound.Instance.collidersAndRoomMask)) ? ray.GetPoint(17f) : rayHit.point);
|
|
pos = roundManager.GetNavMeshPosition(pos);
|
|
SetDestinationToPosition(pos);
|
|
agent.speed = 13f;
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void EndLungeServerRpc()
|
|
{
|
|
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(43708451u, serverRpcParams, RpcDelivery.Reliable);
|
|
__endSendServerRpc(ref bufferWriter, 43708451u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
EndLungeClientRpc();
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void EndLungeClientRpc()
|
|
{
|
|
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(4130373844u, clientRpcParams, RpcDelivery.Reliable);
|
|
__endSendClientRpc(ref bufferWriter, 4130373844u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
SwitchToBehaviourStateOnLocalClient(2);
|
|
creatureAnimator.SetTrigger("EndLungeNoKill");
|
|
inLunge = false;
|
|
Debug.Log("Ending lunge");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ChaseLocalPlayer()
|
|
{
|
|
SwitchToBehaviourState(2);
|
|
ChangeOwnershipOfEnemy(NetworkManager.Singleton.LocalClientId);
|
|
SetDestinationToPosition(GameNetworkManager.Instance.localPlayerController.transform.position);
|
|
}
|
|
|
|
public override void OnCollideWithPlayer(Collider other)
|
|
{
|
|
base.OnCollideWithPlayer(other);
|
|
PlayerControllerB playerControllerB = MeetsStandardPlayerCollisionConditions(other, inKillAnimation);
|
|
if (!(playerControllerB != null))
|
|
{
|
|
return;
|
|
}
|
|
if (Physics.Linecast(base.transform.position + Vector3.up, playerControllerB.gameplayCamera.transform.position, out var hitInfo, StartOfRound.Instance.collidersAndRoomMask, QueryTriggerInteraction.Ignore))
|
|
{
|
|
if (!(hitInfo.collider == debugCollider))
|
|
{
|
|
Debug.Log("Eyeless dog collide, linecast obstructed: " + hitInfo.collider.gameObject.name);
|
|
debugCollider = hitInfo.collider;
|
|
}
|
|
}
|
|
else if (currentBehaviourStateIndex == 3)
|
|
{
|
|
playerControllerB.inAnimationWithEnemy = this;
|
|
KillPlayerServerRpc((int)playerControllerB.playerClientId);
|
|
}
|
|
else if (currentBehaviourStateIndex == 0 || currentBehaviourStateIndex == 1)
|
|
{
|
|
ChaseLocalPlayer();
|
|
}
|
|
else if (currentBehaviourStateIndex == 2 && !inLunge)
|
|
{
|
|
base.transform.LookAt(other.transform.position);
|
|
base.transform.localEulerAngles = new Vector3(0f, base.transform.eulerAngles.y, 0f);
|
|
inLunge = true;
|
|
EnterLunge();
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void KillPlayerServerRpc(int playerId)
|
|
{
|
|
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(998670557u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendServerRpc(ref bufferWriter, 998670557u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
if (!inKillAnimation)
|
|
{
|
|
inKillAnimation = true;
|
|
KillPlayerClientRpc(playerId);
|
|
}
|
|
else
|
|
{
|
|
CancelKillAnimationWithPlayerClientRpc(playerId);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void CancelKillAnimationWithPlayerClientRpc(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(2798326268u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObjectId);
|
|
__endSendClientRpc(ref bufferWriter, 2798326268u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
StartOfRound.Instance.allPlayerScripts[playerObjectId].inAnimationWithEnemy = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void KillPlayerClientRpc(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(2252497379u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendClientRpc(ref bufferWriter, 2252497379u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
Debug.Log("Kill player rpc");
|
|
if (killPlayerCoroutine != null)
|
|
{
|
|
StopCoroutine(killPlayerCoroutine);
|
|
}
|
|
killPlayerCoroutine = StartCoroutine(KillPlayer(playerId));
|
|
}
|
|
}
|
|
|
|
private IEnumerator KillPlayer(int playerId)
|
|
{
|
|
if (base.IsOwner)
|
|
{
|
|
agent.speed = Mathf.Clamp(agent.speed, 2f, 0f);
|
|
}
|
|
Debug.Log("killing player A");
|
|
creatureVoice.pitch = UnityEngine.Random.Range(0.96f, 1.04f);
|
|
creatureVoice.PlayOneShot(killPlayerSFX, 1f);
|
|
PlayerControllerB killPlayer = StartOfRound.Instance.allPlayerScripts[playerId];
|
|
inKillAnimation = true;
|
|
creatureAnimator.SetTrigger("EndLungeKill");
|
|
Debug.Log("killing player B");
|
|
if (GameNetworkManager.Instance.localPlayerController == killPlayer)
|
|
{
|
|
killPlayer.KillPlayer(Vector3.zero, spawnBody: true, CauseOfDeath.Mauling);
|
|
}
|
|
float startTime = Time.timeSinceLevelLoad;
|
|
yield return new WaitUntil(() => killPlayer.deadBody != null || Time.timeSinceLevelLoad - startTime > 2f);
|
|
if (killPlayer.deadBody == null)
|
|
{
|
|
Debug.Log("Giant dog: Player body was not spawned or found within 2 seconds.");
|
|
killPlayer.inAnimationWithEnemy = null;
|
|
inKillAnimation = false;
|
|
yield break;
|
|
}
|
|
TakeBodyInMouth(killPlayer.deadBody);
|
|
startTime = Time.timeSinceLevelLoad;
|
|
Quaternion rotateTo = Quaternion.Euler(new Vector3(0f, RoundManager.Instance.YRotationThatFacesTheFarthestFromPosition(base.transform.position + Vector3.up * 0.6f), 0f));
|
|
Quaternion rotateFrom = base.transform.rotation;
|
|
while (Time.timeSinceLevelLoad - startTime < 2f)
|
|
{
|
|
yield return null;
|
|
if (base.IsOwner)
|
|
{
|
|
base.transform.rotation = Quaternion.RotateTowards(rotateFrom, rotateTo, 60f * Time.deltaTime);
|
|
}
|
|
}
|
|
yield return new WaitForSeconds(3.01f);
|
|
DropCarriedBody();
|
|
suspicionLevel = 2;
|
|
SwitchToBehaviourStateOnLocalClient(2);
|
|
endingLunge = true;
|
|
inKillAnimation = false;
|
|
}
|
|
|
|
private void StopKillAnimation()
|
|
{
|
|
if (killPlayerCoroutine != null)
|
|
{
|
|
StopCoroutine(killPlayerCoroutine);
|
|
}
|
|
inKillAnimation = false;
|
|
creatureVoice.Stop();
|
|
DropCarriedBody();
|
|
}
|
|
|
|
private void TakeBodyInMouth(DeadBodyInfo body)
|
|
{
|
|
carryingBody = body;
|
|
carryingBody.attachedTo = mouthGrip;
|
|
carryingBody.attachedLimb = body.bodyParts[5];
|
|
carryingBody.matchPositionExactly = true;
|
|
}
|
|
|
|
private void DropCarriedBody()
|
|
{
|
|
if (!(carryingBody == null))
|
|
{
|
|
carryingBody.speedMultiplier = 12f;
|
|
carryingBody.attachedTo = null;
|
|
carryingBody.attachedLimb = null;
|
|
carryingBody.matchPositionExactly = false;
|
|
carryingBody = null;
|
|
}
|
|
}
|
|
|
|
public override void KillEnemy(bool destroy = false)
|
|
{
|
|
StopKillAnimation();
|
|
base.KillEnemy(destroy);
|
|
}
|
|
|
|
public override void EnableEnemyMesh(bool enable, bool overrideDoNotSet = false)
|
|
{
|
|
base.EnableEnemyMesh(enable);
|
|
ParticleSystem[] componentsInChildren = base.gameObject.GetComponentsInChildren<ParticleSystem>();
|
|
for (int i = 0; i < componentsInChildren.Length; i++)
|
|
{
|
|
ParticleSystem.MainModule main = componentsInChildren[i].main;
|
|
main.playOnAwake = base.enabled;
|
|
}
|
|
}
|
|
|
|
public override void OnDrawGizmos()
|
|
{
|
|
base.OnDrawGizmos();
|
|
if (debugEnemyAI)
|
|
{
|
|
Gizmos.DrawCube(noisePositionGuess, Vector3.one);
|
|
Gizmos.DrawLine(noisePositionGuess, base.transform.position + Vector3.up);
|
|
}
|
|
}
|
|
|
|
protected override void __initializeVariables()
|
|
{
|
|
base.__initializeVariables();
|
|
}
|
|
|
|
[RuntimeInitializeOnLoadMethod]
|
|
internal static void InitializeRPCS_MouthDogAI()
|
|
{
|
|
NetworkManager.__rpc_func_table.Add(43708451u, __rpc_handler_43708451);
|
|
NetworkManager.__rpc_func_table.Add(4130373844u, __rpc_handler_4130373844);
|
|
NetworkManager.__rpc_func_table.Add(998670557u, __rpc_handler_998670557);
|
|
NetworkManager.__rpc_func_table.Add(2798326268u, __rpc_handler_2798326268);
|
|
NetworkManager.__rpc_func_table.Add(2252497379u, __rpc_handler_2252497379);
|
|
}
|
|
|
|
private static void __rpc_handler_43708451(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((MouthDogAI)target).EndLungeServerRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_4130373844(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((MouthDogAI)target).EndLungeClientRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_998670557(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;
|
|
((MouthDogAI)target).KillPlayerServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2798326268(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;
|
|
((MouthDogAI)target).CancelKillAnimationWithPlayerClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2252497379(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;
|
|
((MouthDogAI)target).KillPlayerClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
protected internal override string __getTypeName()
|
|
{
|
|
return "MouthDogAI";
|
|
}
|
|
}
|