LethalCompany/Lethal Company/ExportedProject/Assets/Scripts/Assembly-CSharp/PatcherTool.cs

using System;
using System.Collections;
using System.Linq;
using DigitalRuby.ThunderAndLightning;
using GameNetcodeStuff;
using Unity.Netcode;
using UnityEngine;

public class PatcherTool : GrabbableObject
{
	[Space(15f)]
	public float gunAnomalyDamage = 1f;

	public bool isShocking;

	public IShockableWithGun shockedTargetScript;

	[Space(15f)]
	public Light flashlightBulb;

	public Light flashlightBulbGlow;

	public AudioSource mainAudio;

	public AudioSource shockAudio;

	public AudioSource gunAudio;

	public AudioClip[] activateClips;

	public AudioClip[] beginShockClips;

	public AudioClip[] overheatClips;

	public AudioClip[] finishShockClips;

	public AudioClip outOfBatteriesClip;

	public AudioClip detectAnomaly;

	public AudioClip scanAnomaly;

	public Material bulbLight;

	public Material bulbDark;

	public Animator effectAnimator;

	public Animator gunAnimator;

	public ParticleSystem overheatParticle;

	private Coroutine scanGunCoroutine;

	private Coroutine beginShockCoroutine;

	public Transform aimDirection;

	private int anomalyMask = 524296;

	private int roomMask = 256;

	private RaycastHit hit;

	private Ray ray;

	public GameObject lightningObject;

	public Transform lightningDest;

	public Transform lightningBend1;

	public Transform lightningBend2;

	private Vector3 shockVectorMidpoint;

	[Header("Shock difficulty variables")]
	public float bendStrengthCap = 3f;

	public float endStrengthCap = 4.25f;

	private float currentEndStrengthCap;

	public float bendChangeSpeedMultiplier = 10f;

	public float endChangeSpeedMultiplier = 17f;

	private float currentEndChangeSpeedMultiplier;

	public float pullStrength;

	public float endPullStrength = 4.25f;

	private float currentEndPullStrength;

	public float maxChangePerFrame = 0.15f;

	public float endChangePerFrame = 2.5f;

	private float currentEndChangePerFrame;

	[HideInInspector]
	public float bendMultiplier;

	[HideInInspector]
	private float bendRandomizerShift;

	[HideInInspector]
	private Vector3 bendVector;

	public float gunOverheat;

	[HideInInspector]
	private bool sentStopShockingRPC;

	[HideInInspector]
	private bool wasShockingPreviousFrame;

	private LightningSplineScript lightningScript;

	private System.Random gunRandom;

	private int timesUsed;

	private bool lightningVisible;

	private float minigameChecksInterval;

	private float timeSpentShocking;

	private float makeAudibleNoiseTimer;

	public static int finishedShockMinigame;

	private RaycastHit[] raycastEnemies;

	private bool isScanning;

	private float currentDifficultyMultiplier;

	private PlayerControllerB previousPlayerHeldBy;

	public override void Start()
	{
		base.Start();
		raycastEnemies = new RaycastHit[12];
	}

	public override void OnDestroy()
	{
		base.OnDestroy();
		if (lightningDest != null && lightningDest.gameObject != null)
		{
			UnityEngine.Object.Destroy(lightningDest.gameObject);
		}
	}

	public override void ItemActivate(bool used, bool buttonDown = true)
	{
		base.ItemActivate(used, buttonDown);
		gunOverheat = 0f;
		if (playerHeldBy == null)
		{
			return;
		}
		if (scanGunCoroutine != null)
		{
			StopCoroutine(scanGunCoroutine);
			scanGunCoroutine = null;
		}
		if (beginShockCoroutine != null)
		{
			StopCoroutine(beginShockCoroutine);
			beginShockCoroutine = null;
		}
		if (isShocking)
		{
			Debug.Log("Stop shocking gun");
			StopShockingAnomalyOnClient(failed: true);
		}
		else if (isScanning)
		{
			SwitchFlashlight(on: false);
			gunAudio.Stop();
			currentUseCooldown = 0.5f;
			if (scanGunCoroutine != null)
			{
				StopCoroutine(scanGunCoroutine);
				scanGunCoroutine = null;
			}
			isScanning = false;
		}
		else
		{
			Debug.Log("Start scanning gun");
			isScanning = true;
			sentStopShockingRPC = false;
			scanGunCoroutine = StartCoroutine(ScanGun());
			currentUseCooldown = 0.5f;
			Debug.Log("Use patcher tool");
			PlayRandomAudio(mainAudio, activateClips);
			SwitchFlashlight(on: true);
		}
	}

	private void PlayRandomAudio(AudioSource audioSource, AudioClip[] audioClips)
	{
		if (audioClips.Length != 0)
		{
			audioSource.PlayOneShot(audioClips[UnityEngine.Random.Range(0, audioClips.Length)]);
		}
	}

	private bool GunMeetsConditionsToShock(PlayerControllerB playerUsingGun, Vector3 targetPosition, float maxAngle = 80f)
	{
		Debug.Log($"Target position: {targetPosition}");
		Vector3 position = playerUsingGun.gameplayCamera.transform.position;
		Vector3 vector = position;
		vector.y = targetPosition.y;
		if (Vector3.Angle(playerUsingGun.transform.forward, targetPosition - position) > maxAngle)
		{
			return false;
		}
		if (gunOverheat > 2f || Vector3.Distance(position, targetPosition) < 0.7f || Vector3.Distance(position, targetPosition) > 13f || Physics.Linecast(position, targetPosition, StartOfRound.Instance.collidersAndRoomMask, QueryTriggerInteraction.Ignore))
		{
			if (Physics.Linecast(position, targetPosition, out var hitInfo, StartOfRound.Instance.collidersAndRoomMask, QueryTriggerInteraction.Ignore))
			{
				Debug.Log(hitInfo.transform.name);
				Debug.Log(hitInfo.transform.gameObject.name);
				Debug.DrawLine(position, targetPosition, Color.green, 25f);
			}
			Debug.Log($"Gun not meeting conditions to zap; {gunOverheat > 2f}; {Vector3.Distance(position, targetPosition) < 0.7f}; {Physics.Linecast(position, targetPosition, StartOfRound.Instance.collidersAndRoomMask, QueryTriggerInteraction.Ignore)}");
			return false;
		}
		return true;
	}

	public override void LateUpdate()
	{
		base.LateUpdate();
		if (!lightningVisible)
		{
			return;
		}
		if (isShocking && shockedTargetScript != null && playerHeldBy != null && !playerHeldBy.isPlayerDead && !insertedBattery.empty)
		{
			timeSpentShocking += Time.deltaTime / 8f;
			if (makeAudibleNoiseTimer <= 0f)
			{
				makeAudibleNoiseTimer = 0.8f;
				RoundManager.Instance.PlayAudibleNoise(base.transform.position, 20f, 0.92f, 0, isInShipRoom && StartOfRound.Instance.hangarDoorsClosed, 11);
			}
			else
			{
				makeAudibleNoiseTimer -= Time.deltaTime;
			}
			Vector3 shockablePosition = shockedTargetScript.GetShockablePosition();
			lightningDest.position = shockablePosition + new Vector3(UnityEngine.Random.Range(-0.3f, 0.3f), UnityEngine.Random.Range(-0.3f, 0.3f), UnityEngine.Random.Range(-0.3f, 0.3f));
			shockVectorMidpoint = Vector3.Normalize(shockedTargetScript.GetShockableTransform().position - aimDirection.position);
			bendVector = playerHeldBy.transform.right * bendMultiplier;
			lightningBend1.position = aimDirection.position + 0.3f * shockVectorMidpoint + bendVector;
			lightningBend2.position = aimDirection.position + 0.6f * shockVectorMidpoint + bendVector;
			if (bendRandomizerShift < 0f)
			{
				float num = Mathf.Clamp(RandomFloatInRange(gunRandom, -1f + Mathf.Round(bendRandomizerShift), 1f) * (bendChangeSpeedMultiplier * Time.deltaTime), 0f - maxChangePerFrame, maxChangePerFrame);
				bendMultiplier = Mathf.Clamp(bendMultiplier + num, 0f - bendStrengthCap, bendStrengthCap);
			}
			else
			{
				float num2 = Mathf.Clamp(RandomFloatInRange(gunRandom, -1f, 1f + Mathf.Round(bendRandomizerShift)) * (bendChangeSpeedMultiplier * Time.deltaTime), 0f - maxChangePerFrame, maxChangePerFrame);
				bendMultiplier = Mathf.Clamp(bendMultiplier + num2, 0f - bendStrengthCap, bendStrengthCap);
			}
			ShiftBendRandomizer();
			AdjustDifficultyValues();
			if (!base.IsOwner)
			{
				return;
			}
			wasShockingPreviousFrame = true;
			float num3 = Mathf.Abs(Mathf.Clamp(bendMultiplier * 0.5f, -0.5f, 0.5f) - playerHeldBy.shockMinigamePullPosition * 2f);
			playerHeldBy.turnCompass.Rotate(Vector3.up * 100f * bendMultiplier * pullStrength * Time.deltaTime);
			RoundManager.Instance.tempTransform.eulerAngles = new Vector3(0f, playerHeldBy.gameplayCamera.transform.eulerAngles.y, playerHeldBy.gameplayCamera.transform.eulerAngles.z);
			if (Vector3.Angle(RoundManager.Instance.tempTransform.forward, new Vector3(lightningDest.position.x, playerHeldBy.gameplayCamera.transform.position.y, lightningDest.position.z) - playerHeldBy.gameplayCamera.transform.position) > 90f)
			{
				gunOverheat += Time.deltaTime * 10f;
			}
			if (bendMultiplier < -0.3f)
			{
				if (playerHeldBy.shockMinigamePullPosition < 0f)
				{
					gunOverheat = Mathf.Clamp(gunOverheat - Time.deltaTime * 3f, 0f, 10f);
				}
				else
				{
					gunOverheat += Time.deltaTime * (num3 * 2f);
				}
				HUDManager.Instance.SetTutorialArrow(2);
			}
			else if (bendMultiplier > 0.3f)
			{
				if (playerHeldBy.shockMinigamePullPosition > 0f)
				{
					gunOverheat = Mathf.Clamp(gunOverheat - Time.deltaTime * 3f, 0f, 10f);
				}
				else
				{
					gunOverheat += Time.deltaTime * (num3 * 2f);
				}
				HUDManager.Instance.SetTutorialArrow(1);
			}
			else
			{
				HUDManager.Instance.SetTutorialArrow(0);
			}
			minigameChecksInterval -= Time.deltaTime;
			if (minigameChecksInterval <= 0f)
			{
				minigameChecksInterval = 0.15f;
				if (shockedTargetScript == null || !GunMeetsConditionsToShock(playerHeldBy, shockablePosition))
				{
					StopShockingAnomalyOnClient(failed: true);
					return;
				}
			}
			if (gunOverheat > 0.75f)
			{
				gunAudio.volume = Mathf.Lerp(gunAudio.volume, 1f, 13f * Time.deltaTime);
				gunAnimator.SetBool("Overheating", value: true);
			}
			else
			{
				gunAudio.volume = Mathf.Lerp(gunAudio.volume, 0f, 7f * Time.deltaTime);
				gunAnimator.SetBool("Overheating", value: false);
			}
		}
		else if (wasShockingPreviousFrame)
		{
			wasShockingPreviousFrame = false;
			timeSpentShocking = 0f;
			if (base.IsOwner)
			{
				StopShockingAnomalyOnClient();
			}
		}
	}

	private void AdjustDifficultyValues()
	{
		bendStrengthCap = Mathf.Lerp(0.4f, currentEndStrengthCap, timeSpentShocking * currentDifficultyMultiplier);
		bendChangeSpeedMultiplier = Mathf.Lerp(3.5f, currentEndChangeSpeedMultiplier, timeSpentShocking * currentDifficultyMultiplier);
		pullStrength = Mathf.Lerp(0.4f, currentEndPullStrength, timeSpentShocking * currentDifficultyMultiplier);
		maxChangePerFrame = Mathf.Lerp(0.13f, currentEndChangePerFrame, timeSpentShocking * currentDifficultyMultiplier);
		lightningScript.Forkedness = Mathf.Lerp(0.11f, 0.45f, timeSpentShocking * currentDifficultyMultiplier);
		lightningScript.ForkLengthMultiplier = Mathf.Lerp(0.11f, 1.1f, timeSpentShocking * currentDifficultyMultiplier);
		lightningScript.ForkLengthVariance = Mathf.Lerp(0.08f, 4f, timeSpentShocking * currentDifficultyMultiplier);
		shockAudio.volume = Mathf.Lerp(0.1f, 1f, timeSpentShocking * currentDifficultyMultiplier);
	}

	private void InitialDifficultyValues()
	{
		currentEndStrengthCap = SetCurrentDifficultyValue(endStrengthCap, 1.4f);
		currentEndChangeSpeedMultiplier = SetCurrentDifficultyValue(endChangeSpeedMultiplier, 7f);
		currentEndPullStrength = SetCurrentDifficultyValue(endPullStrength, 0.4f);
		currentEndChangePerFrame = SetCurrentDifficultyValue(endChangePerFrame, 0.12f);
	}

	private float SetCurrentDifficultyValue(float max, float min)
	{
		return shockedTargetScript.GetDifficultyMultiplier() * (max - min) + min;
	}

	public void ShiftBendRandomizer()
	{
		if (bendMultiplier < 0f)
		{
			if (bendMultiplier < -0.5f)
			{
				bendRandomizerShift += 1f * Time.deltaTime;
			}
			else
			{
				bendRandomizerShift -= 1f * Time.deltaTime;
			}
		}
		else if (bendMultiplier > 0.5f)
		{
			bendRandomizerShift -= 1f * Time.deltaTime;
		}
		else
		{
			bendRandomizerShift += 1f * Time.deltaTime;
		}
	}

	private void OnEnable()
	{
		StartCoroutine(waitForStartOfRoundInstance());
	}

	private IEnumerator waitForStartOfRoundInstance()
	{
		yield return new WaitUntil(() => StartOfRound.Instance != null && StartOfRound.Instance.CameraSwitchEvent != null && StartOfRound.Instance.activeCamera != null);
		StartOfRound.Instance.CameraSwitchEvent.AddListener(OnSwitchCamera);
		if (StartOfRound.Instance != null && StartOfRound.Instance.activeCamera != null)
		{
			lightningScript = lightningObject.GetComponent<LightningSplineScript>();
			lightningScript.Camera = StartOfRound.Instance.activeCamera;
		}
	}

	private void OnDisable()
	{
		StartOfRound.Instance.CameraSwitchEvent.RemoveListener(OnSwitchCamera);
	}

	private void OnSwitchCamera()
	{
		lightningObject.GetComponent<LightningSplineScript>().Camera = StartOfRound.Instance.activeCamera;
	}

	private IEnumerator ScanGun()
	{
		effectAnimator.SetTrigger("Scan");
		gunAudio.PlayOneShot(scanAnomaly);
		lightningScript = lightningObject.GetComponent<LightningSplineScript>();
		lightningDest.SetParent(null);
		lightningBend1.SetParent(null);
		lightningBend2.SetParent(null);
		Debug.Log("Scan A");
		for (int i = 0; i < 12; i++)
		{
			if (base.IsOwner)
			{
				Debug.Log("Scan B");
				if (isPocketed)
				{
					yield break;
				}
				ray = new Ray(playerHeldBy.gameplayCamera.transform.position - playerHeldBy.gameplayCamera.transform.forward * 3f, playerHeldBy.gameplayCamera.transform.forward);
				Debug.DrawRay(playerHeldBy.gameplayCamera.transform.position - playerHeldBy.gameplayCamera.transform.forward * 3f, playerHeldBy.gameplayCamera.transform.forward * 6f, Color.red, 5f);
				int num = Physics.SphereCastNonAlloc(ray, 5f, raycastEnemies, 5f, anomalyMask, QueryTriggerInteraction.Collide);
				raycastEnemies = raycastEnemies.OrderBy((RaycastHit x) => x.distance).ToArray();
				for (int j = 0; j < num; j++)
				{
					if (j >= raycastEnemies.Length)
					{
						continue;
					}
					hit = raycastEnemies[j];
					if (!(hit.transform == null) && hit.transform.gameObject.TryGetComponent<IShockableWithGun>(out var component) && component.CanBeShocked())
					{
						Vector3 shockablePosition = component.GetShockablePosition();
						Debug.Log("Got shockable transform name : " + component.GetShockableTransform().gameObject.name);
						if (GunMeetsConditionsToShock(playerHeldBy, shockablePosition, 60f))
						{
							gunAudio.Stop();
							BeginShockingAnomalyOnClient(component);
							yield break;
						}
					}
				}
			}
			yield return new WaitForSeconds(0.125f);
		}
		Debug.Log("Zap gun light off!!!");
		SwitchFlashlight(on: false);
		isScanning = false;
	}

	public void BeginShockingAnomalyOnClient(IShockableWithGun shockableScript)
	{
		timesUsed++;
		sentStopShockingRPC = false;
		gunRandom = new System.Random(playerHeldBy.playersManager.randomMapSeed + timesUsed);
		gunOverheat = 0f;
		shockedTargetScript = shockableScript;
		currentDifficultyMultiplier = shockableScript.GetDifficultyMultiplier();
		InitialDifficultyValues();
		bendMultiplier = 0f;
		bendRandomizerShift = 0f;
		if (beginShockCoroutine != null)
		{
			StopCoroutine(beginShockCoroutine);
		}
		beginShockCoroutine = StartCoroutine(beginShockGame(shockableScript));
	}

	private IEnumerator beginShockGame(IShockableWithGun shockableScript)
	{
		if (shockableScript == null || shockableScript.GetNetworkObject() == null)
		{
			Debug.LogError($"Zap gun: The shockable script was null when starting the minigame! ; {shockableScript == null}; {shockableScript.GetNetworkObject() == null}");
			isScanning = false;
			yield break;
		}
		effectAnimator.SetTrigger("Shock");
		gunAudio.PlayOneShot(detectAnomaly);
		isShocking = true;
		isScanning = false;
		playerHeldBy.inShockingMinigame = true;
		Transform shockableTransform = shockableScript.GetShockableTransform();
		playerHeldBy.shockingTarget = shockableTransform;
		playerHeldBy.isCrouching = false;
		playerHeldBy.playerBodyAnimator.SetBool("crouching", value: false);
		playerHeldBy.turnCompass.LookAt(shockableTransform);
		Vector3 zero = Vector3.zero;
		zero.y = playerHeldBy.turnCompass.localEulerAngles.y;
		playerHeldBy.turnCompass.localEulerAngles = zero;
		yield return new WaitForSeconds(0.55f);
		StartShockAudios();
		isBeingUsed = true;
		shockedTargetScript.ShockWithGun(playerHeldBy);
		playerHeldBy.inSpecialInteractAnimation = true;
		playerHeldBy.playerBodyAnimator.SetBool("HoldPatcherTool", value: true);
		SwitchFlashlight(on: false);
		gunAnimator.SetTrigger("Shock");
		lightningObject.SetActive(value: true);
		lightningVisible = true;
		ShockPatcherToolServerRpc(shockableScript.GetNetworkObject());
	}

	private void StartShockAudios()
	{
		PlayRandomAudio(mainAudio, beginShockClips);
		gunAudio.Play();
		mainAudio.Play();
		mainAudio.volume = 1f;
		shockAudio.Play();
		shockAudio.volume = 0f;
	}

	public void StopShockingAnomalyOnClient(bool failed = false)
	{
		if (scanGunCoroutine != null)
		{
			StopCoroutine(scanGunCoroutine);
			scanGunCoroutine = null;
		}
		timeSpentShocking = 0f;
		wasShockingPreviousFrame = false;
		lightningVisible = false;
		lightningObject.SetActive(value: false);
		isBeingUsed = false;
		SwitchFlashlight(on: false);
		gunAnimator.SetBool("Overheating", value: false);
		gunAnimator.SetBool("Shock", value: false);
		if (shockedTargetScript != null)
		{
			shockedTargetScript.StopShockingWithGun();
		}
		gunOverheat = 0f;
		gunAudio.Stop();
		gunAudio.volume = 1f;
		mainAudio.Stop();
		shockAudio.Stop();
		if (base.IsOwner && playerHeldBy != null && !sentStopShockingRPC)
		{
			HUDManager.Instance.SetTutorialArrow(0);
			sentStopShockingRPC = true;
			StopShockingServerRpc();
			playerHeldBy.playerBodyAnimator.SetTrigger("Overheat");
			Vector3 localEulerAngles = playerHeldBy.thisPlayerBody.localEulerAngles;
			localEulerAngles.x = 0f;
			localEulerAngles.z = 0f;
			playerHeldBy.thisPlayerBody.localEulerAngles = localEulerAngles;
		}
		if (failed)
		{
			PlayRandomAudio(gunAudio, overheatClips);
			overheatParticle.Play();
			currentUseCooldown = 5f;
			effectAnimator.SetTrigger("FailGame");
			if (timeSpentShocking > 0.75f)
			{
				SetFinishedShockMinigameTutorial();
			}
		}
		else
		{
			currentUseCooldown = 0.25f;
			effectAnimator.SetTrigger("FinishGame");
			if (base.IsOwner)
			{
				playerHeldBy.playerBodyAnimator.SetTrigger("Overheat");
			}
			SetFinishedShockMinigameTutorial();
		}
		playerHeldBy.PlayQuickSpecialAnimation(3f);
		PlayRandomAudio(mainAudio, finishShockClips);
		if (base.IsOwner)
		{
			if (playerHeldBy != null)
			{
				playerHeldBy.playerBodyAnimator.SetBool("HoldPatcherTool", value: false);
				StartCoroutine(stopShocking(playerHeldBy));
			}
			else
			{
				Debug.LogError("Error: playerHeldBy is null for owner of zap gun when stopping shock, in client rpc");
			}
			return;
		}
		isShocking = false;
		if (playerHeldBy != null)
		{
			playerHeldBy.inSpecialInteractAnimation = false;
			playerHeldBy.inShockingMinigame = false;
		}
	}

	private void SetFinishedShockMinigameTutorial()
	{
		if (HUDManager.Instance.setTutorialArrow)
		{
			finishedShockMinigame++;
			if (finishedShockMinigame >= 2)
			{
				HUDManager.Instance.setTutorialArrow = false;
			}
		}
	}

	private IEnumerator stopShocking(PlayerControllerB playerController)
	{
		yield return new WaitForSeconds(0.4f);
		isShocking = false;
		playerController.inSpecialInteractAnimation = false;
		playerController.inShockingMinigame = false;
	}

	[ServerRpc(RequireOwnership = false)]
	public void ShockPatcherToolServerRpc(NetworkObjectReference netObject)
	{
		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(2303694898u, serverRpcParams, RpcDelivery.Reliable);
				bufferWriter.WriteValueSafe(in netObject, default(FastBufferWriter.ForNetworkSerializable));
				__endSendServerRpc(ref bufferWriter, 2303694898u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				ShockPatcherToolClientRpc(netObject);
				Debug.Log("Patcher tool server rpc received");
			}
		}
	}

	[ClientRpc]
	public void ShockPatcherToolClientRpc(NetworkObjectReference netObject)
	{
		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(4275427213u, clientRpcParams, RpcDelivery.Reliable);
			bufferWriter.WriteValueSafe(in netObject, default(FastBufferWriter.ForNetworkSerializable));
			__endSendClientRpc(ref bufferWriter, 4275427213u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage != __RpcExecStage.Client || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		Debug.Log("Shock patcher tool client rpc received");
		if (base.IsOwner || previousPlayerHeldBy == GameNetworkManager.Instance.localPlayerController)
		{
			return;
		}
		Debug.Log("Running shock patcher tool function");
		timesUsed++;
		gunRandom = new System.Random(playerHeldBy.playersManager.randomMapSeed + timesUsed);
		if (scanGunCoroutine != null)
		{
			StopCoroutine(scanGunCoroutine);
		}
		if (netObject.TryGet(out var networkObject))
		{
			isShocking = true;
			isScanning = false;
			shockedTargetScript = networkObject.gameObject.GetComponentInChildren<IShockableWithGun>();
			if (shockedTargetScript != null)
			{
				shockedTargetScript.ShockWithGun(playerHeldBy);
				StartShockAudios();
				lightningObject.SetActive(value: true);
				SwitchFlashlight(on: false);
				gunAnimator.SetTrigger("UseGun");
				effectAnimator.SetTrigger("Shock");
				lightningVisible = true;
				playerHeldBy.inShockingMinigame = true;
				playerHeldBy.inSpecialInteractAnimation = true;
			}
			else
			{
				Debug.LogError("Zap gun: Unable to get IShockableWithGun interface from networkobject on client rpc!");
			}
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void StopShockingServerRpc()
	{
		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(3351579778u, serverRpcParams, RpcDelivery.Reliable);
				__endSendServerRpc(ref bufferWriter, 3351579778u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				StopShockingClientRpc();
			}
		}
	}

	[ClientRpc]
	public void StopShockingClientRpc()
	{
		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(75402723u, clientRpcParams, RpcDelivery.Reliable);
			__endSendClientRpc(ref bufferWriter, 75402723u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
		{
			Debug.Log("Running client rpc stopping shock");
			if (!(GameNetworkManager.Instance.localPlayerController == null) && !(NetworkManager.Singleton == null) && !base.IsOwner && !(previousPlayerHeldBy == GameNetworkManager.Instance.localPlayerController))
			{
				Debug.Log($"{base.IsOwner} ; {previousPlayerHeldBy}");
				StopShockingAnomalyOnClient();
			}
		}
	}

	public override void UseUpBatteries()
	{
		base.UseUpBatteries();
		SwitchFlashlight(on: false);
		gunAudio.PlayOneShot(outOfBatteriesClip, 1f);
	}

	public override void PocketItem()
	{
		isBeingUsed = false;
		if (playerHeldBy != null)
		{
			DisablePatcherGun();
		}
		else
		{
			Debug.Log("Could not find what player was holding this item");
		}
		base.PocketItem();
	}

	public override void DiscardItem()
	{
		DisablePatcherGun();
		base.DiscardItem();
	}

	private void DisablePatcherGun()
	{
		SwitchFlashlight(on: false);
		if (scanGunCoroutine != null)
		{
			StopCoroutine(scanGunCoroutine);
			scanGunCoroutine = null;
		}
		if (beginShockCoroutine != null)
		{
			StopCoroutine(beginShockCoroutine);
			beginShockCoroutine = null;
		}
		if (playerHeldBy != null && isShocking)
		{
			StopShockingAnomalyOnClient(failed: true);
		}
		isBeingUsed = false;
		wasShockingPreviousFrame = false;
	}

	public override void EquipItem()
	{
		base.EquipItem();
		if (playerHeldBy != null)
		{
			previousPlayerHeldBy = playerHeldBy;
		}
	}

	public void SwitchFlashlight(bool on)
	{
		flashlightBulb.enabled = on;
		flashlightBulbGlow.enabled = on;
	}

	private float RandomFloatInRange(System.Random rand, float min, float max)
	{
		return (float)(rand.NextDouble() * (double)(max - min) + (double)min);
	}

	protected override void __initializeVariables()
	{
		base.__initializeVariables();
	}

	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeRPCS_PatcherTool()
	{
		NetworkManager.__rpc_func_table.Add(2303694898u, __rpc_handler_2303694898);
		NetworkManager.__rpc_func_table.Add(4275427213u, __rpc_handler_4275427213);
		NetworkManager.__rpc_func_table.Add(3351579778u, __rpc_handler_3351579778);
		NetworkManager.__rpc_func_table.Add(75402723u, __rpc_handler_75402723);
	}

	private static void __rpc_handler_2303694898(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out NetworkObjectReference value, default(FastBufferWriter.ForNetworkSerializable));
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((PatcherTool)target).ShockPatcherToolServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_4275427213(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out NetworkObjectReference value, default(FastBufferWriter.ForNetworkSerializable));
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((PatcherTool)target).ShockPatcherToolClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_3351579778(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((PatcherTool)target).StopShockingServerRpc();
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_75402723(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((PatcherTool)target).StopShockingClientRpc();
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	protected internal override string __getTypeName()
	{
		return "PatcherTool";
	}
}