Decompiled source of WaterGunLib v1.2.0

WaterGunLib.dll

Decompiled a week ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using GameNetcodeStuff;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using WaterGunLib.NetcodePatcher;

[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: AssemblyCompany("WaterGunLib")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("WaterGunLib")]
[assembly: AssemblyTitle("WaterGunLib")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: NetcodePatchedAssembly]
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;
		}
	}
}
namespace WaterGunLib
{
	public class DetonatorItem : GrabbableObject
	{
		public GameObject ObjectToDetonate;

		public GameObject DestructionObject;

		public float minDistance = 5f;

		public string ExplosionText;

		public override void Update()
		{
			((GrabbableObject)this).Update();
			if ((Object)(object)base.playerHeldBy != (Object)null && StartOfRound.Instance.inShipPhase)
			{
				((GrabbableObject)this).DestroyObjectInHand(base.playerHeldBy);
			}
			else if ((Object)(object)base.playerHeldBy == (Object)null && StartOfRound.Instance.inShipPhase)
			{
				DespawnObjectServerRpc();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void DespawnObjectServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2875846605u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2875846605u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					((Component)this).GetComponent<NetworkObject>().Despawn(true);
				}
			}
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			float num = Vector3.Distance(((Component)this).transform.position, ObjectToDetonate.transform.position);
			if (num <= minDistance)
			{
				HUDManager.Instance.DisplayTip(base.itemProperties.itemName, ExplosionText, false, false, "LC_Tip1");
				DestroyObject();
			}
			else
			{
				HUDManager.Instance.DisplayTip(base.itemProperties.itemName, "Failed to detonate please get closer to the target", false, false, "LC_Tip1");
			}
		}

		private void DestroyObject()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(DestructionObject, ObjectToDetonate.transform.position, ObjectToDetonate.transform.rotation);
			Object.Destroy((Object)(object)ObjectToDetonate);
			((GrabbableObject)this).DestroyObjectInHand(base.playerHeldBy);
		}

		protected override void __initializeVariables()
		{
			((GrabbableObject)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2875846605u, new RpcReceiveHandler(__rpc_handler_2875846605), "DespawnObjectServerRpc");
			((GrabbableObject)this).__initializeRpcs();
		}

		private static void __rpc_handler_2875846605(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DetonatorItem)(object)target).DespawnObjectServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "DetonatorItem";
		}
	}
	[BepInPlugin("WaterGun.WaterGunLib", "WaterGunLib", "1.2.0")]
	public class Plugin : BaseUnityPlugin
	{
		private const string GUID = "WaterGun.WaterGunLib";

		private const string VER = "1.2.0";

		private const string NAME = "WaterGunLib";

		private void Awake()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"WaterGunLib: Loaded");
		}
	}
	public class PowerGenerator : NetworkBehaviour
	{
		[Space]
		[Header("Refrences")]
		public List<Light> LightsToDisable;

		public AudioClip FailSound;

		public AudioClip ToggleSound;

		public AudioSource GeneratorAudioSource;

		[Space]
		[Header("Settings")]
		public bool IsAbleToFail = true;

		public int ChanceToFail = 10;

		public int FailDamage = 50;

		public void ToggleAllLights(PlayerControllerB player)
		{
			ulong playerClientId = player.playerClientId;
			ToggleLightsServerRpc(playerClientId);
		}

		[ServerRpc(RequireOwnership = false)]
		public void ToggleLightsServerRpc(ulong clientid)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4017266650u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientid);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4017266650u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val3 in allPlayerScripts)
			{
				if (val3.playerClientId == clientid)
				{
					float num = Random.Range(1, ChanceToFail);
					if (num == 1f)
					{
						ToggleLightsClientRpc(IsFailed: true, clientid);
					}
					else
					{
						ToggleLightsClientRpc(IsFailed: false, clientid);
					}
				}
			}
		}

		[ClientRpc]
		public void ToggleLightsClientRpc(bool IsFailed, ulong clientid)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_008c: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1129565366u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref IsFailed, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, clientid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1129565366u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!IsFailed)
			{
				if ((Object)(object)GeneratorAudioSource != (Object)null)
				{
					GeneratorAudioSource.PlayOneShot(ToggleSound);
				}
				{
					foreach (Light item in LightsToDisable)
					{
						if (!((Behaviour)item).enabled)
						{
							((Behaviour)item).enabled = true;
						}
						else
						{
							((Behaviour)item).enabled = false;
						}
					}
					return;
				}
			}
			if (!IsFailed || !IsAbleToFail)
			{
				return;
			}
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val3 in allPlayerScripts)
			{
				if (val3.playerClientId == clientid)
				{
					val3.DamagePlayer(FailDamage, true, true, (CauseOfDeath)11, 0, false, default(Vector3));
				}
			}
			if ((Object)(object)GeneratorAudioSource != (Object)null)
			{
				GeneratorAudioSource.PlayOneShot(FailSound);
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(4017266650u, new RpcReceiveHandler(__rpc_handler_4017266650), "ToggleLightsServerRpc");
			((NetworkBehaviour)this).__registerRpc(1129565366u, new RpcReceiveHandler(__rpc_handler_1129565366), "ToggleLightsClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_4017266650(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PowerGenerator)(object)target).ToggleLightsServerRpc(clientid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1129565366(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool isFailed = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isFailed, default(ForPrimitives));
				ulong clientid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PowerGenerator)(object)target).ToggleLightsClientRpc(isFailed, clientid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "PowerGenerator";
		}
	}
	public class TeleportTarget : NetworkBehaviour
	{
		[Space]
		[Header("Refrences")]
		public Transform Target;

		public AudioClip StartTeleport;

		public AudioClip EndTeleport;

		[Space]
		[Header("AudioSource")]
		public AudioSource EndAudioSource;

		public AudioSource StartAudioSource;

		public void TeleportPlayer()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			GameNetworkManager.Instance.localPlayerController.TeleportPlayer(Target.position, true, Target.eulerAngles.y, false, true);
			GameNetworkManager.Instance.localPlayerController.isInElevator = false;
			GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom = false;
			TeleportPlayerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
			Debug.Log((object)"TeleportStarted");
		}

		[ServerRpc(RequireOwnership = false)]
		private void TeleportPlayerServerRpc(int PlayerObj)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1787506709u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, PlayerObj);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1787506709u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportPlayerClientRpc(PlayerObj);
				}
			}
		}

		[ClientRpc]
		private void TeleportPlayerClientRpc(int PlayerObj)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1996081384u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, PlayerObj);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1996081384u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				StartOfRound.Instance.allPlayerScripts[PlayerObj].TeleportPlayer(Target.position, true, Target.eulerAngles.y, false, true);
				StartOfRound.Instance.allPlayerScripts[PlayerObj].isInElevator = false;
				StartOfRound.Instance.allPlayerScripts[PlayerObj].isInHangarShipRoom = false;
				if ((Object)(object)EndTeleport != (Object)null && (Object)(object)EndAudioSource != (Object)null)
				{
					EndAudioSource.PlayOneShot(EndTeleport);
				}
				if ((Object)(object)StartTeleport != (Object)null && (Object)(object)StartAudioSource != (Object)null)
				{
					StartAudioSource.PlayOneShot(StartTeleport);
				}
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1787506709u, new RpcReceiveHandler(__rpc_handler_1787506709), "TeleportPlayerServerRpc");
			((NetworkBehaviour)this).__registerRpc(1996081384u, new RpcReceiveHandler(__rpc_handler_1996081384), "TeleportPlayerClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1787506709(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerObj = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerObj);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((TeleportTarget)(object)target).TeleportPlayerServerRpc(playerObj);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1996081384(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerObj = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerObj);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((TeleportTarget)(object)target).TeleportPlayerClientRpc(playerObj);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "TeleportTarget";
		}
	}
	public class ToxicGas : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DamagePlayerAfterDelay>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerControllerB Player;

			public ToxicGas <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005b: 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_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this.IsAbleToDealDamage)
					{
						<>4__this.IsAbleToDealDamage = false;
						Player.DamagePlayer(<>4__this.Damage, true, true, <>4__this.DeathType, <>4__this.DeathAnimation, false, default(Vector3));
						Debug.Log((object)("Damaged Player: " + Player.playerUsername));
						<>2__current = (object)new WaitForSeconds((float)<>4__this.Delay);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					<>4__this.IsAbleToDealDamage = true;
					break;
				}
				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();
			}
		}

		[Space]
		[Header("Settings")]
		public int Delay = 3;

		public int Damage = 20;

		public CauseOfDeath DeathType;

		public int DeathAnimation = 0;

		public bool DamageSFX = false;

		private bool IsAbleToDealDamage = true;

		private void OnTriggerStay(Collider other)
		{
			if (Object.op_Implicit((Object)(object)((Component)other).GetComponent<PlayerControllerB>()))
			{
				((MonoBehaviour)this).StartCoroutine(DamagePlayerAfterDelay(((Component)other).GetComponent<PlayerControllerB>()));
			}
		}

		[IteratorStateMachine(typeof(<DamagePlayerAfterDelay>d__7))]
		private IEnumerator DamagePlayerAfterDelay(PlayerControllerB Player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DamagePlayerAfterDelay>d__7(0)
			{
				<>4__this = this,
				Player = Player
			};
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace WaterGunLib.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}