LethalCompany/Lethal Company/ExportedProject/Assets/Scripts/Assembly-CSharp/SandSpiderAI.cs
2023-12-22 18:30:10 -05:00

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";
}
}