1632 lines
53 KiB
C#
1632 lines
53 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using GameNetcodeStuff;
|
|
using Unity.Netcode;
|
|
using UnityEngine;
|
|
using UnityEngine.AI;
|
|
|
|
public class SandSpiderAI : EnemyAI
|
|
{
|
|
private float[] legDistances = new float[12]
|
|
{
|
|
2.2f, 2.2f, 1.8f, 1.8f, 1.3f, 1.3f, 1.5f, 1.5f, 1f, 1f,
|
|
0.6f, 0.6f
|
|
};
|
|
|
|
public Vector3[] legPositions;
|
|
|
|
public Transform[] legDefaultPositions;
|
|
|
|
public Transform[] legTargets;
|
|
|
|
public Transform abdomen;
|
|
|
|
public Transform mouthTarget;
|
|
|
|
public bool burrowing;
|
|
|
|
public Transform turnCompass;
|
|
|
|
public Vector3 wallPosition;
|
|
|
|
public Vector3 wallNormal;
|
|
|
|
public Vector3 floorPosition;
|
|
|
|
private bool onWall;
|
|
|
|
private RaycastHit rayHit;
|
|
|
|
private Ray ray;
|
|
|
|
public bool lookingForWallPosition;
|
|
|
|
private bool gotWallPositionInLOS;
|
|
|
|
private float tryWallPositionInterval;
|
|
|
|
private bool reachedWallPosition;
|
|
|
|
public Transform meshContainer;
|
|
|
|
public Vector3 meshContainerPosition;
|
|
|
|
public Vector3 meshContainerTarget;
|
|
|
|
private Quaternion meshContainerTargetRotation;
|
|
|
|
public float spiderSpeed;
|
|
|
|
public float calculatePathToAgentInterval;
|
|
|
|
public bool navigateMeshTowardsPosition;
|
|
|
|
public Vector3 navigateToPositionTarget;
|
|
|
|
public NavMeshHit navHit;
|
|
|
|
public List<SandSpiderWebTrap> webTraps = new List<SandSpiderWebTrap>();
|
|
|
|
public GameObject webTrapPrefab;
|
|
|
|
public int maxWebTrapsToPlace;
|
|
|
|
private float timeSincePlacingWebTrap;
|
|
|
|
public Vector3 meshContainerServerPosition;
|
|
|
|
public Vector3 meshContainerServerRotation;
|
|
|
|
private Vector3 refVel;
|
|
|
|
public Transform homeNode;
|
|
|
|
public AISearchRoutine patrolHomeBase;
|
|
|
|
private bool setDestinationToHomeBase;
|
|
|
|
private float chaseTimer;
|
|
|
|
private bool overrideSpiderLookRotation;
|
|
|
|
private bool watchFromDistance;
|
|
|
|
public float overrideAnimation;
|
|
|
|
private float overrideAnimationWeight;
|
|
|
|
private float timeSinceHittingPlayer;
|
|
|
|
private DeadBodyInfo currentlyHeldBody;
|
|
|
|
public Mesh playerBodyWebMesh;
|
|
|
|
public Material playerBodyWebMat;
|
|
|
|
private bool spooledPlayerBody;
|
|
|
|
private bool spoolingPlayerBody;
|
|
|
|
private Coroutine turnBodyIntoWebCoroutine;
|
|
|
|
private bool decidedChanceToHangBodyEarly;
|
|
|
|
public GameObject hangBodyPhysicsPrefab;
|
|
|
|
private Coroutine grabBodyCoroutine;
|
|
|
|
private float waitOnWallTimer;
|
|
|
|
public AudioClip[] footstepSFX;
|
|
|
|
public AudioSource footstepAudio;
|
|
|
|
public AudioClip hitWebSFX;
|
|
|
|
public AudioClip attackSFX;
|
|
|
|
public AudioClip spoolPlayerSFX;
|
|
|
|
public AudioClip hangPlayerSFX;
|
|
|
|
public AudioClip breakWebSFX;
|
|
|
|
public AudioClip hitSpiderSFX;
|
|
|
|
private float lookAtPlayerInterval;
|
|
|
|
public Rigidbody meshContainerRigidbody;
|
|
|
|
private RaycastHit rayHitB;
|
|
|
|
private int health = 5;
|
|
|
|
public override void Start()
|
|
{
|
|
base.Start();
|
|
meshContainerPosition = base.transform.position;
|
|
meshContainerTarget = base.transform.position;
|
|
navHit = default(NavMeshHit);
|
|
rayHitB = default(RaycastHit);
|
|
patrolHomeBase.searchWidth = 17f;
|
|
patrolHomeBase.searchPrecision = 3f;
|
|
maxWebTrapsToPlace = Random.Range(4, 7);
|
|
homeNode = ChooseClosestNodeToPosition(base.transform.position, avoidLineOfSight: false, 2);
|
|
meshContainerTargetRotation = Quaternion.identity;
|
|
}
|
|
|
|
public override void DoAIInterval()
|
|
{
|
|
base.DoAIInterval();
|
|
if (isEnemyDead)
|
|
{
|
|
return;
|
|
}
|
|
if (lookingForWallPosition && !gotWallPositionInLOS)
|
|
{
|
|
gotWallPositionInLOS = GetWallPositionForSpiderMesh();
|
|
}
|
|
if (navigateMeshTowardsPosition)
|
|
{
|
|
CalculateSpiderPathToPosition();
|
|
}
|
|
switch (currentBehaviourStateIndex)
|
|
{
|
|
case 0:
|
|
setDestinationToHomeBase = false;
|
|
lookingForWallPosition = false;
|
|
reachedWallPosition = false;
|
|
if (!patrolHomeBase.inProgress)
|
|
{
|
|
StartSearch(homeNode.position, patrolHomeBase);
|
|
}
|
|
break;
|
|
case 1:
|
|
movingTowardsTargetPlayer = false;
|
|
if (!lookingForWallPosition)
|
|
{
|
|
if (Vector3.Distance(base.transform.position, homeNode.position) > 7f)
|
|
{
|
|
patrolHomeBase.searchWidth = 6f;
|
|
if (!patrolHomeBase.inProgress)
|
|
{
|
|
if (PathIsIntersectedByLineOfSight(homeNode.position, calculatePathDistance: false, avoidLineOfSight: false))
|
|
{
|
|
homeNode = ChooseClosestNodeToPosition(base.transform.position, avoidLineOfSight: false, 2);
|
|
}
|
|
StartSearch(homeNode.position, patrolHomeBase);
|
|
}
|
|
break;
|
|
}
|
|
if (currentlyHeldBody != null && !spooledPlayerBody)
|
|
{
|
|
if (turnBodyIntoWebCoroutine == null)
|
|
{
|
|
turnBodyIntoWebCoroutine = StartCoroutine(turnBodyIntoWeb());
|
|
SpiderTurnBodyIntoWebServerRpc();
|
|
}
|
|
break;
|
|
}
|
|
if (currentlyHeldBody != null && !decidedChanceToHangBodyEarly)
|
|
{
|
|
if (Random.Range(0, 100) < 150)
|
|
{
|
|
HangBodyFromCeiling();
|
|
SpiderHangBodyServerRpc();
|
|
}
|
|
decidedChanceToHangBodyEarly = true;
|
|
}
|
|
if (patrolHomeBase.inProgress)
|
|
{
|
|
StopSearch(patrolHomeBase);
|
|
}
|
|
lookingForWallPosition = true;
|
|
reachedWallPosition = false;
|
|
break;
|
|
}
|
|
if (reachedWallPosition)
|
|
{
|
|
if (currentlyHeldBody != null)
|
|
{
|
|
HangBodyFromCeiling();
|
|
SpiderHangBodyServerRpc();
|
|
}
|
|
for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
|
|
{
|
|
if (PlayerIsTargetable(StartOfRound.Instance.allPlayerScripts[i]) && !Physics.Linecast(meshContainer.position, StartOfRound.Instance.allPlayerScripts[i].gameplayCamera.transform.position, StartOfRound.Instance.collidersAndRoomMask))
|
|
{
|
|
float num = Vector3.Distance(StartOfRound.Instance.allPlayerScripts[i].gameplayCamera.transform.position, meshContainer.position);
|
|
if (num < 5f)
|
|
{
|
|
TriggerChaseWithPlayer(StartOfRound.Instance.allPlayerScripts[i]);
|
|
break;
|
|
}
|
|
if (num < 10f)
|
|
{
|
|
Vector3 position = StartOfRound.Instance.allPlayerScripts[i].gameplayCamera.transform.position;
|
|
float num2 = Vector3.Dot(position - meshContainer.position, wallNormal);
|
|
Vector3 forward = position - num2 * wallNormal;
|
|
meshContainerTargetRotation = Quaternion.LookRotation(forward, wallNormal);
|
|
overrideSpiderLookRotation = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
overrideSpiderLookRotation = false;
|
|
break;
|
|
case 2:
|
|
if (patrolHomeBase.inProgress)
|
|
{
|
|
StopSearch(patrolHomeBase);
|
|
}
|
|
if (watchFromDistance && !TargetClosestPlayer(2f, requireLineOfSight: true, 80f))
|
|
{
|
|
StopChasing();
|
|
}
|
|
if (!(targetPlayer == null))
|
|
{
|
|
if (targetPlayer.isPlayerDead && targetPlayer.deadBody != null && (!SetDestinationToPosition(targetPlayer.deadBody.bodyParts[6].transform.position, checkForPath: true) || targetPlayer.deadBody.attachedTo != null))
|
|
{
|
|
targetPlayer = null;
|
|
StopChasing(moveTowardsDeadPlayerBody: true);
|
|
}
|
|
if (watchFromDistance)
|
|
{
|
|
SetDestinationToPosition(ChooseClosestNodeToPosition(targetPlayer.transform.position, avoidLineOfSight: false, 4).transform.position);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private IEnumerator turnBodyIntoWeb()
|
|
{
|
|
if (currentlyHeldBody == null)
|
|
{
|
|
Debug.LogError("Sand Spider: Tried to wrap body but it could not be found.");
|
|
yield break;
|
|
}
|
|
spoolingPlayerBody = true;
|
|
overrideAnimation = 4.05f;
|
|
creatureAnimator.SetTrigger("spool");
|
|
creatureSFX.PlayOneShot(spoolPlayerSFX);
|
|
yield return new WaitForSeconds(0.9f);
|
|
if (currentlyHeldBody.attachedTo != mouthTarget)
|
|
{
|
|
CancelSpoolingBody();
|
|
}
|
|
currentlyHeldBody.ChangeMesh(playerBodyWebMesh, playerBodyWebMat);
|
|
yield return new WaitForSeconds(3.105f);
|
|
spooledPlayerBody = true;
|
|
spoolingPlayerBody = false;
|
|
turnBodyIntoWebCoroutine = null;
|
|
if (currentlyHeldBody.attachedTo != mouthTarget)
|
|
{
|
|
CancelSpoolingBody();
|
|
}
|
|
}
|
|
|
|
private void CancelSpoolingBody()
|
|
{
|
|
if (turnBodyIntoWebCoroutine != null)
|
|
{
|
|
StopCoroutine(turnBodyIntoWebCoroutine);
|
|
}
|
|
if (currentlyHeldBody != null)
|
|
{
|
|
currentlyHeldBody.attachedLimb = null;
|
|
currentlyHeldBody.attachedTo = null;
|
|
currentlyHeldBody = null;
|
|
}
|
|
spooledPlayerBody = false;
|
|
spoolingPlayerBody = false;
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void SpiderTurnBodyIntoWebServerRpc()
|
|
{
|
|
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(224635274u, serverRpcParams, RpcDelivery.Reliable);
|
|
__endSendServerRpc(ref bufferWriter, 224635274u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
SpiderTurnBodyIntoWebClientRpc();
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void SpiderTurnBodyIntoWebClientRpc()
|
|
{
|
|
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(2894295549u, clientRpcParams, RpcDelivery.Reliable);
|
|
__endSendClientRpc(ref bufferWriter, 2894295549u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsOwner && !isEnemyDead && turnBodyIntoWebCoroutine == null)
|
|
{
|
|
turnBodyIntoWebCoroutine = StartCoroutine(turnBodyIntoWeb());
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void SpiderHangBodyServerRpc()
|
|
{
|
|
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(1372568795u, serverRpcParams, RpcDelivery.Reliable);
|
|
__endSendServerRpc(ref bufferWriter, 1372568795u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
SpiderHangBodyClientRpc();
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void SpiderHangBodyClientRpc()
|
|
{
|
|
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(180633541u, clientRpcParams, RpcDelivery.Reliable);
|
|
__endSendClientRpc(ref bufferWriter, 180633541u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsOwner)
|
|
{
|
|
HangBodyFromCeiling();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void HangBodyFromCeiling()
|
|
{
|
|
if (currentlyHeldBody == null)
|
|
{
|
|
Debug.LogError("Sand spider: Held body was null, couldn't hang up");
|
|
return;
|
|
}
|
|
Vector3 position = abdomen.position + Vector3.up * 6f;
|
|
if (Physics.Raycast(abdomen.position, Vector3.up, out rayHit, 25f, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
|
|
{
|
|
position = rayHit.point;
|
|
}
|
|
SetLineRendererPoints component = Object.Instantiate(hangBodyPhysicsPrefab, position, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform).GetComponent<SetLineRendererPoints>();
|
|
component.target.position = currentlyHeldBody.bodyParts[6].transform.position;
|
|
currentlyHeldBody.attachedTo = component.target;
|
|
decidedChanceToHangBodyEarly = false;
|
|
currentlyHeldBody.bodyAudio.volume = 0.8f;
|
|
currentlyHeldBody.bodyAudio.PlayOneShot(hangPlayerSFX);
|
|
currentlyHeldBody = null;
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void GrabBodyServerRpc(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(196846835u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendServerRpc(ref bufferWriter, 196846835u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
GrabBodyClientRpc(playerId);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void GrabBodyClientRpc(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(4242200834u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendClientRpc(ref bufferWriter, 4242200834u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsOwner)
|
|
{
|
|
if (grabBodyCoroutine != null)
|
|
{
|
|
StopCoroutine(grabBodyCoroutine);
|
|
}
|
|
grabBodyCoroutine = StartCoroutine(WaitForBodyToGrab(playerId));
|
|
}
|
|
}
|
|
|
|
private void GrabBody(DeadBodyInfo body)
|
|
{
|
|
currentlyHeldBody = body;
|
|
currentlyHeldBody.attachedLimb = currentlyHeldBody.bodyParts[6];
|
|
currentlyHeldBody.attachedTo = mouthTarget;
|
|
currentlyHeldBody.matchPositionExactly = true;
|
|
}
|
|
|
|
private IEnumerator WaitForBodyToGrab(int playerId)
|
|
{
|
|
float timeAtStartOfWait = Time.timeSinceLevelLoad;
|
|
yield return new WaitUntil(() => StartOfRound.Instance.allPlayerScripts[playerId].deadBody != null || Time.timeSinceLevelLoad - timeAtStartOfWait > 10f);
|
|
if (StartOfRound.Instance.allPlayerScripts[playerId].deadBody == null)
|
|
{
|
|
Debug.LogError("SandSpider: Grab body RPC was called, but body did not spawn within 10 seconds on this client.");
|
|
}
|
|
DeadBodyInfo deadBody = StartOfRound.Instance.allPlayerScripts[playerId].deadBody;
|
|
GrabBody(deadBody);
|
|
}
|
|
|
|
private void CalculateSpiderPathToPosition()
|
|
{
|
|
if (NavMesh.CalculatePath(meshContainer.position, navigateToPositionTarget, -1, path1))
|
|
{
|
|
if (path1.corners.Length > 1)
|
|
{
|
|
meshContainerTarget = path1.corners[1];
|
|
if (!overrideSpiderLookRotation)
|
|
{
|
|
SetSpiderLookAtPosition(path1.corners[1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
meshContainerTarget = navigateToPositionTarget;
|
|
if (!overrideSpiderLookRotation)
|
|
{
|
|
SetSpiderLookAtPosition(navigateToPositionTarget);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
meshContainer.position = RoundManager.Instance.GetNavMeshPosition(meshContainer.position, navHit);
|
|
meshContainerTarget = meshContainer.position;
|
|
}
|
|
}
|
|
|
|
public override void Update()
|
|
{
|
|
base.Update();
|
|
timeSinceHittingPlayer += Time.deltaTime;
|
|
if (isEnemyDead)
|
|
{
|
|
agent.speed = 0f;
|
|
spiderSpeed = 0f;
|
|
creatureAnimator.SetBool("moving", value: false);
|
|
return;
|
|
}
|
|
if (!base.IsOwner)
|
|
{
|
|
creatureAnimator.SetBool("moving", refVel.sqrMagnitude > 0.002f);
|
|
return;
|
|
}
|
|
creatureAnimator.SetBool("moving", refVel.sqrMagnitude * Time.deltaTime * 25f > 0.002f);
|
|
SyncMeshContainerPositionToClients();
|
|
CalculateMeshMovement();
|
|
if (!base.IsOwner)
|
|
{
|
|
return;
|
|
}
|
|
switch (currentBehaviourStateIndex)
|
|
{
|
|
case 0:
|
|
{
|
|
setDestinationToHomeBase = false;
|
|
lookingForWallPosition = false;
|
|
movingTowardsTargetPlayer = false;
|
|
overrideSpiderLookRotation = false;
|
|
waitOnWallTimer = 11f;
|
|
if (stunNormalizedTimer > 0f)
|
|
{
|
|
agent.speed = 0f;
|
|
spiderSpeed = 0f;
|
|
}
|
|
else
|
|
{
|
|
agent.speed = 4.25f;
|
|
spiderSpeed = 4.25f;
|
|
}
|
|
PlayerControllerB closestPlayer = GetClosestPlayer(requireLineOfSight: true);
|
|
if (closestPlayer != null && HasLineOfSightToPosition(closestPlayer.gameplayCamera.transform.position, 80f, 15, 2f))
|
|
{
|
|
targetPlayer = closestPlayer;
|
|
SwitchToBehaviourState(2);
|
|
chaseTimer = 12.5f;
|
|
watchFromDistance = mostOptimalDistance > 8f;
|
|
}
|
|
if (timeSincePlacingWebTrap > 4f)
|
|
{
|
|
timeSincePlacingWebTrap = Random.Range(0f, 1.5f);
|
|
AttemptPlaceWebTrap();
|
|
if (webTraps.Count > maxWebTrapsToPlace)
|
|
{
|
|
SwitchToBehaviourState(1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
timeSincePlacingWebTrap += Time.deltaTime;
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
if (spoolingPlayerBody || stunNormalizedTimer > 0f)
|
|
{
|
|
agent.speed = 0f;
|
|
spiderSpeed = 0f;
|
|
}
|
|
else
|
|
{
|
|
agent.speed = 4.5f;
|
|
spiderSpeed = 3.75f;
|
|
}
|
|
if (webTraps.Count < maxWebTrapsToPlace && currentlyHeldBody == null)
|
|
{
|
|
waitOnWallTimer -= Time.deltaTime;
|
|
}
|
|
if (waitOnWallTimer <= 0f)
|
|
{
|
|
SwitchToBehaviourState(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
setDestinationToHomeBase = false;
|
|
reachedWallPosition = false;
|
|
lookingForWallPosition = false;
|
|
waitOnWallTimer = 11f;
|
|
if (spoolingPlayerBody)
|
|
{
|
|
CancelSpoolingBody();
|
|
}
|
|
if (targetPlayer == null)
|
|
{
|
|
StopChasing();
|
|
break;
|
|
}
|
|
if (onWall)
|
|
{
|
|
movingTowardsTargetPlayer = true;
|
|
agent.speed = 4.25f;
|
|
spiderSpeed = 4.25f;
|
|
break;
|
|
}
|
|
if (watchFromDistance)
|
|
{
|
|
if (lookAtPlayerInterval <= 0f)
|
|
{
|
|
lookAtPlayerInterval = 3f;
|
|
movingTowardsTargetPlayer = false;
|
|
overrideSpiderLookRotation = true;
|
|
Vector3 position = targetPlayer.transform.position;
|
|
position.y = meshContainer.position.y;
|
|
SetSpiderLookAtPosition(position);
|
|
}
|
|
else
|
|
{
|
|
lookAtPlayerInterval -= Time.deltaTime;
|
|
}
|
|
agent.speed = 0f;
|
|
spiderSpeed = 0f;
|
|
if (Physics.Linecast(meshContainer.position, targetPlayer.gameplayCamera.transform.position, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
|
|
{
|
|
StopChasing();
|
|
}
|
|
else if (Vector3.Distance(targetPlayer.gameplayCamera.transform.position, base.transform.position) < 5f || stunNormalizedTimer > 0f)
|
|
{
|
|
watchFromDistance = false;
|
|
}
|
|
break;
|
|
}
|
|
agent.speed = 4.5f;
|
|
spiderSpeed = 4.25f;
|
|
movingTowardsTargetPlayer = true;
|
|
overrideSpiderLookRotation = false;
|
|
Debug.Log("Chasing player");
|
|
if (timeSinceHittingPlayer < 0.5f)
|
|
{
|
|
agent.speed = 0.7f;
|
|
spiderSpeed = 0.4f;
|
|
}
|
|
if (targetPlayer.isPlayerDead && targetPlayer.deadBody != null)
|
|
{
|
|
if (Vector3.Distance(targetPlayer.deadBody.bodyParts[6].transform.position, meshContainer.position) < 3.7f)
|
|
{
|
|
spooledPlayerBody = false;
|
|
GrabBody(targetPlayer.deadBody);
|
|
GrabBodyServerRpc((int)targetPlayer.playerClientId);
|
|
SwitchToBehaviourState(1);
|
|
}
|
|
else
|
|
{
|
|
targetPlayer = null;
|
|
StopChasing();
|
|
}
|
|
}
|
|
else if (!PlayerIsTargetable(targetPlayer) || (Vector3.Distance(targetPlayer.transform.position, homeNode.position) > 12f && Vector3.Distance(targetPlayer.transform.position, base.transform.position) > 5f))
|
|
{
|
|
chaseTimer -= Time.deltaTime;
|
|
if (chaseTimer <= 0f)
|
|
{
|
|
targetPlayer = null;
|
|
StopChasing();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (stunNormalizedTimer > 0f)
|
|
{
|
|
spiderSpeed = 0f;
|
|
agent.speed = 0f;
|
|
}
|
|
}
|
|
|
|
private void StopChasing(bool moveTowardsDeadPlayerBody = false)
|
|
{
|
|
overrideSpiderLookRotation = false;
|
|
movingTowardsTargetPlayer = false;
|
|
lookingForWallPosition = false;
|
|
if (webTraps.Count > maxWebTrapsToPlace || moveTowardsDeadPlayerBody)
|
|
{
|
|
SwitchToBehaviourState(1);
|
|
}
|
|
else
|
|
{
|
|
SwitchToBehaviourState(0);
|
|
}
|
|
}
|
|
|
|
private void CalculateMeshMovement()
|
|
{
|
|
if (lookingForWallPosition && gotWallPositionInLOS)
|
|
{
|
|
if (!onWall)
|
|
{
|
|
agent.obstacleAvoidanceType = ObstacleAvoidanceType.HighQualityObstacleAvoidance;
|
|
navigateMeshTowardsPosition = true;
|
|
navigateToPositionTarget = floorPosition;
|
|
if (!overrideSpiderLookRotation)
|
|
{
|
|
turnCompass.position = meshContainer.position;
|
|
turnCompass.LookAt(floorPosition, Vector3.up);
|
|
meshContainerTargetRotation = turnCompass.rotation;
|
|
}
|
|
if (Vector3.Distance(meshContainer.transform.position, floorPosition) < 0.7f)
|
|
{
|
|
onWall = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
agent.obstacleAvoidanceType = ObstacleAvoidanceType.NoObstacleAvoidance;
|
|
navigateMeshTowardsPosition = false;
|
|
meshContainerTarget = wallPosition;
|
|
if (!reachedWallPosition && Vector3.Distance(meshContainer.position, wallPosition) < 0.1f)
|
|
{
|
|
reachedWallPosition = true;
|
|
}
|
|
if (!overrideSpiderLookRotation)
|
|
{
|
|
turnCompass.position = meshContainer.position;
|
|
turnCompass.LookAt(wallPosition, wallNormal);
|
|
meshContainerTargetRotation = turnCompass.rotation;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (!lookingForWallPosition)
|
|
{
|
|
gotWallPositionInLOS = false;
|
|
reachedWallPosition = false;
|
|
}
|
|
if (!onWall)
|
|
{
|
|
agent.obstacleAvoidanceType = ObstacleAvoidanceType.HighQualityObstacleAvoidance;
|
|
if (!navigateMeshTowardsPosition)
|
|
{
|
|
CalculateSpiderPathToPosition();
|
|
navigateMeshTowardsPosition = true;
|
|
}
|
|
navigateToPositionTarget = base.transform.position + Vector3.Normalize(agent.desiredVelocity) * 2f;
|
|
return;
|
|
}
|
|
agent.obstacleAvoidanceType = ObstacleAvoidanceType.NoObstacleAvoidance;
|
|
navigateMeshTowardsPosition = false;
|
|
meshContainerTarget = floorPosition;
|
|
if (!overrideSpiderLookRotation)
|
|
{
|
|
turnCompass.position = meshContainer.position;
|
|
turnCompass.LookAt(floorPosition, wallNormal);
|
|
meshContainerTargetRotation = turnCompass.rotation;
|
|
}
|
|
if (Vector3.Distance(meshContainer.transform.position, floorPosition) < 1.1f)
|
|
{
|
|
onWall = false;
|
|
}
|
|
}
|
|
|
|
private void SetSpiderLookAtPosition(Vector3 lookAt)
|
|
{
|
|
turnCompass.position = meshContainer.position;
|
|
turnCompass.LookAt(lookAt, Vector3.up);
|
|
meshContainerTargetRotation = turnCompass.rotation;
|
|
}
|
|
|
|
private bool GetWallPositionForSpiderMesh()
|
|
{
|
|
float num = 6f;
|
|
if (Physics.Raycast(base.transform.position, Vector3.up, out rayHit, 22f, StartOfRound.Instance.collidersAndRoomMask, QueryTriggerInteraction.Ignore))
|
|
{
|
|
num = ((!(currentlyHeldBody != null)) ? (rayHit.distance - 1.3f) : (rayHit.distance - 2f));
|
|
}
|
|
float num2 = RoundManager.Instance.YRotationThatFacesTheNearestFromPosition(base.transform.position + Vector3.up * num, 10f);
|
|
if (num2 != -777f)
|
|
{
|
|
turnCompass.eulerAngles = new Vector3(0f, num2, 0f);
|
|
ray = new Ray(base.transform.position + Vector3.up * num, turnCompass.forward);
|
|
if (Physics.Raycast(ray, out rayHit, 10.1f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, QueryTriggerInteraction.Ignore))
|
|
{
|
|
wallPosition = ray.GetPoint(rayHit.distance - 0.2f);
|
|
wallNormal = rayHit.normal;
|
|
if (Physics.Raycast(wallPosition, Vector3.down, out rayHitB, 7f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, QueryTriggerInteraction.Ignore))
|
|
{
|
|
floorPosition = rayHitB.point;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void LateUpdate()
|
|
{
|
|
if (isEnemyDead || StartOfRound.Instance.allPlayersDead)
|
|
{
|
|
return;
|
|
}
|
|
if (base.IsOwner)
|
|
{
|
|
Vector3 vector = meshContainerPosition;
|
|
meshContainerPosition = Vector3.MoveTowards(meshContainerPosition, meshContainerTarget, spiderSpeed * Time.deltaTime);
|
|
refVel = vector - meshContainerPosition;
|
|
meshContainer.position = meshContainerPosition;
|
|
meshContainer.rotation = Quaternion.Lerp(meshContainer.rotation, meshContainerTargetRotation, 8f * Time.deltaTime);
|
|
}
|
|
else
|
|
{
|
|
meshContainer.position = Vector3.SmoothDamp(meshContainerPosition, meshContainerServerPosition, ref refVel, 4f * Time.deltaTime);
|
|
meshContainerPosition = meshContainer.position;
|
|
meshContainer.rotation = Quaternion.Lerp(meshContainer.rotation, Quaternion.Euler(meshContainerServerRotation), 9f * Time.deltaTime);
|
|
}
|
|
if (overrideAnimation <= 0f && stunNormalizedTimer <= 0f)
|
|
{
|
|
if (overrideAnimationWeight > 0.05f)
|
|
{
|
|
overrideAnimationWeight = Mathf.Lerp(overrideAnimationWeight, 0f, 20f * Time.deltaTime);
|
|
}
|
|
else
|
|
{
|
|
overrideAnimationWeight = 0f;
|
|
}
|
|
MoveLegsProcedurally();
|
|
}
|
|
else
|
|
{
|
|
overrideAnimation -= Time.deltaTime;
|
|
overrideAnimationWeight = Mathf.Lerp(overrideAnimationWeight, 1f, 20f * Time.deltaTime);
|
|
}
|
|
creatureAnimator.SetBool("stunned", stunNormalizedTimer > 0f);
|
|
creatureAnimator.SetLayerWeight(creatureAnimator.GetLayerIndex("MoveLegs"), overrideAnimationWeight);
|
|
}
|
|
|
|
public void MoveLegsProcedurally()
|
|
{
|
|
for (int i = 0; i < legTargets.Length; i++)
|
|
{
|
|
legTargets[i].position = Vector3.Lerp(legTargets[i].position, legPositions[i], 35f * Time.deltaTime);
|
|
}
|
|
bool flag = false;
|
|
for (int j = 0; j < legPositions.Length; j++)
|
|
{
|
|
if ((legPositions[j] - legDefaultPositions[j].position).sqrMagnitude > legDistances[j] * 1.4f)
|
|
{
|
|
legPositions[j] = legDefaultPositions[j].position;
|
|
flag = true;
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
footstepAudio.pitch = Random.Range(0.6f, 1.2f);
|
|
footstepAudio.PlayOneShot(footstepSFX[Random.Range(0, footstepSFX.Length)], Random.Range(0.1f, 1f));
|
|
WalkieTalkie.TransmitOneShotAudio(footstepAudio, footstepSFX[Random.Range(0, footstepSFX.Length)], Mathf.Clamp(Random.Range(-0.4f, 0.8f), 0f, 1f));
|
|
}
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void SyncMeshContainerPositionServerRpc(Vector3 syncPosition, Vector3 syncRotation)
|
|
{
|
|
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(3294703349u, serverRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in syncPosition);
|
|
bufferWriter.WriteValueSafe(in syncRotation);
|
|
__endSendServerRpc(ref bufferWriter, 3294703349u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
SyncMeshContainerPositionClientRpc(syncPosition, syncRotation);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void SyncMeshContainerPositionClientRpc(Vector3 syncPosition, Vector3 syncRotation)
|
|
{
|
|
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(3344227036u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in syncPosition);
|
|
bufferWriter.WriteValueSafe(in syncRotation);
|
|
__endSendClientRpc(ref bufferWriter, 3344227036u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && !base.IsOwner)
|
|
{
|
|
meshContainerServerPosition = syncPosition;
|
|
meshContainerServerRotation = syncRotation;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SyncMeshContainerPositionToClients()
|
|
{
|
|
if (Vector3.Distance(meshContainerServerPosition, base.transform.position) > 0.5f || Vector3.SignedAngle(meshContainerServerRotation, meshContainer.eulerAngles, Vector3.up) > 30f)
|
|
{
|
|
meshContainerServerPosition = meshContainer.position;
|
|
meshContainerServerRotation = meshContainer.eulerAngles;
|
|
if (base.IsServer)
|
|
{
|
|
SyncMeshContainerPositionClientRpc(meshContainerServerPosition, meshContainer.eulerAngles);
|
|
}
|
|
else
|
|
{
|
|
SyncMeshContainerPositionServerRpc(meshContainerServerPosition, meshContainer.eulerAngles);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool AttemptPlaceWebTrap()
|
|
{
|
|
for (int i = 0; i < webTraps.Count; i++)
|
|
{
|
|
if (Vector3.Distance(webTraps[i].transform.position, abdomen.position) < 0.6f)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
ray = new Ray(abdomen.position, Vector3.Scale(Random.onUnitSphere, new Vector3(1f, Random.Range(0.6f, 1f), 1f)));
|
|
if (Physics.Raycast(ray, out rayHit, 7f, StartOfRound.Instance.collidersAndRoomMask))
|
|
{
|
|
if (rayHit.distance < 1.5f)
|
|
{
|
|
return false;
|
|
}
|
|
Vector3 point = rayHit.point;
|
|
if (Physics.Raycast(abdomen.position, Vector3.down, out rayHit, 10f, StartOfRound.Instance.collidersAndRoomMask))
|
|
{
|
|
Vector3 point2 = rayHit.point;
|
|
SpawnWebTrapServerRpc(point2, point);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
[ServerRpc]
|
|
public void SpawnWebTrapServerRpc(Vector3 startPosition, Vector3 endPosition)
|
|
{
|
|
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(3159704048u, serverRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in startPosition);
|
|
bufferWriter.WriteValueSafe(in endPosition);
|
|
__endSendServerRpc(ref bufferWriter, 3159704048u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
SpawnWebTrapClientRpc(startPosition, endPosition);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void SpawnWebTrapClientRpc(Vector3 startPosition, Vector3 endPosition)
|
|
{
|
|
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(2600337163u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in startPosition);
|
|
bufferWriter.WriteValueSafe(in endPosition);
|
|
__endSendClientRpc(ref bufferWriter, 2600337163u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
GameObject obj = Object.Instantiate(webTrapPrefab, startPosition, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
|
|
obj.transform.LookAt(endPosition);
|
|
SandSpiderWebTrap componentInChildren = obj.GetComponentInChildren<SandSpiderWebTrap>();
|
|
webTraps.Add(componentInChildren);
|
|
componentInChildren.trapID = webTraps.Count - 1;
|
|
componentInChildren.mainScript = this;
|
|
componentInChildren.zScale = Vector3.Distance(startPosition, endPosition) / 4f;
|
|
}
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void PlayerTripWebServerRpc(int trapID, int playerNum)
|
|
{
|
|
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(2685725483u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, trapID);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerNum);
|
|
__endSendServerRpc(ref bufferWriter, 2685725483u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
PlayerTripWebClientRpc(trapID, playerNum);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void PlayerTripWebClientRpc(int trapID, int playerNum)
|
|
{
|
|
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(1467254034u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, trapID);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerNum);
|
|
__endSendClientRpc(ref bufferWriter, 1467254034u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost))
|
|
{
|
|
return;
|
|
}
|
|
PlayerControllerB playerControllerB = StartOfRound.Instance.allPlayerScripts[playerNum];
|
|
if (webTraps.Count - 1 >= trapID && playerControllerB.isPlayerControlled)
|
|
{
|
|
webTraps[trapID].webAudio.Play();
|
|
webTraps[trapID].webAudio.PlayOneShot(hitWebSFX);
|
|
if (webTraps[trapID].currentTrappedPlayer != null)
|
|
{
|
|
webTraps[trapID].currentTrappedPlayer = playerControllerB;
|
|
}
|
|
if (base.IsOwner)
|
|
{
|
|
TriggerChaseWithPlayer(playerControllerB);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ChasePlayer(PlayerControllerB player)
|
|
{
|
|
if (base.IsOwner && PlayerIsTargetable(player))
|
|
{
|
|
TriggerChaseWithPlayer(player);
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void BreakWebServerRpc(int trapID, int playerWhoHit)
|
|
{
|
|
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(327820463u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, trapID);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerWhoHit);
|
|
__endSendServerRpc(ref bufferWriter, 327820463u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
Vector3 position = webTraps[trapID].centerOfWeb.position;
|
|
BreakWebClientRpc(position, trapID);
|
|
ChasePlayer(StartOfRound.Instance.allPlayerScripts[playerWhoHit]);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void BreakWebClientRpc(Vector3 webPosition, int trapID)
|
|
{
|
|
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(3975888531u, clientRpcParams, RpcDelivery.Reliable);
|
|
bufferWriter.WriteValueSafe(in webPosition);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, trapID);
|
|
__endSendClientRpc(ref bufferWriter, 3975888531u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
AudioSource.PlayClipAtPoint(breakWebSFX, webPosition);
|
|
RemoveWeb(trapID);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RemoveWeb(int trapID)
|
|
{
|
|
if (webTraps[trapID].currentTrappedPlayer != null)
|
|
{
|
|
if (webTraps[trapID].currentTrappedPlayer == GameNetworkManager.Instance.localPlayerController)
|
|
{
|
|
webTraps[trapID].currentTrappedPlayer.isMovementHindered--;
|
|
webTraps[trapID].currentTrappedPlayer.hinderedMultiplier *= 0.5f;
|
|
}
|
|
webTraps[trapID].currentTrappedPlayer = null;
|
|
}
|
|
Object.Destroy(webTraps[trapID].gameObject.transform.parent.gameObject);
|
|
for (int i = 0; i < webTraps.Count; i++)
|
|
{
|
|
if (i > trapID)
|
|
{
|
|
webTraps[i].trapID--;
|
|
}
|
|
}
|
|
webTraps.RemoveAt(trapID);
|
|
}
|
|
|
|
public void TriggerChaseWithPlayer(PlayerControllerB playerScript)
|
|
{
|
|
if ((currentBehaviourStateIndex != 2 || watchFromDistance) && (currentBehaviourStateIndex != 1 || !(currentlyHeldBody != null) || !spooledPlayerBody) && !PathIsIntersectedByLineOfSight(playerScript.transform.position, calculatePathDistance: false, avoidLineOfSight: false) && (Vector3.Distance(playerScript.transform.position, homeNode.position) < 25f || Vector3.Distance(playerScript.transform.position, meshContainer.position) < 15f))
|
|
{
|
|
watchFromDistance = false;
|
|
targetPlayer = playerScript;
|
|
chaseTimer = 12.5f;
|
|
SwitchToBehaviourState(2);
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void PlayerLeaveWebServerRpc(int trapID, int playerNum)
|
|
{
|
|
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(4039894120u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, trapID);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerNum);
|
|
__endSendServerRpc(ref bufferWriter, 4039894120u, serverRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
PlayerLeaveWebClientRpc(trapID, playerNum);
|
|
}
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void PlayerLeaveWebClientRpc(int trapID, int playerNum)
|
|
{
|
|
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(902229680u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, trapID);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerNum);
|
|
__endSendClientRpc(ref bufferWriter, 902229680u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost) && webTraps[trapID].currentTrappedPlayer == StartOfRound.Instance.allPlayerScripts[playerNum])
|
|
{
|
|
webTraps[trapID].currentTrappedPlayer = null;
|
|
webTraps[trapID].webAudio.Stop();
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void OnCollideWithPlayer(Collider other)
|
|
{
|
|
base.OnCollideWithPlayer(other);
|
|
if (!isEnemyDead && !onWall)
|
|
{
|
|
PlayerControllerB playerControllerB = MeetsStandardPlayerCollisionConditions(other, spoolingPlayerBody);
|
|
if (playerControllerB != null && timeSinceHittingPlayer > 1f)
|
|
{
|
|
timeSinceHittingPlayer = 0f;
|
|
playerControllerB.DamagePlayer(90, hasDamageSFX: true, callRPC: true, CauseOfDeath.Mauling);
|
|
HitPlayerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void HitEnemy(int force = 1, PlayerControllerB playerWhoHit = null, bool playHitSFX = false)
|
|
{
|
|
base.HitEnemy(force, playerWhoHit);
|
|
if (!isEnemyDead)
|
|
{
|
|
creatureSFX.PlayOneShot(hitSpiderSFX, 1f);
|
|
WalkieTalkie.TransmitOneShotAudio(creatureSFX, hitSpiderSFX);
|
|
health--;
|
|
if (health <= 0)
|
|
{
|
|
KillEnemyOnOwnerClient();
|
|
}
|
|
else if (base.IsOwner)
|
|
{
|
|
TriggerChaseWithPlayer(playerWhoHit);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void KillEnemy(bool destroy = false)
|
|
{
|
|
base.KillEnemy(destroy);
|
|
CancelSpoolingBody();
|
|
overrideAnimation = 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(1418960684u, serverRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendServerRpc(ref bufferWriter, 1418960684u, 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)
|
|
{
|
|
if (__rpc_exec_stage != __RpcExecStage.Client && (networkManager.IsServer || networkManager.IsHost))
|
|
{
|
|
ClientRpcParams clientRpcParams = default(ClientRpcParams);
|
|
FastBufferWriter bufferWriter = __beginSendClientRpc(2819158268u, clientRpcParams, RpcDelivery.Reliable);
|
|
BytePacker.WriteValueBitPacked(bufferWriter, playerId);
|
|
__endSendClientRpc(ref bufferWriter, 2819158268u, clientRpcParams, RpcDelivery.Reliable);
|
|
}
|
|
if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
|
|
{
|
|
creatureAnimator.SetTrigger("attack");
|
|
overrideAnimation = 0.8f;
|
|
creatureSFX.PlayOneShot(attackSFX);
|
|
Debug.Log("Playing attack audio");
|
|
WalkieTalkie.TransmitOneShotAudio(creatureSFX, attackSFX);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void __initializeVariables()
|
|
{
|
|
base.__initializeVariables();
|
|
}
|
|
|
|
[RuntimeInitializeOnLoadMethod]
|
|
internal static void InitializeRPCS_SandSpiderAI()
|
|
{
|
|
NetworkManager.__rpc_func_table.Add(224635274u, __rpc_handler_224635274);
|
|
NetworkManager.__rpc_func_table.Add(2894295549u, __rpc_handler_2894295549);
|
|
NetworkManager.__rpc_func_table.Add(1372568795u, __rpc_handler_1372568795);
|
|
NetworkManager.__rpc_func_table.Add(180633541u, __rpc_handler_180633541);
|
|
NetworkManager.__rpc_func_table.Add(196846835u, __rpc_handler_196846835);
|
|
NetworkManager.__rpc_func_table.Add(4242200834u, __rpc_handler_4242200834);
|
|
NetworkManager.__rpc_func_table.Add(3294703349u, __rpc_handler_3294703349);
|
|
NetworkManager.__rpc_func_table.Add(3344227036u, __rpc_handler_3344227036);
|
|
NetworkManager.__rpc_func_table.Add(3159704048u, __rpc_handler_3159704048);
|
|
NetworkManager.__rpc_func_table.Add(2600337163u, __rpc_handler_2600337163);
|
|
NetworkManager.__rpc_func_table.Add(2685725483u, __rpc_handler_2685725483);
|
|
NetworkManager.__rpc_func_table.Add(1467254034u, __rpc_handler_1467254034);
|
|
NetworkManager.__rpc_func_table.Add(327820463u, __rpc_handler_327820463);
|
|
NetworkManager.__rpc_func_table.Add(3975888531u, __rpc_handler_3975888531);
|
|
NetworkManager.__rpc_func_table.Add(4039894120u, __rpc_handler_4039894120);
|
|
NetworkManager.__rpc_func_table.Add(902229680u, __rpc_handler_902229680);
|
|
NetworkManager.__rpc_func_table.Add(1418960684u, __rpc_handler_1418960684);
|
|
NetworkManager.__rpc_func_table.Add(2819158268u, __rpc_handler_2819158268);
|
|
}
|
|
|
|
private static void __rpc_handler_224635274(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;
|
|
((SandSpiderAI)target).SpiderTurnBodyIntoWebServerRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2894295549(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((SandSpiderAI)target).SpiderTurnBodyIntoWebClientRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1372568795(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;
|
|
((SandSpiderAI)target).SpiderHangBodyServerRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_180633541(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((SandSpiderAI)target).SpiderHangBodyClientRpc();
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_196846835(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;
|
|
((SandSpiderAI)target).GrabBodyServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_4242200834(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;
|
|
((SandSpiderAI)target).GrabBodyClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3294703349(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 Vector3 value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((SandSpiderAI)target).SyncMeshContainerPositionServerRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3344227036(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
reader.ReadValueSafe(out Vector3 value);
|
|
reader.ReadValueSafe(out Vector3 value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((SandSpiderAI)target).SyncMeshContainerPositionClientRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3159704048(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 Vector3 value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((SandSpiderAI)target).SpawnWebTrapServerRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2600337163(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
reader.ReadValueSafe(out Vector3 value);
|
|
reader.ReadValueSafe(out Vector3 value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((SandSpiderAI)target).SpawnWebTrapClientRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2685725483(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value);
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((SandSpiderAI)target).PlayerTripWebServerRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1467254034(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value);
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((SandSpiderAI)target).PlayerTripWebClientRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_327820463(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value);
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((SandSpiderAI)target).BreakWebServerRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_3975888531(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
reader.ReadValueSafe(out Vector3 value);
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((SandSpiderAI)target).BreakWebClientRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_4039894120(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value);
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.Server;
|
|
((SandSpiderAI)target).PlayerLeaveWebServerRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_902229680(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
|
|
{
|
|
NetworkManager networkManager = target.NetworkManager;
|
|
if ((object)networkManager != null && networkManager.IsListening)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value);
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.Client;
|
|
((SandSpiderAI)target).PlayerLeaveWebClientRpc(value, value2);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_1418960684(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;
|
|
((SandSpiderAI)target).HitPlayerServerRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
private static void __rpc_handler_2819158268(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;
|
|
((SandSpiderAI)target).HitPlayerClientRpc(value);
|
|
target.__rpc_exec_stage = __RpcExecStage.None;
|
|
}
|
|
}
|
|
|
|
protected internal override string __getTypeName()
|
|
{
|
|
return "SandSpiderAI";
|
|
}
|
|
}
|