using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Rosay")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EchoholdAPI")]
[assembly: AssemblyTitle("EchoholdAPI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[DisallowMultipleComponent]
public class AirVentTrap : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <AutoOffCountdown>d__12 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public AirVentTrap <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <AutoOffCountdown>d__12(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(<>4__this.autoOffSeconds);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if ((!SemiFunc.IsMultiplayer() || SemiFunc.IsMasterClient()) && <>4__this.isEnabledNow)
				{
					<>4__this.BroadcastSetActive(enable: false);
				}
				<>4__this.autoOffRoutine = null;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[Header("Assign the empty that holds your effects")]
	[SerializeField]
	private GameObject effectsRoot;

	[Header("Start state / timing")]
	[SerializeField]
	private bool startsEnabled = false;

	[SerializeField]
	private float autoOffSeconds = 5f;

	[Header("Networking")]
	[SerializeField]
	private bool allowClientRequestToMaster = true;

	private bool isEnabledNow;

	private PhotonView pv;

	private Coroutine autoOffRoutine;

	private void Awake()
	{
		pv = ((Component)this).GetComponent<PhotonView>();
		if ((Object)(object)pv == (Object)null)
		{
			pv = ((Component)this).GetComponentInParent<PhotonView>();
		}
		Apply(startsEnabled);
	}

	private void OnDisable()
	{
		StopAutoOff();
	}

	private void Apply(bool enable)
	{
		isEnabledNow = enable;
		if ((Object)(object)effectsRoot != (Object)null)
		{
			effectsRoot.SetActive(enable);
		}
		if (!SemiFunc.IsMultiplayer() || SemiFunc.IsMasterClient())
		{
			if (enable)
			{
				RestartAutoOff();
			}
			else
			{
				StopAutoOff();
			}
		}
	}

	private void RestartAutoOff()
	{
		StopAutoOff();
		if (autoOffSeconds > 0f)
		{
			autoOffRoutine = ((MonoBehaviour)this).StartCoroutine(AutoOffCountdown());
		}
	}

	private void StopAutoOff()
	{
		if (autoOffRoutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(autoOffRoutine);
			autoOffRoutine = null;
		}
	}

	[IteratorStateMachine(typeof(<AutoOffCountdown>d__12))]
	private IEnumerator AutoOffCountdown()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <AutoOffCountdown>d__12(0)
		{
			<>4__this = this
		};
	}

	public void ToggleOnGrab()
	{
		bool flag = !isEnabledNow;
		if (SemiFunc.IsMultiplayer())
		{
			if (SemiFunc.IsMasterClient())
			{
				BroadcastSetActive(flag);
			}
			else if (allowClientRequestToMaster && (Object)(object)pv != (Object)null)
			{
				pv.RPC("RequestToggleRPC", (RpcTarget)2, Array.Empty<object>());
			}
		}
		else
		{
			SetActiveRPC(flag);
		}
	}

	[PunRPC]
	private void RequestToggleRPC()
	{
		if (SemiFunc.IsMasterClient())
		{
			BroadcastSetActive(!isEnabledNow);
		}
	}

	private void BroadcastSetActive(bool enable)
	{
		if ((Object)(object)pv != (Object)null && SemiFunc.IsMultiplayer())
		{
			pv.RPC("SetActiveRPC", (RpcTarget)0, new object[1] { enable });
		}
		else
		{
			SetActiveRPC(enable);
		}
	}

	[PunRPC]
	public void SetActiveRPC(bool enable)
	{
		Apply(enable);
	}

	public void EnableTrap()
	{
		ToggleTo(state: true);
	}

	public void DisableTrap()
	{
		ToggleTo(state: false);
	}

	private void ToggleTo(bool state)
	{
		if (SemiFunc.IsMultiplayer())
		{
			if (SemiFunc.IsMasterClient())
			{
				BroadcastSetActive(state);
			}
			else if (allowClientRequestToMaster && (Object)(object)pv != (Object)null)
			{
				pv.RPC("RequestToggleRPC", (RpcTarget)2, Array.Empty<object>());
			}
		}
		else
		{
			SetActiveRPC(state);
		}
	}
}
public class ButtonSlideDoor : MonoBehaviourPun
{
	[CompilerGenerated]
	private sealed class <SlideDoorCoroutine>d__29 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Vector3 targetPosition;

		public ButtonSlideDoor <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SlideDoorCoroutine>d__29(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.moving = true;
				if ((Object)(object)<>4__this.doorAudioSource != (Object)null && (Object)(object)<>4__this.doorMoveClip != (Object)null)
				{
					<>4__this.doorAudioSource.PlayOneShot(<>4__this.doorMoveClip);
				}
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (Vector3.Distance(<>4__this.door.position, targetPosition) > 0.01f)
			{
				<>4__this.door.position = Vector3.MoveTowards(<>4__this.door.position, targetPosition, <>4__this.moveSpeed * Time.deltaTime);
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			<>4__this.door.position = targetPosition;
			<>4__this.moving = false;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[Header("Door Settings")]
	public Transform door;

	public float moveDistance = 3f;

	public float moveSpeed = 2f;

	[Header("Audio Settings")]
	public AudioSource buttonAudioSource;

	public AudioClip buttonPressClip;

	public AudioSource doorAudioSource;

	public AudioClip doorMoveClip;

	[Header("Enemy Trigger Settings")]
	public bool useEnemyTrigger = false;

	public Collider triggerZone;

	private int enemiesInZone = 0;

	private Vector3 originalDoorPosition;

	private Vector3 openDoorPosition;

	private bool moving = false;

	private PhotonView photonView;

	private void Start()
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		photonView = ((Component)this).GetComponentInParent<PhotonView>();
		if ((Object)(object)door != (Object)null)
		{
			originalDoorPosition = door.position;
			openDoorPosition = originalDoorPosition + Vector3.up * moveDistance;
		}
	}

	public void SlideDoorToggle()
	{
		if (moving || (Object)(object)door == (Object)null)
		{
			return;
		}
		if (SemiFunc.IsMultiplayer())
		{
			photonView.RPC("RPC_PlayButtonSound", (RpcTarget)0, Array.Empty<object>());
		}
		else
		{
			PlayButtonSound();
		}
		if (SemiFunc.IsMultiplayer())
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				photonView.RPC("RPC_ToggleDoor", (RpcTarget)0, Array.Empty<object>());
			}
			else
			{
				photonView.RPC("RPC_RequestToggleDoor", (RpcTarget)2, Array.Empty<object>());
			}
		}
		else
		{
			ToggleDoor();
		}
	}

	[PunRPC]
	private void RPC_PlayButtonSound()
	{
		PlayButtonSound();
	}

	private void PlayButtonSound()
	{
		if ((Object)(object)buttonAudioSource != (Object)null && (Object)(object)buttonPressClip != (Object)null)
		{
			buttonAudioSource.PlayOneShot(buttonPressClip);
		}
	}

	[PunRPC]
	private void RPC_ToggleDoor()
	{
		ToggleDoor();
	}

	[PunRPC]
	private void RPC_RequestToggleDoor()
	{
		if (SemiFunc.IsMasterClientOrSingleplayer())
		{
			photonView.RPC("RPC_ToggleDoor", (RpcTarget)0, Array.Empty<object>());
		}
	}

	private void ToggleDoor()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		if (!moving && !((Object)(object)door == (Object)null))
		{
			if (Vector3.Distance(door.position, openDoorPosition) < 0.01f)
			{
				((MonoBehaviour)this).StartCoroutine(SlideDoorCoroutine(originalDoorPosition));
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(SlideDoorCoroutine(openDoorPosition));
			}
		}
	}

	public void OnTriggerEnter(Collider other)
	{
		if (!useEnemyTrigger || (Object)(object)triggerZone == (Object)null || (SemiFunc.IsMultiplayer() && !SemiFunc.IsMasterClientOrSingleplayer()) || (Object)(object)other == (Object)(object)triggerZone)
		{
			return;
		}
		EnemyRigidbody componentInParent = ((Component)other).GetComponentInParent<EnemyRigidbody>();
		Debug.Log((object)$"[DoorTrigger] OnTriggerEnter: '{((Object)((Component)other).gameObject).name}' - EnemyRigidbody found: {(Object)(object)componentInParent != (Object)null}");
		if ((Object)(object)componentInParent != (Object)null)
		{
			enemiesInZone++;
			Debug.Log((object)$"[DoorTrigger] Enemy entered. enemiesInZone now: {enemiesInZone}");
			if (enemiesInZone == 1)
			{
				Debug.Log((object)"[DoorTrigger] First enemy in zone, opening door.");
				OpenDoorFromTrigger();
			}
		}
	}

	public void OnTriggerExit(Collider other)
	{
		if (!useEnemyTrigger || (Object)(object)triggerZone == (Object)null || (SemiFunc.IsMultiplayer() && !SemiFunc.IsMasterClientOrSingleplayer()) || (Object)(object)other == (Object)(object)triggerZone)
		{
			return;
		}
		EnemyRigidbody componentInParent = ((Component)other).GetComponentInParent<EnemyRigidbody>();
		Debug.Log((object)$"[DoorTrigger] OnTriggerExit: '{((Object)((Component)other).gameObject).name}' - EnemyRigidbody found: {(Object)(object)componentInParent != (Object)null}");
		if ((Object)(object)componentInParent != (Object)null)
		{
			enemiesInZone = Mathf.Max(0, enemiesInZone - 1);
			Debug.Log((object)$"[DoorTrigger] Enemy left. enemiesInZone now: {enemiesInZone}");
			if (enemiesInZone == 0)
			{
				Debug.Log((object)"[DoorTrigger] Last enemy left zone, closing door.");
				CloseDoorFromTrigger();
			}
		}
	}

	public void OpenDoorFromTrigger()
	{
		if (SemiFunc.IsMultiplayer())
		{
			photonView.RPC("RPC_ForceOpenDoor", (RpcTarget)0, Array.Empty<object>());
		}
		else
		{
			ForceOpenDoor();
		}
	}

	public void CloseDoorFromTrigger()
	{
		if (SemiFunc.IsMultiplayer())
		{
			photonView.RPC("RPC_ForceCloseDoor", (RpcTarget)0, Array.Empty<object>());
		}
		else
		{
			ForceCloseDoor();
		}
	}

	[PunRPC]
	private void RPC_ForceOpenDoor()
	{
		ForceOpenDoor();
	}

	[PunRPC]
	private void RPC_ForceCloseDoor()
	{
		ForceCloseDoor();
	}

	public void ForceOpenDoor()
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		if (!moving && !((Object)(object)door == (Object)null) && !(Vector3.Distance(door.position, openDoorPosition) < 0.01f))
		{
			((MonoBehaviour)this).StopAllCoroutines();
			((MonoBehaviour)this).StartCoroutine(SlideDoorCoroutine(openDoorPosition));
		}
	}

	public void ForceCloseDoor()
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		if (!moving && !((Object)(object)door == (Object)null) && !(Vector3.Distance(door.position, originalDoorPosition) < 0.01f))
		{
			((MonoBehaviour)this).StopAllCoroutines();
			((MonoBehaviour)this).StartCoroutine(SlideDoorCoroutine(originalDoorPosition));
		}
	}

	[IteratorStateMachine(typeof(<SlideDoorCoroutine>d__29))]
	private IEnumerator SlideDoorCoroutine(Vector3 targetPosition)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SlideDoorCoroutine>d__29(0)
		{
			<>4__this = this,
			targetPosition = targetPosition
		};
	}
}
[DisallowMultipleComponent]
[RequireComponent(typeof(PhotonView))]
public class ChanceManager : MonoBehaviourPun
{
	[Range(0f, 1f)]
	[SerializeField]
	private float chanceToAppear = 0.5f;

	[SerializeField]
	private GameObject nonChanceObject;

	[SerializeField]
	private GameObject ChanceObject;

	private void OnEnable()
	{
		if (SemiFunc.IsMasterClientOrSingleplayer())
		{
			bool flag = Random.value < chanceToAppear;
			if (SemiFunc.IsMultiplayer())
			{
				((MonoBehaviourPun)this).photonView.RPC("RPC_SetChanceState", (RpcTarget)3, new object[1] { flag });
			}
			else
			{
				SetChanceState(flag);
			}
		}
	}

	[PunRPC]
	private void RPC_SetChanceState(bool isChance)
	{
		SetChanceState(isChance);
	}

	private void SetChanceState(bool isChance)
	{
		if (Object.op_Implicit((Object)(object)ChanceObject))
		{
			ChanceObject.SetActive(isChance);
		}
		if (Object.op_Implicit((Object)(object)nonChanceObject))
		{
			nonChanceObject.SetActive(!isChance);
		}
	}
}
public class EnemyTriggerRelay : MonoBehaviour
{
	public ButtonSlideDoor linkedDoor;

	private void OnTriggerEnter(Collider other)
	{
		linkedDoor?.OnTriggerEnter(other);
	}

	private void OnTriggerExit(Collider other)
	{
		linkedDoor?.OnTriggerExit(other);
	}
}
public class ProjectileAutoDestruct : MonoBehaviour
{
	private HurtCollider hurtCollider;

	private bool hasImpacted = false;

	private void Awake()
	{
		hurtCollider = ((Component)this).GetComponent<HurtCollider>();
		if ((Object)(object)hurtCollider == (Object)null)
		{
			hurtCollider = ((Component)this).GetComponentInChildren<HurtCollider>();
		}
		if ((Object)(object)hurtCollider == (Object)null)
		{
			Debug.LogError((object)"[ProjectileAutoDestruct] No HurtCollider found on this GameObject or its children!", (Object)(object)this);
			((Behaviour)this).enabled = false;
		}
	}

	private void OnEnable()
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Expected O, but got Unknown
		if ((Object)(object)hurtCollider != (Object)null)
		{
			hurtCollider.onImpactAny.AddListener(new UnityAction(OnAnyImpact));
		}
		((MonoBehaviour)this).Invoke("SelfDestruct", 1f);
	}

	private void OnDisable()
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Expected O, but got Unknown
		if ((Object)(object)hurtCollider != (Object)null)
		{
			hurtCollider.onImpactAny.RemoveListener(new UnityAction(OnAnyImpact));
		}
		((MonoBehaviour)this).CancelInvoke("SelfDestruct");
	}

	private void OnAnyImpact()
	{
		DestroyProjectile();
	}

	private void SelfDestruct()
	{
		DestroyProjectile();
	}

	private void DestroyProjectile()
	{
		if (!hasImpacted)
		{
			hasImpacted = true;
			PhotonView component = ((Component)this).GetComponent<PhotonView>();
			if ((Object)(object)component != (Object)null && component.ViewID != 0 && (component.IsMine || PhotonNetwork.IsMasterClient))
			{
				PhotonNetwork.Destroy(((Component)this).gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
}
public class AirlockDoor : MonoBehaviourPun
{
	[CompilerGenerated]
	private sealed class <DoorRoutine>d__24 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public AirlockDoor <>4__this;

		private GameObject[] <>s__1;

		private int <>s__2;

		private GameObject <go>5__3;

		private GameObject[] <>s__4;

		private int <>s__5;

		private GameObject <go>5__6;

		private GameObject[] <>s__7;

		private int <>s__8;

		private GameObject <go>5__9;

		private GameObject[] <>s__10;

		private int <>s__11;

		private GameObject <go>5__12;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DoorRoutine>d__24(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>s__1 = null;
			<go>5__3 = null;
			<>s__4 = null;
			<go>5__6 = null;
			<>s__7 = null;
			<go>5__9 = null;
			<>s__10 = null;
			<go>5__12 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.isOperating = true;
				<>s__1 = <>4__this.alarmObjects;
				for (<>s__2 = 0; <>s__2 < <>s__1.Length; <>s__2++)
				{
					<go>5__3 = <>s__1[<>s__2];
					if ((Object)(object)<go>5__3 != (Object)null)
					{
						<go>5__3.SetActive(true);
					}
					<go>5__3 = null;
				}
				<>s__1 = null;
				if ((Object)(object)<>4__this.alarmAudioSource != (Object)null && (Object)(object)<>4__this.alarmClip != (Object)null)
				{
					<>4__this.alarmAudioSource.PlayOneShot(<>4__this.alarmClip);
				}
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.SlideDoorCoroutine(<>4__this.openDoorPosition));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(<>4__this.alarmTime);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>s__4 = <>4__this.alarmObjects;
				for (<>s__5 = 0; <>s__5 < <>s__4.Length; <>s__5++)
				{
					<go>5__6 = <>s__4[<>s__5];
					if ((Object)(object)<go>5__6 != (Object)null)
					{
						<go>5__6.SetActive(false);
					}
					<go>5__6 = null;
				}
				<>s__4 = null;
				<>s__7 = <>4__this.activateOnOpen;
				for (<>s__8 = 0; <>s__8 < <>s__7.Length; <>s__8++)
				{
					<go>5__9 = <>s__7[<>s__8];
					if ((Object)(object)<go>5__9 != (Object)null)
					{
						<go>5__9.SetActive(true);
					}
					<go>5__9 = null;
				}
				<>s__7 = null;
				<>2__current = (object)new WaitForSeconds(<>4__this.openTime);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>s__10 = <>4__this.activateOnOpen;
				for (<>s__11 = 0; <>s__11 < <>s__10.Length; <>s__11++)
				{
					<go>5__12 = <>s__10[<>s__11];
					if ((Object)(object)<go>5__12 != (Object)null)
					{
						<go>5__12.SetActive(false);
					}
					<go>5__12 = null;
				}
				<>s__10 = null;
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.SlideDoorCoroutine(<>4__this.originalDoorPosition));
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.isOperating = false;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SlideDoorCoroutine>d__25 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Vector3 targetPosition;

		public AirlockDoor <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SlideDoorCoroutine>d__25(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if ((Object)(object)<>4__this.doorAudioSource != (Object)null && (Object)(object)<>4__this.doorMoveClip != (Object)null)
				{
					<>4__this.doorAudioSource.PlayOneShot(<>4__this.doorMoveClip);
				}
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (Vector3.Distance(<>4__this.door.position, targetPosition) > 0.01f)
			{
				<>4__this.door.position = Vector3.MoveTowards(<>4__this.door.position, targetPosition, <>4__this.moveSpeed * Time.deltaTime);
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			<>4__this.door.position = targetPosition;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[Header("Door Settings")]
	public Transform door;

	public float moveDistance = 3f;

	public float moveSpeed = 2f;

	public float openTime = 3f;

	public float alarmTime = 2f;

	[Header("Audio Settings")]
	public AudioSource buttonAudioSource;

	public AudioClip buttonPressClip;

	public AudioSource doorAudioSource;

	public AudioClip doorMoveClip;

	[Header("Alarm Settings (optional)")]
	public GameObject[] alarmObjects;

	public AudioSource alarmAudioSource;

	public AudioClip alarmClip;

	[Header("Objects To Activate During Open (e.g. Wind, Pushers)")]
	public GameObject[] activateOnOpen;

	private Vector3 originalDoorPosition;

	private Vector3 openDoorPosition;

	private bool isOperating = false;

	private PhotonView photonView;

	private void Start()
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		photonView = ((Component)this).GetComponentInParent<PhotonView>();
		if ((Object)(object)door != (Object)null)
		{
			originalDoorPosition = door.position;
			openDoorPosition = originalDoorPosition + Vector3.up * moveDistance;
		}
	}

	public void ActivateDoor()
	{
		if (isOperating || (Object)(object)door == (Object)null)
		{
			return;
		}
		if (SemiFunc.IsMultiplayer())
		{
			photonView.RPC("RPC_PlayButtonSound", (RpcTarget)0, Array.Empty<object>());
		}
		else
		{
			PlayButtonSound();
		}
		if (SemiFunc.IsMultiplayer())
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				photonView.RPC("RPC_ActivateTimedDoor", (RpcTarget)0, Array.Empty<object>());
			}
			else
			{
				photonView.RPC("RPC_RequestActivateTimedDoor", (RpcTarget)2, Array.Empty<object>());
			}
		}
		else
		{
			StartTimedDoor();
		}
	}

	[PunRPC]
	private void RPC_PlayButtonSound()
	{
		PlayButtonSound();
	}

	private void PlayButtonSound()
	{
		if ((Object)(object)buttonAudioSource != (Object)null && (Object)(object)buttonPressClip != (Object)null)
		{
			buttonAudioSource.PlayOneShot(buttonPressClip);
		}
	}

	[PunRPC]
	private void RPC_ActivateTimedDoor()
	{
		StartTimedDoor();
	}

	[PunRPC]
	private void RPC_RequestActivateTimedDoor()
	{
		if (SemiFunc.IsMasterClientOrSingleplayer())
		{
			photonView.RPC("RPC_ActivateTimedDoor", (RpcTarget)0, Array.Empty<object>());
		}
	}

	private void StartTimedDoor()
	{
		if (!isOperating && !((Object)(object)door == (Object)null))
		{
			((MonoBehaviour)this).StartCoroutine(DoorRoutine());
		}
	}

	[IteratorStateMachine(typeof(<DoorRoutine>d__24))]
	private IEnumerator DoorRoutine()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DoorRoutine>d__24(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<SlideDoorCoroutine>d__25))]
	private IEnumerator SlideDoorCoroutine(Vector3 targetPosition)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SlideDoorCoroutine>d__25(0)
		{
			<>4__this = this,
			targetPosition = targetPosition
		};
	}
}
public class TurretRotator : MonoBehaviourPunCallbacks
{
	[Header("Rotation Settings")]
	public float idleRotationSpeed = 30f;

	public float firingRotationSpeed = 70f;

	[Header("Detection Settings")]
	public float detectionRange = 10f;

	[Range(1f, 180f)]
	public float fieldOfView = 60f;

	[Header("Vision Mask (like EnemyVision's VisionMask)")]
	public LayerMask visionMask;

	[Header("Turret Eye (optional, uses transform if null)")]
	public Transform turretEye;

	[Header("Target Search Intervals (seconds)")]
	[Tooltip("How often to check for targets while idle (not firing).")]
	public float idleSearchInterval = 0.25f;

	[Tooltip("How often to check for targets while firing/locked on.")]
	public float firingSearchInterval = 0.21f;

	[Header("Spotting and Visuals")]
	public float spotToShootDelay = 1f;

	public GameObject spottedIcon;

	[Header("Audio")]
	public AudioSource audioSource;

	public AudioClip spottedSound;

	public AudioClip shootingSound;

	[Range(0f, 1f)]
	public float easterEggChance = 0.1f;

	public AudioClip[] easterEggSpottedSounds;

	public float[] easterEggDelays;

	[Header("Debug")]
	public bool enableDebug = false;

	private Transform target;

	private TurretShooter shooter;

	private float searchTimer = 0f;

	private bool isFiring = false;

	private bool isSpotted = false;

	private float spotTimer = 0f;

	private int lastEasterEggIndex = -1;

	private static readonly List<PlayerAvatar> cachedPlayers = new List<PlayerAvatar>(16);

	private Quaternion syncedRotation;

	private bool syncedIsSpotted;

	private bool syncedIsFiring;

	private int syncedTargetViewID = -1;

	private float lastSyncTime = 0f;

	private PhotonView photonView;

	private bool CanSendRPCs => PhotonNetwork.IsConnectedAndReady && PhotonNetwork.InRoom;

	private void Awake()
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		shooter = ((Component)this).GetComponent<TurretShooter>();
		photonView = ((Component)this).GetComponent<PhotonView>();
		if ((Object)(object)spottedIcon != (Object)null)
		{
			spottedIcon.SetActive(false);
		}
		syncedRotation = ((Component)this).transform.rotation;
		syncedIsSpotted = false;
		syncedIsFiring = false;
		syncedTargetViewID = -1;
	}

	private void Update()
	{
		//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_020a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
		if (SemiFunc.IsMasterClientOrSingleplayer())
		{
			float num = (isFiring ? firingSearchInterval : idleSearchInterval);
			searchTimer -= Time.deltaTime;
			if (searchTimer <= 0f)
			{
				searchTimer = num;
				Transform val = FindTargetInFOV();
				if (!isSpotted && (Object)(object)val != (Object)null)
				{
					OnPlayerSpotted();
					SyncStateWithClients();
				}
				else if (isSpotted && (Object)(object)val == (Object)null)
				{
					OnPlayerLost();
					SyncStateWithClients();
				}
				target = val;
			}
			if (isSpotted && (Object)(object)target != (Object)null)
			{
				LookAtTarget(firingRotationSpeed);
				if (spotTimer > 0f)
				{
					spotTimer -= Time.deltaTime;
				}
				else
				{
					if (!isFiring)
					{
						isFiring = true;
						SyncStateWithClients();
					}
					if ((Object)(object)shooter != (Object)null)
					{
						shooter.FireAtTarget(target, PlayShootingSound);
					}
				}
			}
			else
			{
				if (isFiring)
				{
					isFiring = false;
					SyncStateWithClients();
				}
				Rotate(idleRotationSpeed);
			}
			if (Time.time - lastSyncTime > 0.05f && CanSendRPCs)
			{
				lastSyncTime = Time.time;
				photonView.RPC("RPC_UpdateRotation", (RpcTarget)1, new object[1] { ((Component)this).transform.rotation });
			}
		}
		else
		{
			((Component)this).transform.rotation = Quaternion.Slerp(((Component)this).transform.rotation, syncedRotation, Time.deltaTime * 18f);
			if ((Object)(object)spottedIcon != (Object)null)
			{
				spottedIcon.SetActive(syncedIsSpotted);
			}
		}
	}

	private void SyncStateWithClients()
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		int num = (Object.op_Implicit((Object)(object)target) ? ((Object)target).GetInstanceID() : (-1));
		if (CanSendRPCs)
		{
			photonView.RPC("RPC_UpdateTurretState", (RpcTarget)1, new object[4]
			{
				((Component)this).transform.rotation,
				isSpotted,
				isFiring,
				num
			});
		}
	}

	[PunRPC]
	private void RPC_UpdateTurretState(Quaternion rot, bool spotted, bool firing, int targetID)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		syncedRotation = rot;
		syncedIsSpotted = spotted;
		syncedIsFiring = firing;
		syncedTargetViewID = targetID;
	}

	[PunRPC]
	private void RPC_UpdateRotation(Quaternion rot)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		syncedRotation = rot;
	}

	private void OnPlayerSpotted()
	{
		isSpotted = true;
		lastEasterEggIndex = -1;
		if (easterEggSpottedSounds != null && easterEggSpottedSounds.Length != 0 && easterEggDelays != null && easterEggDelays.Length == easterEggSpottedSounds.Length && Random.value < easterEggChance)
		{
			lastEasterEggIndex = Random.Range(0, easterEggSpottedSounds.Length);
			AudioClip val = easterEggSpottedSounds[lastEasterEggIndex];
			float num = (spotTimer = easterEggDelays[lastEasterEggIndex]);
			if (enableDebug)
			{
				Debug.Log((object)$"[Turret] Easter egg spotted! Playing: {((val != null) ? ((Object)val).name : null)}, delay: {num}");
			}
			if ((Object)(object)audioSource != (Object)null && (Object)(object)val != (Object)null)
			{
				audioSource.PlayOneShot(val);
			}
		}
		else
		{
			spotTimer = spotToShootDelay;
			if (enableDebug)
			{
				Debug.Log((object)("[Turret] Player spotted! Playing normal sound. Delay before firing: " + spotToShootDelay));
			}
			if ((Object)(object)audioSource != (Object)null && (Object)(object)spottedSound != (Object)null)
			{
				audioSource.PlayOneShot(spottedSound);
			}
		}
		if ((Object)(object)spottedIcon != (Object)null)
		{
			spottedIcon.SetActive(true);
		}
	}

	private void OnPlayerLost()
	{
		isSpotted = false;
		isFiring = false;
		spotTimer = 0f;
		lastEasterEggIndex = -1;
		if (enableDebug)
		{
			Debug.Log((object)"[Turret] Lost sight of player.");
		}
		if ((Object)(object)spottedIcon != (Object)null)
		{
			spottedIcon.SetActive(false);
		}
	}

	private void PlayShootingSound()
	{
		if ((Object)(object)audioSource != (Object)null && (Object)(object)shootingSound != (Object)null)
		{
			audioSource.PlayOneShot(shootingSound);
		}
	}

	private void Rotate(float speed)
	{
		((Component)this).transform.Rotate(0f, speed * Time.deltaTime, 0f);
	}

	private void LookAtTarget(float speed)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = target.position - (Object.op_Implicit((Object)(object)turretEye) ? turretEye.position : ((Component)this).transform.position);
		Vector3 normalized = ((Vector3)(ref val)).normalized;
		normalized.y = 0f;
		if (normalized != Vector3.zero)
		{
			Quaternion val2 = Quaternion.LookRotation(normalized);
			((Component)this).transform.rotation = Quaternion.Slerp(((Component)this).transform.rotation, val2, Time.deltaTime * speed / 10f);
		}
	}

	private Transform FindTargetInFOV()
	{
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0160: Unknown result type (might be due to invalid IL or missing references)
		cachedPlayers.Clear();
		cachedPlayers.AddRange(SemiFunc.PlayerGetAll());
		if (enableDebug)
		{
			Debug.Log((object)$"[Turret] Checking {cachedPlayers.Count} players in scene.");
		}
		Transform bestTarget = null;
		float bestDot = -1f;
		Vector3 eye = (Object.op_Implicit((Object)(object)turretEye) ? turretEye.position : ((Component)this).transform.position);
		Vector3 forward = ((Component)this).transform.forward;
		foreach (PlayerAvatar cachedPlayer in cachedPlayers)
		{
			if ((Object)(object)cachedPlayer == (Object)null || cachedPlayer.isDisabled)
			{
				continue;
			}
			Transform val = ((Component)cachedPlayer).transform;
			FieldInfo field = ((object)cachedPlayer).GetType().GetField("VisionTarget");
			if (field != null)
			{
				object value = field.GetValue(cachedPlayer);
				Transform val2 = (Transform)((value is Transform) ? value : null);
				if (val2 != null && (Object)(object)val2 != (Object)null)
				{
					val = val2;
				}
			}
			Vector3 val3 = val.position;
			if ((Object)(object)val == (Object)(object)((Component)cachedPlayer).transform)
			{
				val3 += Vector3.up * 1f;
			}
			CheckCandidate(((Component)cachedPlayer).transform, val3, "Player");
		}
		if (Object.op_Implicit((Object)(object)bestTarget) && enableDebug)
		{
			Debug.Log((object)("[Turret] Closest visible target selected: " + ((Object)bestTarget).name));
		}
		else if (!Object.op_Implicit((Object)(object)bestTarget) && enableDebug)
		{
			Debug.Log((object)"[Turret] No valid player found in FOV.");
		}
		return bestTarget;
		void CheckCandidate(Transform candidateRoot, Vector3 candidateVisionTargetPosition, string candidateType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val4 = candidateVisionTargetPosition - eye;
			float magnitude = ((Vector3)(ref val4)).magnitude;
			if (magnitude > detectionRange)
			{
				if (enableDebug)
				{
					Debug.Log((object)$"[Turret] {candidateType} {((Object)candidateRoot).name} is too far: {magnitude:F2} > {detectionRange}");
				}
			}
			else
			{
				Vector3 val5 = val4 / magnitude;
				float num = Vector3.Dot(forward, val5);
				float num2 = Mathf.Cos(MathF.PI / 180f * fieldOfView / 2f);
				if (enableDebug)
				{
					Debug.Log((object)$"[Turret] {candidateType} {((Object)candidateRoot).name} dot {num:F3}, required {num2:F3}");
				}
				if (num < num2)
				{
					if (enableDebug)
					{
						Debug.Log((object)("[Turret] " + candidateType + " " + ((Object)candidateRoot).name + " is outside FOV."));
					}
				}
				else
				{
					RaycastHit[] array = Physics.RaycastAll(eye, val5, magnitude, LayerMask.op_Implicit(visionMask), (QueryTriggerInteraction)1);
					Array.Sort(array, (RaycastHit a, RaycastHit b) => ((RaycastHit)(ref a)).distance.CompareTo(((RaycastHit)(ref b)).distance));
					Transform val6 = null;
					Transform val7 = null;
					RaycastHit[] array2 = array;
					for (int i = 0; i < array2.Length; i++)
					{
						RaycastHit val8 = array2[i];
						if (enableDebug)
						{
							Debug.Log((object)$"[Turret] Raycast hit: {((Object)((RaycastHit)(ref val8)).transform).name} (tag: {((Component)((RaycastHit)(ref val8)).transform).tag}) dist: {((RaycastHit)(ref val8)).distance:F2}");
						}
						if (Object.op_Implicit((Object)(object)((Component)candidateRoot).GetComponent<PlayerAvatar>()) && ((Component)((RaycastHit)(ref val8)).transform).CompareTag("Player"))
						{
							val6 = ((RaycastHit)(ref val8)).transform;
						}
						if ((Object)(object)val7 == (Object)null && (Object)(object)((RaycastHit)(ref val8)).transform != (Object)(object)((Component)this).transform && !((RaycastHit)(ref val8)).transform.IsChildOf(((Component)this).transform) && (!Object.op_Implicit((Object)(object)((Component)candidateRoot).GetComponent<PlayerAvatar>()) || !Object.op_Implicit((Object)(object)((Component)((RaycastHit)(ref val8)).transform).GetComponentInParent<EnemyRigidbody>())))
						{
							val7 = ((RaycastHit)(ref val8)).transform;
						}
					}
					if (Object.op_Implicit((Object)(object)((Component)candidateRoot).GetComponent<PlayerAvatar>()) && (Object)(object)val6 != (Object)null && (Object)(object)val6 == (Object)(object)val7)
					{
						if (enableDebug)
						{
							Debug.Log((object)("[Turret] " + candidateType + " " + ((Object)candidateRoot).name + " is visible! Ray hit: " + ((Object)val6).name));
						}
						if (num > bestDot)
						{
							bestDot = num;
							bestTarget = candidateRoot;
						}
					}
				}
			}
		}
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		Gizmos.color = Color.yellow;
		Gizmos.DrawWireSphere(((Component)this).transform.position, detectionRange);
		Vector3 val = Quaternion.Euler(0f, (0f - fieldOfView) / 2f, 0f) * ((Component)this).transform.forward;
		Vector3 val2 = Quaternion.Euler(0f, fieldOfView / 2f, 0f) * ((Component)this).transform.forward;
		Gizmos.color = Color.cyan;
		Gizmos.DrawLine(((Component)this).transform.position, ((Component)this).transform.position + val * detectionRange);
		Gizmos.DrawLine(((Component)this).transform.position, ((Component)this).transform.position + val2 * detectionRange);
		if (Application.isPlaying && (Object)(object)target != (Object)null)
		{
			Gizmos.color = Color.red;
			Gizmos.DrawLine(((Component)this).transform.position, target.position);
		}
	}

	public void DisableTurretRotation()
	{
		((Behaviour)this).enabled = false;
		Debug.Log((object)"[TurretRotator] Rotation disabled");
	}
}
public class TurretShooter : MonoBehaviourPunCallbacks
{
	[Header("Projectile Firing")]
	public GameObject projectilePrefab;

	public Transform projectileSpawnPoint;

	public float projectileForce = 20f;

	public float fireRate = 1f;

	[Header("VFX")]
	public GameObject muzzleFlashRoot;

	private float fireCooldown = 0f;

	private bool CanSendRPCs => PhotonNetwork.IsConnectedAndReady && PhotonNetwork.InRoom;

	private void Update()
	{
		if (fireCooldown > 0f)
		{
			fireCooldown -= Time.deltaTime;
		}
	}

	public void FireAtTarget(Transform target, Action onFireSound = null)
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)target == (Object)null || fireCooldown > 0f)
		{
			return;
		}
		if ((Object)(object)projectilePrefab == (Object)null || (Object)(object)projectileSpawnPoint == (Object)null)
		{
			Debug.LogWarning((object)"[TurretShooter] Missing projectilePrefab or spawn point!");
			return;
		}
		Vector3 val = target.position - projectileSpawnPoint.position;
		Vector3 normalized = ((Vector3)(ref val)).normalized;
		Quaternion val2 = Quaternion.LookRotation(normalized);
		Vector3 position = projectileSpawnPoint.position;
		float num = projectileForce;
		if (CanSendRPCs)
		{
			((MonoBehaviourPun)this).photonView.RPC("RPC_SpawnProjectile", (RpcTarget)0, new object[3] { position, val2, num });
		}
		else
		{
			SpawnProjectile(position, val2, num);
		}
		PlayMuzzleFlash();
		onFireSound?.Invoke();
		fireCooldown = fireRate;
	}

	[PunRPC]
	private void RPC_SpawnProjectile(Vector3 spawnPos, Quaternion spawnRot, float force)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		SpawnProjectile(spawnPos, spawnRot, force);
	}

	private void SpawnProjectile(Vector3 spawnPos, Quaternion spawnRot, float force)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)projectilePrefab == (Object)null)
		{
			Debug.LogWarning((object)"[TurretShooter] Projectile prefab not assigned!");
			return;
		}
		GameObject val = Object.Instantiate<GameObject>(projectilePrefab, spawnPos, spawnRot);
		val.SetActive(true);
		Rigidbody component = val.GetComponent<Rigidbody>();
		if ((Object)(object)component != (Object)null)
		{
			component.velocity = val.transform.forward * force;
		}
		Object.Destroy((Object)(object)val, 5f);
	}

	private void PlayMuzzleFlash()
	{
		if (!((Object)(object)muzzleFlashRoot == (Object)null))
		{
			ParticleSystem[] componentsInChildren = muzzleFlashRoot.GetComponentsInChildren<ParticleSystem>(true);
			ParticleSystem[] array = componentsInChildren;
			foreach (ParticleSystem val in array)
			{
				val.Stop(true, (ParticleSystemStopBehavior)0);
				val.Play(true);
			}
		}
	}

	public void DisableTurret()
	{
		((Behaviour)this).enabled = false;
		Debug.Log((object)"[TurretShooter] Disabled");
	}
}
[RequireComponent(typeof(BoxCollider))]
public class ZeroGravityZone : MonoBehaviour
{
	public float antiGravityDuration = 0.1f;

	[Header("Toggling")]
	[SerializeField]
	private bool isZoneActive = false;

	[SerializeField]
	private GameObject zeroGravityEffects;

	private readonly HashSet<PlayerAvatar> playersInZone = new HashSet<PlayerAvatar>();

	private BoxCollider zoneCollider;

	private PhotonView photonView;

	private void Awake()
	{
		zoneCollider = ((Component)this).GetComponent<BoxCollider>();
		((Collider)zoneCollider).isTrigger = true;
		photonView = ((Component)this).GetComponent<PhotonView>();
		if ((Object)(object)photonView == (Object)null)
		{
			photonView = ((Component)this).GetComponentInParent<PhotonView>();
		}
		ApplyEnabledState(isZoneActive);
	}

	private void ApplyEnabledState(bool enable)
	{
		isZoneActive = enable;
		if ((Object)(object)zoneCollider != (Object)null)
		{
			((Collider)zoneCollider).enabled = enable;
		}
		if ((Object)(object)zeroGravityEffects != (Object)null)
		{
			zeroGravityEffects.SetActive(enable);
		}
		if (!enable)
		{
			playersInZone.Clear();
		}
	}

	public void ToggleZoneOnGrab()
	{
		if (SemiFunc.IsMultiplayer())
		{
			if (SemiFunc.IsMasterClient())
			{
				bool flag = !isZoneActive;
				if ((Object)(object)photonView != (Object)null)
				{
					photonView.RPC("SetZoneActiveRPC", (RpcTarget)0, new object[1] { flag });
				}
				else
				{
					SetZoneActiveRPC(flag);
				}
			}
		}
		else
		{
			SetZoneActiveRPC(!isZoneActive);
		}
	}

	[PunRPC]
	public void SetZoneActiveRPC(bool enable)
	{
		ApplyEnabledState(enable);
	}

	private void Update()
	{
		if (!isZoneActive)
		{
			return;
		}
		foreach (PlayerAvatar item in playersInZone)
		{
			if ((Object)(object)item != (Object)null && item.isLocal)
			{
				PlayerController.instance.AntiGravity(antiGravityDuration);
			}
		}
	}

	private void OnTriggerEnter(Collider other)
	{
		if (isZoneActive)
		{
			PlayerAvatar componentInParent = ((Component)other).GetComponentInParent<PlayerAvatar>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				playersInZone.Add(componentInParent);
			}
		}
	}

	private void OnTriggerExit(Collider other)
	{
		if (isZoneActive)
		{
			PlayerAvatar componentInParent = ((Component)other).GetComponentInParent<PlayerAvatar>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				playersInZone.Remove(componentInParent);
			}
		}
	}

	private void OnTriggerStay(Collider other)
	{
		if (isZoneActive && SemiFunc.IsMasterClientOrSingleplayer())
		{
			PhysGrabObject componentInParent = ((Component)other).GetComponentInParent<PhysGrabObject>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				componentInParent.OverrideDrag(0.5f, 0.1f);
				componentInParent.OverrideAngularDrag(0.5f, 0.1f);
				componentInParent.OverrideZeroGravity(0.1f);
			}
		}
	}
}
namespace EchoholdAPI
{
	[BepInPlugin("Rosay.EchoholdAPI", "EchoholdAPI", "1.0")]
	public class EchoholdAPI : BaseUnityPlugin
	{
		internal static EchoholdAPI Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal void Patch()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
		}
	}
}