1033 lines
32 KiB
C#
1033 lines
32 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using GameNetcodeStuff;
|
|
using Unity.Netcode;
|
|
using UnityEngine;
|
|
|
|
public class FlowermanAI : EnemyAI
|
|
{
|
|
private bool evadeModeStareDown;
|
|
|
|
private bool stopTurningTowardsPlayers;
|
|
|
|
public float evadeStealthTimer;
|
|
|
|
private int stareDownChanceIncrease;
|
|
|
|
public PlayerControllerB lookAtPlayer;
|
|
|
|
private Transform localPlayerCamera;
|
|
|
|
private RaycastHit rayHit;
|
|
|
|
private Ray playerRay;
|
|
|
|
public Transform turnCompass;
|
|
|
|
private int roomAndEnemiesMask = 8915200;
|
|
|
|
private Vector3 agentLocalVelocity;
|
|
|
|
public Collider thisEnemyCollider;
|
|
|
|
private Vector3 previousPosition;
|
|
|
|
private float velX;
|
|
|
|
private float velZ;
|
|
|
|
[Header("Kill animation")]
|
|
public bool inKillAnimation;
|
|
|
|
private Coroutine killAnimationCoroutine;
|
|
|
|
public bool carryingPlayerBody;
|
|
|
|
public DeadBodyInfo bodyBeingCarried;
|
|
|
|
public Transform rightHandGrip;
|
|
|
|
public Transform animationContainer;
|
|
|
|
private bool wasInEvadeMode;
|
|
|
|
public List<Transform> ignoredNodes = new List<Transform>();
|
|
|
|
private Vector3 mainEntrancePosition;
|
|
|
|
[Header("Anger phase")]
|
|
public float angerMeter;
|
|
|
|
public float angerCheckInterval;
|
|
|
|
public bool isInAngerMode;
|
|
|
|
public AudioSource creatureAngerVoice;
|
|
|
|
public AudioSource crackNeckAudio;
|
|
|
|
public AudioClip crackNeckSFX;
|
|
|
|
public int timesThreatened;
|
|
|
|
private Vector3 waitAroundEntrancePosition;
|
|
|
|
private int timesFoundSneaking;
|
|
|
|
private bool stunnedByPlayerLastFrame;
|
|
|
|
public override void Start()
|
|
{
|
|
base.Start();
|
|
movingTowardsTargetPlayer = true;
|
|
localPlayerCamera = GameNetworkManager.Instance.localPlayerController.gameplayCamera.transform;
|
|
mainEntrancePosition = RoundManager.FindMainEntrancePosition();
|
|
}
|
|
|
|
public override void DoAIInterval()
|
|
{
|
|
if (StartOfRound.Instance.livingPlayers == 0)
|
|
{
|
|
base.DoAIInterval();
|
|
return;
|
|
}
|
|
if (TargetClosestPlayer())
|
|
{
|
|
if (currentBehaviourStateIndex == 2)
|
|
{
|
|
SetMovingTowardsTargetPlayer(targetPlayer);
|
|
if (!inKillAnimation && targetPlayer != GameNetworkManager.Instance.localPlayerController)
|
|
{
|
|
ChangeOwnershipOfEnemy(targetPlayer.actualClientId);
|
|
}
|
|
base.DoAIInterval();
|
|
return;
|
|
}
|
|
if (currentBehaviourStateIndex == 1)
|
|
{
|
|
if (favoriteSpot != null && carryingPlayerBody)
|
|
{
|
|
if (mostOptimalDistance < 5f || PathIsIntersectedByLineOfSight(favoriteSpot.position))
|
|
{
|
|
AvoidClosestPlayer();
|
|
}
|
|
else
|
|
{
|
|
targetNode = favoriteSpot;
|
|
SetDestinationToPosition(favoriteSpot.position, checkForPath: true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AvoidClosestPlayer();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ChooseClosestNodeToPlayer();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (currentBehaviourStateIndex == 2)
|
|
{
|
|
SetDestinationToPosition(waitAroundEntrancePosition);
|
|
return;
|
|
}
|
|
Transform transform = ChooseFarthestNodeFromPosition(mainEntrancePosition);
|
|
if (favoriteSpot == null)
|
|
{
|
|
favoriteSpot = transform;
|
|
}
|
|
targetNode = transform;
|
|
SetDestinationToPosition(transform.position, checkForPath: true);
|
|
}
|
|
base.DoAIInterval();
|
|
}
|
|
|
|
public void AvoidClosestPlayer()
|
|
{
|
|
Transform transform = ChooseFarthestNodeFromPosition(targetPlayer.transform.position, avoidLineOfSight: true, 0, log: true);
|
|
if (transform != null && mostOptimalDistance > 5f && Physics.Linecast(transform.transform.position, targetPlayer.gameplayCamera.transform.position, StartOfRound.Instance.collidersAndRoomMaskAndDefault, QueryTriggerInteraction.Ignore))
|
|
{
|
|
targetNode = transform;
|
|
SetDestinationToPosition(targetNode.position);
|
|
return;
|
|
}
|
|
if (carryingPlayerBody)
|
|
{
|
|
DropPlayerBody();
|
|
DropPlayerBodyServerRpc();
|
|
}
|
|
AddToAngerMeter(AIIntervalTime);
|
|
agent.speed = 0f;
|
|
}
|
|
|
|
public void AddToAngerMeter(float amountToAdd)
|
|
{
|
|
if (stunNormalizedTimer > 0f)
|
|
{
|
|
if (stunnedByPlayer != null)
|
|
{
|
|
stunnedByPlayerLastFrame = true;
|
|
angerMeter = 12f;
|
|
}
|
|
else
|
|
{
|
|
angerMeter = 2f;
|
|
}
|
|
return;
|
|
}
|
|
angerMeter += amountToAdd;
|
|
if (angerMeter <= 0.4f)
|
|
{
|
|
return;
|
|
}
|
|
angerCheckInterval += amountToAdd;
|
|
if (!(angerCheckInterval > 1f))
|
|
{
|
|
return;
|
|
}
|
|
angerCheckInterval = 0f;
|
|
float num = Mathf.Clamp(0.09f * angerMeter, 0f, 0.99f);
|
|
if (Random.Range(0f, 1f) < num)
|
|
{
|
|
if (angerMeter < 2.5f)
|
|
{
|
|
timesThreatened++;
|
|
}
|
|
angerMeter += (float)timesThreatened / 1.75f;
|
|
SwitchToBehaviourStateOnLocalClient(2);
|
|
EnterAngerModeServerRpc(angerMeter);
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void EnterAngerModeServerRpc(float angerTime)
|
|
{
|
|
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(80027368u, serverRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in angerTime, default(FastBufferWriter.ForPrimitives));
|
|
__endSendServerRpc(ref bufferWriter, 80027368u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
EnterAngerModeClientRpc(angerTime);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void EnterAngerModeClientRpc(float angerTime)
|
|
{
|
|
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(2307050878u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in angerTime, default(FastBufferWriter.ForPrimitives));
|
|
__endSendClientRpc(ref bufferWriter, 2307050878u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
angerMeter = angerTime;
|
|
agent.speed = 9f;
|
|
SwitchToBehaviourStateOnLocalClient(2);
|
|
waitAroundEntrancePosition = RoundManager.Instance.GetRandomNavMeshPositionInRadius(mainEntrancePosition, 6f);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ChooseClosestNodeToPlayer()
|
|
{
|
|
if (targetNode == null)
|
|
{
|
|
targetNode = allAINodes[0].transform;
|
|
}
|
|
Transform transform = ChooseClosestNodeToPosition(targetPlayer.transform.position, avoidLineOfSight: true);
|
|
if (transform != null)
|
|
{
|
|
targetNode = transform;
|
|
}
|
|
float num = Vector3.Distance(targetPlayer.transform.position, base.transform.position);
|
|
if (num - mostOptimalDistance < 0.1f && (!PathIsIntersectedByLineOfSight(targetPlayer.transform.position, calculatePathDistance: true) || num < 3f))
|
|
{
|
|
if (pathDistance > 10f && !ignoredNodes.Contains(targetNode) && ignoredNodes.Count < 4)
|
|
{
|
|
ignoredNodes.Add(targetNode);
|
|
}
|
|
movingTowardsTargetPlayer = true;
|
|
}
|
|
else
|
|
{
|
|
SetDestinationToPosition(targetNode.position);
|
|
}
|
|
}
|
|
|
|
public override void Update()
|
|
{
|
|
base.Update();
|
|
if (isEnemyDead || inKillAnimation || GameNetworkManager.Instance == null)
|
|
{
|
|
return;
|
|
}
|
|
if (GameNetworkManager.Instance.localPlayerController.HasLineOfSightToPosition(base.transform.position + Vector3.up * 0.5f, 30f))
|
|
{
|
|
if (currentBehaviourStateIndex == 0)
|
|
{
|
|
SwitchToBehaviourState(1);
|
|
if (!thisNetworkObject.IsOwner)
|
|
{
|
|
ChangeOwnershipOfEnemy(GameNetworkManager.Instance.localPlayerController.actualClientId);
|
|
}
|
|
if (Vector3.Distance(base.transform.position, GameNetworkManager.Instance.localPlayerController.transform.position) < 5f)
|
|
{
|
|
GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(0.6f);
|
|
}
|
|
else
|
|
{
|
|
GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(0.3f);
|
|
}
|
|
agent.speed = 0f;
|
|
evadeStealthTimer = 0f;
|
|
}
|
|
else if (evadeStealthTimer > 0.5f)
|
|
{
|
|
int playerObj = (int)GameNetworkManager.Instance.localPlayerController.playerClientId;
|
|
LookAtFlowermanTrigger(playerObj);
|
|
ResetFlowermanStealthTimerServerRpc(playerObj);
|
|
}
|
|
}
|
|
switch (currentBehaviourStateIndex)
|
|
{
|
|
case 1:
|
|
if (isInAngerMode)
|
|
{
|
|
isInAngerMode = false;
|
|
creatureAnimator.SetBool("anger", value: false);
|
|
}
|
|
if (!wasInEvadeMode)
|
|
{
|
|
wasInEvadeMode = true;
|
|
movingTowardsTargetPlayer = false;
|
|
if (favoriteSpot != null && !carryingPlayerBody && Vector3.Distance(base.transform.position, favoriteSpot.position) < 7f)
|
|
{
|
|
favoriteSpot = null;
|
|
}
|
|
}
|
|
if (stunNormalizedTimer > 0f)
|
|
{
|
|
creatureAnimator.SetLayerWeight(2, 1f);
|
|
}
|
|
else
|
|
{
|
|
creatureAnimator.SetLayerWeight(2, 0f);
|
|
}
|
|
evadeStealthTimer += Time.deltaTime;
|
|
if (thisNetworkObject.IsOwner)
|
|
{
|
|
float num = ((timesFoundSneaking % 3 != 0) ? 11f : 24f);
|
|
if (favoriteSpot != null && carryingPlayerBody)
|
|
{
|
|
num = ((!(Vector3.Distance(base.transform.position, favoriteSpot.position) > 8f)) ? 3f : 24f);
|
|
}
|
|
if (evadeStealthTimer > num)
|
|
{
|
|
evadeStealthTimer = 0f;
|
|
SwitchToBehaviourState(0);
|
|
}
|
|
if (!carryingPlayerBody && evadeModeStareDown && evadeStealthTimer < 1.25f)
|
|
{
|
|
AddToAngerMeter(Time.deltaTime * 1.5f);
|
|
agent.speed = 0f;
|
|
}
|
|
else
|
|
{
|
|
evadeModeStareDown = false;
|
|
if (stunNormalizedTimer > 0f)
|
|
{
|
|
DropPlayerBody();
|
|
AddToAngerMeter(0f);
|
|
agent.speed = 0f;
|
|
}
|
|
else
|
|
{
|
|
if (stunnedByPlayerLastFrame)
|
|
{
|
|
stunnedByPlayerLastFrame = false;
|
|
AddToAngerMeter(0f);
|
|
}
|
|
if (carryingPlayerBody)
|
|
{
|
|
agent.speed = Mathf.Clamp(agent.speed + Time.deltaTime * 7.25f, 4f, 9f);
|
|
}
|
|
else
|
|
{
|
|
agent.speed = Mathf.Clamp(agent.speed + Time.deltaTime * 4.25f, 0f, 6f);
|
|
}
|
|
}
|
|
}
|
|
if (!carryingPlayerBody && ventAnimationFinished)
|
|
{
|
|
LookAtPlayerOfInterest();
|
|
}
|
|
}
|
|
if (!carryingPlayerBody)
|
|
{
|
|
CalculateAnimationDirection();
|
|
break;
|
|
}
|
|
creatureAnimator.SetFloat("speedMultiplier", Vector3.ClampMagnitude(base.transform.position - previousPosition, 1f).sqrMagnitude / (Time.deltaTime * 2f));
|
|
previousPosition = base.transform.position;
|
|
break;
|
|
case 0:
|
|
if (isInAngerMode)
|
|
{
|
|
isInAngerMode = false;
|
|
creatureAnimator.SetBool("anger", value: false);
|
|
}
|
|
if (wasInEvadeMode)
|
|
{
|
|
wasInEvadeMode = false;
|
|
evadeStealthTimer = 0f;
|
|
if (carryingPlayerBody)
|
|
{
|
|
DropPlayerBody();
|
|
agent.enabled = true;
|
|
favoriteSpot = ChooseClosestNodeToPosition(base.transform.position, avoidLineOfSight: true);
|
|
if (!base.IsOwner)
|
|
{
|
|
agent.enabled = false;
|
|
}
|
|
Debug.Log("Flowerman: Dropped player body");
|
|
}
|
|
}
|
|
creatureAnimator.SetFloat("speedMultiplier", Vector3.ClampMagnitude(base.transform.position - previousPosition, 1f).sqrMagnitude / (Time.deltaTime / 4f));
|
|
previousPosition = base.transform.position;
|
|
agent.speed = 6f;
|
|
break;
|
|
case 2:
|
|
{
|
|
bool flag = false;
|
|
if (!isInAngerMode)
|
|
{
|
|
isInAngerMode = true;
|
|
DropPlayerBody();
|
|
creatureAngerVoice.Play();
|
|
creatureAngerVoice.pitch = Random.Range(0.9f, 1.3f);
|
|
creatureAnimator.SetBool("anger", value: true);
|
|
creatureAnimator.SetBool("sneak", value: false);
|
|
if (GameNetworkManager.Instance.localPlayerController.HasLineOfSightToPosition(base.transform.position, 60f, 15, 2.5f))
|
|
{
|
|
flag = true;
|
|
GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(0.5f);
|
|
}
|
|
}
|
|
if (!flag && GameNetworkManager.Instance.localPlayerController.HasLineOfSightToPosition(base.transform.position, 60f, 13, 4f))
|
|
{
|
|
GameNetworkManager.Instance.localPlayerController.IncreaseFearLevelOverTime(0.8f);
|
|
}
|
|
CalculateAnimationDirection(3f);
|
|
if (stunNormalizedTimer > 0f)
|
|
{
|
|
creatureAnimator.SetLayerWeight(2, 1f);
|
|
agent.speed = 0f;
|
|
angerMeter = 6f;
|
|
}
|
|
else
|
|
{
|
|
creatureAnimator.SetLayerWeight(2, 0f);
|
|
agent.speed = Mathf.Clamp(agent.speed + Time.deltaTime * 1.2f, 3f, 12f);
|
|
}
|
|
angerMeter -= Time.deltaTime;
|
|
if (base.IsOwner && angerMeter <= 0f)
|
|
{
|
|
SwitchToBehaviourState(1);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (isInAngerMode)
|
|
{
|
|
creatureAngerVoice.volume = Mathf.Lerp(creatureAngerVoice.volume, 1f, 10f * Time.deltaTime);
|
|
}
|
|
else
|
|
{
|
|
creatureAngerVoice.volume = Mathf.Lerp(creatureAngerVoice.volume, 0f, 2f * Time.deltaTime);
|
|
}
|
|
Vector3 localEulerAngles = animationContainer.localEulerAngles;
|
|
if (carryingPlayerBody)
|
|
{
|
|
agent.angularSpeed = 50f;
|
|
localEulerAngles.z = Mathf.Lerp(localEulerAngles.z, 179f, 10f * Time.deltaTime);
|
|
creatureAnimator.SetLayerWeight(1, Mathf.Lerp(creatureAnimator.GetLayerWeight(1), 1f, 10f * Time.deltaTime));
|
|
}
|
|
else
|
|
{
|
|
agent.angularSpeed = 220f;
|
|
localEulerAngles.z = Mathf.Lerp(localEulerAngles.z, 0f, 10f * Time.deltaTime);
|
|
creatureAnimator.SetLayerWeight(1, Mathf.Lerp(creatureAnimator.GetLayerWeight(1), 0f, 10f * Time.deltaTime));
|
|
}
|
|
animationContainer.localEulerAngles = localEulerAngles;
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void DropPlayerBodyServerRpc()
|
|
{
|
|
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(2817453984u, serverRpcParams, RpcDelivery.Reliable);
|
|
__endSendServerRpc(ref bufferWriter, 2817453984u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
DropPlayerBodyClientRpc();
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void DropPlayerBodyClientRpc()
|
|
{
|
|
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(1942952026u, clientRpcParams, RpcDelivery.Reliable);
|
|
__endSendClientRpc(ref bufferWriter, 1942952026u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
DropPlayerBody();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DropPlayerBody()
|
|
{
|
|
if (carryingPlayerBody)
|
|
{
|
|
carryingPlayerBody = false;
|
|
bodyBeingCarried.matchPositionExactly = false;
|
|
bodyBeingCarried.attachedTo = null;
|
|
bodyBeingCarried = null;
|
|
creatureAnimator.SetBool("carryingBody", value: false);
|
|
}
|
|
}
|
|
|
|
private void LookAtPlayerOfInterest()
|
|
{
|
|
if (isInAngerMode)
|
|
{
|
|
lookAtPlayer = targetPlayer;
|
|
}
|
|
else
|
|
{
|
|
lookAtPlayer = GetClosestPlayer();
|
|
}
|
|
if (lookAtPlayer != null)
|
|
{
|
|
turnCompass.LookAt(lookAtPlayer.gameplayCamera.transform.position);
|
|
base.transform.rotation = Quaternion.Lerp(base.transform.rotation, Quaternion.Euler(new Vector3(0f, turnCompass.eulerAngles.y, 0f)), 30f * Time.deltaTime);
|
|
}
|
|
}
|
|
|
|
private void CalculateAnimationDirection(float maxSpeed = 1f)
|
|
{
|
|
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, 0f - agentLocalVelocity.y, 10f * Time.deltaTime);
|
|
creatureAnimator.SetFloat("VelocityZ", Mathf.Clamp(velZ, 0f - maxSpeed, maxSpeed));
|
|
previousPosition = base.transform.position;
|
|
}
|
|
|
|
public override void OnCollideWithPlayer(Collider other)
|
|
{
|
|
base.OnCollideWithPlayer(other);
|
|
PlayerControllerB playerControllerB = MeetsStandardPlayerCollisionConditions(other, inKillAnimation);
|
|
if (playerControllerB != null)
|
|
{
|
|
KillPlayerAnimationServerRpc((int)playerControllerB.playerClientId);
|
|
playerControllerB.inAnimationWithEnemy = this;
|
|
playerControllerB.inSpecialInteractAnimation = 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(2920701539u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObjectId);
|
|
__endSendServerRpc(ref bufferWriter, 2920701539u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
if (!inKillAnimation)
|
|
{
|
|
inKillAnimation = true;
|
|
inSpecialAnimation = true;
|
|
isClientCalculatingAI = false;
|
|
inSpecialAnimationWithPlayer = StartOfRound.Instance.allPlayerScripts[playerObjectId];
|
|
inSpecialAnimationWithPlayer.inAnimationWithEnemy = this;
|
|
KillPlayerAnimationClientRpc(playerObjectId);
|
|
}
|
|
else
|
|
{
|
|
CancelKillAnimationClientRpc(playerObjectId);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void CancelKillAnimationClientRpc(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(2215703370u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObjectId);
|
|
__endSendClientRpc(ref bufferWriter, 2215703370u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
StartOfRound.Instance.allPlayerScripts[playerObjectId].inAnimationWithEnemy = null;
|
|
StartOfRound.Instance.allPlayerScripts[playerObjectId].inSpecialInteractAnimation = false;
|
|
if (killAnimationCoroutine == null)
|
|
{
|
|
inKillAnimation = 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(114605325u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObjectId);
|
|
__endSendClientRpc(ref bufferWriter, 114605325u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
inSpecialAnimationWithPlayer = StartOfRound.Instance.allPlayerScripts[playerObjectId];
|
|
if (inSpecialAnimationWithPlayer == null || inSpecialAnimationWithPlayer.isPlayerDead || !inSpecialAnimationWithPlayer.isInsideFactory)
|
|
{
|
|
FinishKillAnimation(carryingBody: false);
|
|
}
|
|
inSpecialAnimationWithPlayer.inAnimationWithEnemy = this;
|
|
inKillAnimation = true;
|
|
inSpecialAnimation = true;
|
|
creatureAnimator.SetBool("killing", value: true);
|
|
agent.enabled = false;
|
|
inSpecialAnimationWithPlayer.inSpecialInteractAnimation = true;
|
|
inSpecialAnimationWithPlayer.snapToServerPosition = true;
|
|
Vector3 vector = ((!inSpecialAnimationWithPlayer.IsOwner) ? inSpecialAnimationWithPlayer.transform.parent.TransformPoint(inSpecialAnimationWithPlayer.serverPlayerPosition) : inSpecialAnimationWithPlayer.transform.position);
|
|
Vector3 position = base.transform.position;
|
|
position.y = inSpecialAnimationWithPlayer.transform.position.y;
|
|
playerRay = new Ray(vector, position - inSpecialAnimationWithPlayer.transform.position);
|
|
Debug.DrawRay(vector, position - inSpecialAnimationWithPlayer.transform.position, Color.green, 10f);
|
|
Debug.DrawRay(vector, Vector3.up * 50f, Color.red, 10f);
|
|
Debug.DrawRay(inSpecialAnimationWithPlayer.transform.position, Vector3.up * 50f, Color.yellow, 10f);
|
|
Debug.Log("Doing kill animation");
|
|
turnCompass.LookAt(vector);
|
|
position = base.transform.eulerAngles;
|
|
position.y = turnCompass.eulerAngles.y;
|
|
base.transform.eulerAngles = position;
|
|
if (killAnimationCoroutine != null)
|
|
{
|
|
StopCoroutine(killAnimationCoroutine);
|
|
}
|
|
killAnimationCoroutine = StartCoroutine(killAnimation());
|
|
}
|
|
}
|
|
|
|
private IEnumerator killAnimation()
|
|
{
|
|
WalkieTalkie.TransmitOneShotAudio(crackNeckAudio, crackNeckSFX);
|
|
crackNeckAudio.PlayOneShot(crackNeckSFX);
|
|
Vector3 endPosition = playerRay.GetPoint(1f);
|
|
Debug.DrawRay(endPosition, Vector3.up, Color.red, 10f);
|
|
Vector3 startingPosition = base.transform.position;
|
|
Debug.Log($"start: {startingPosition} / end: {endPosition}");
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
base.transform.position = Vector3.Lerp(startingPosition, endPosition, (float)i / 5f);
|
|
yield return null;
|
|
}
|
|
base.transform.position = endPosition;
|
|
creatureAnimator.SetBool("killing", value: false);
|
|
creatureAnimator.SetBool("carryingBody", value: true);
|
|
yield return new WaitForSeconds(0.65f);
|
|
if (inSpecialAnimationWithPlayer != null)
|
|
{
|
|
inSpecialAnimationWithPlayer.KillPlayer(Vector3.zero, spawnBody: true, CauseOfDeath.Strangulation);
|
|
inSpecialAnimationWithPlayer.snapToServerPosition = false;
|
|
float startTime = Time.timeSinceLevelLoad;
|
|
yield return new WaitUntil(() => inSpecialAnimationWithPlayer.deadBody != null || Time.timeSinceLevelLoad - startTime > 2f);
|
|
}
|
|
if (inSpecialAnimationWithPlayer == null || inSpecialAnimationWithPlayer.deadBody == null)
|
|
{
|
|
Debug.Log("Flowerman: Player body was not spawned or found within 2 seconds.");
|
|
FinishKillAnimation(carryingBody: false);
|
|
}
|
|
else
|
|
{
|
|
inSpecialAnimationWithPlayer.deadBody.bodyBleedingHeavily = true;
|
|
FinishKillAnimation();
|
|
}
|
|
}
|
|
|
|
public void FinishKillAnimation(bool carryingBody = true)
|
|
{
|
|
if (killAnimationCoroutine != null)
|
|
{
|
|
StopCoroutine(killAnimationCoroutine);
|
|
}
|
|
inSpecialAnimation = false;
|
|
inKillAnimation = false;
|
|
creatureAnimator.SetBool("killing", value: false);
|
|
if (inSpecialAnimationWithPlayer != null)
|
|
{
|
|
inSpecialAnimationWithPlayer.inSpecialInteractAnimation = false;
|
|
inSpecialAnimationWithPlayer.snapToServerPosition = false;
|
|
inSpecialAnimationWithPlayer.inAnimationWithEnemy = null;
|
|
if (carryingBody)
|
|
{
|
|
bodyBeingCarried = inSpecialAnimationWithPlayer.deadBody;
|
|
bodyBeingCarried.attachedTo = rightHandGrip;
|
|
bodyBeingCarried.attachedLimb = inSpecialAnimationWithPlayer.deadBody.bodyParts[0];
|
|
bodyBeingCarried.matchPositionExactly = true;
|
|
carryingPlayerBody = true;
|
|
}
|
|
}
|
|
evadeStealthTimer = 0f;
|
|
movingTowardsTargetPlayer = false;
|
|
ignoredNodes.Clear();
|
|
if (!carryingBody)
|
|
{
|
|
creatureAnimator.SetBool("carryingBody", value: false);
|
|
}
|
|
if (base.IsOwner)
|
|
{
|
|
agent.enabled = true;
|
|
isClientCalculatingAI = true;
|
|
}
|
|
SwitchToBehaviourStateOnLocalClient(1);
|
|
if (base.IsServer)
|
|
{
|
|
SwitchToBehaviourState(1);
|
|
}
|
|
Debug.Log($"Flowerman: is agent enabled after killing?: {agent.enabled}; speed: {agent.speed}");
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void ResetFlowermanStealthTimerServerRpc(int playerObj)
|
|
{
|
|
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(843847125u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObj);
|
|
__endSendServerRpc(ref bufferWriter, 843847125u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
ResetFlowermanStealthClientRpc(playerObj);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void ResetFlowermanStealthClientRpc(int playerObj)
|
|
{
|
|
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(3273050u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerObj);
|
|
__endSendClientRpc(ref bufferWriter, 3273050u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && playerObj != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
|
|
{
|
|
LookAtFlowermanTrigger(playerObj);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void LookAtFlowermanTrigger(int playerObj)
|
|
{
|
|
if (!base.IsOwner)
|
|
{
|
|
return;
|
|
}
|
|
if (!evadeModeStareDown)
|
|
{
|
|
if (Random.Range(0, 70) < stareDownChanceIncrease)
|
|
{
|
|
stareDownChanceIncrease = -6;
|
|
evadeModeStareDown = true;
|
|
}
|
|
else
|
|
{
|
|
stareDownChanceIncrease++;
|
|
}
|
|
evadeStealthTimer = 0f;
|
|
}
|
|
if (carryingPlayerBody && favoriteSpot != null && Vector3.Distance(base.transform.position, favoriteSpot.transform.position) < 5f)
|
|
{
|
|
DropPlayerBody();
|
|
}
|
|
}
|
|
|
|
public override void KillEnemy(bool destroy = false)
|
|
{
|
|
if (creatureVoice != null)
|
|
{
|
|
creatureVoice.Stop();
|
|
}
|
|
creatureSFX.Stop();
|
|
creatureAnimator.SetLayerWeight(2, 0f);
|
|
base.KillEnemy();
|
|
if (carryingPlayerBody)
|
|
{
|
|
carryingPlayerBody = false;
|
|
if (bodyBeingCarried != null)
|
|
{
|
|
bodyBeingCarried.matchPositionExactly = false;
|
|
bodyBeingCarried.attachedTo = null;
|
|
}
|
|
}
|
|
if (inKillAnimation)
|
|
{
|
|
FinishKillAnimation(carryingBody: false);
|
|
}
|
|
}
|
|
|
|
public override void HitEnemy(int force = 1, PlayerControllerB playerWhoHit = null, bool playHitSFX = false)
|
|
{
|
|
base.HitEnemy(force, playerWhoHit);
|
|
Debug.Log("Flowerman was hit and angered!");
|
|
enemyHP -= force;
|
|
if (base.IsOwner)
|
|
{
|
|
if (enemyHP <= 0)
|
|
{
|
|
KillEnemyOnOwnerClient();
|
|
return;
|
|
}
|
|
angerMeter = 11f;
|
|
angerCheckInterval = 1f;
|
|
AddToAngerMeter(0.1f);
|
|
}
|
|
}
|
|
|
|
protected override void __initializeVariables()
|
|
{
|
|
base.__initializeVariables();
|
|
}
|
|
|
|
[RuntimeInitializeOnLoadMethod]
|
|
internal static void InitializeRPCS_FlowermanAI()
|
|
{
|
|
NetworkManager.__rpc_func_table.Add(80027368u, __rpc_handler_80027368);
|
|
NetworkManager.__rpc_func_table.Add(2307050878u, __rpc_handler_2307050878);
|
|
NetworkManager.__rpc_func_table.Add(2817453984u, __rpc_handler_2817453984);
|
|
NetworkManager.__rpc_func_table.Add(1942952026u, __rpc_handler_1942952026);
|
|
NetworkManager.__rpc_func_table.Add(2920701539u, __rpc_handler_2920701539);
|
|
NetworkManager.__rpc_func_table.Add(2215703370u, __rpc_handler_2215703370);
|
|
NetworkManager.__rpc_func_table.Add(114605325u, __rpc_handler_114605325);
|
|
NetworkManager.__rpc_func_table.Add(843847125u, __rpc_handler_843847125);
|
|
NetworkManager.__rpc_func_table.Add(3273050u, __rpc_handler_3273050);
|
|
}
|
|
|
|
private static void __rpc_handler_80027368(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 float value, default(FastBufferWriter.ForPrimitives));
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((FlowermanAI)target).EnterAngerModeServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2307050878(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
reader.ReadValueSafe(out float value, default(FastBufferWriter.ForPrimitives));
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((FlowermanAI)target).EnterAngerModeClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2817453984(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;
|
|
((FlowermanAI)target).DropPlayerBodyServerRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1942952026(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((FlowermanAI)target).DropPlayerBodyClientRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2920701539(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;
|
|
((FlowermanAI)target).KillPlayerAnimationServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2215703370(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;
|
|
((FlowermanAI)target).CancelKillAnimationClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_114605325(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;
|
|
((FlowermanAI)target).KillPlayerAnimationClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_843847125(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;
|
|
((FlowermanAI)target).ResetFlowermanStealthTimerServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3273050(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;
|
|
((FlowermanAI)target).ResetFlowermanStealthClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
protected internal override string __getTypeName()
|
|
{
|
|
return "FlowermanAI";
|
|
}
|
|
}
|