Decompiled source of LethalChaos v1.2.1

LC_Cutea.dll

Decompiled a week ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LC_Cutea.NetcodePatcher;
using LethalLib.Modules;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("LC_Cutea")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LC_Cutea")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("b305ba02-86ae-4d0f-bc13-3439417618b3")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
public class DrinkCan : GrabbableObject
{
	[CompilerGenerated]
	private sealed class <OpenBottle>d__34 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public DrinkCan <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.audio.PlayOneShot(openingSFX);
				<>4__this.animator.Play("PopOff");
				<>4__this.beenOpened = true;
				<>4__this.particleSystem.Stop();
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.particleSystem.Play();
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.bottleCap.SetActive(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 <RequestData>d__18 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public DrinkCan <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (!<>4__this.loaded)
				{
					<>4__this.RequestFillDataServerRpc();
				}
				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 <StartDrink>d__24 : IEnumerator<WaitForSeconds>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public DrinkCan <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.animator.SetBool("IsDrinking", true);
				<>2__current = new WaitForSeconds(<>4__this.timeToStart);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.drinking = true;
				<>4__this.audio.PlayOneShot(drinkingSFX, 0.75f);
				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();
		}
	}

	public bool drinking = false;

	public float fill = 1f;

	public float duration = 20f;

	public float timeToDrink = 2f;

	public float timeToStart = 0.75f;

	public AudioSource audio;

	public Animator animator;

	public ParticleSystem particleSystem;

	public Coroutine DrinkCoroutine;

	public PlayerControllerB previousPlayerHeldBy;

	public GameObject bottleCap;

	public const string playerDrinkAnimation = "HoldMask";

	public static AudioClip drinkingSFX;

	public static AudioClip openingSFX;

	public static AudioClip finishSFX;

	public bool beenOpened = false;

	public bool loaded = false;

	public override void Start()
	{
		((GrabbableObject)this).Start();
		audio = ((Component)this).GetComponent<AudioSource>();
		animator = ((Component)this).GetComponent<Animator>();
		particleSystem = ((Component)this).GetComponentInChildren<ParticleSystem>();
		bottleCap = ((Component)((Component)this).transform.Find("BottleMesh/CapMesh")).gameObject;
		if (!((NetworkBehaviour)this).IsServer)
		{
			((MonoBehaviour)this).StartCoroutine(RequestData());
		}
	}

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

	public override void ItemActivate(bool used, bool buttonDown = true)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		((GrabbableObject)this).ItemActivate(used, buttonDown);
		if (buttonDown)
		{
			if (!beenOpened)
			{
				RoundManager.Instance.PlayAudibleNoise(((Component)this).transform.position, 15f, 1.5f, 0, base.isInElevator && StartOfRound.Instance.hangarDoorsClosed, 0);
				OpenBottleServerRpc();
				((MonoBehaviour)this).StartCoroutine(OpenBottle());
				beenOpened = true;
				return;
			}
			base.isBeingUsed = true;
			if (fill <= 0f)
			{
				previousPlayerHeldBy.playerBodyAnimator.SetTrigger("shakeItem");
				return;
			}
			previousPlayerHeldBy.activatingItem = true;
			previousPlayerHeldBy.playerBodyAnimator.SetBool("HoldMask", true);
			previousPlayerHeldBy = base.playerHeldBy;
			DrinkCoroutine = ((MonoBehaviour)this).StartCoroutine((IEnumerator)StartDrink());
		}
		else
		{
			base.isBeingUsed = false;
			if (DrinkCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(DrinkCoroutine);
			}
			Stop();
		}
	}

	public override void Update()
	{
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		((GrabbableObject)this).Update();
		if (!base.isHeld || !((Object)(object)base.playerHeldBy == (Object)(object)StartOfRound.Instance.localPlayerController))
		{
			return;
		}
		if (drinking)
		{
			if ((Object)(object)previousPlayerHeldBy == (Object)null || !base.isHeld || fill <= 0f)
			{
				Stop();
				base.itemUsedUp = true;
			}
			fill -= Time.deltaTime / timeToDrink;
			DoDrinkEffectOvertime(Time.deltaTime / timeToDrink);
		}
		if (fill <= 0f)
		{
			DoDrinkEffect();
			audio.PlayOneShot(finishSFX);
			RoundManager.Instance.PlayAudibleNoise(((Component)this).transform.position, 15f, 1.5f, 0, base.isInElevator && StartOfRound.Instance.hangarDoorsClosed, 0);
			((GrabbableObject)this).DestroyObjectInHand(previousPlayerHeldBy);
			((Behaviour)this).enabled = false;
		}
	}

	public void DoDrinkEffectOvertime(float deltatime)
	{
	}

	public void DoDrinkEffect()
	{
		Effects.HealPlayer(previousPlayerHeldBy, 100);
		Effects.ApplyDrinkEffect(previousPlayerHeldBy);
	}

	public void ChangeItem(Item to)
	{
		if ((Object)(object)base.itemProperties != (Object)(object)to)
		{
			base.itemProperties = to;
		}
	}

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

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

	public override void DiscardItem()
	{
		if (DrinkCoroutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(DrinkCoroutine);
		}
		Stop();
		SendFillServerRpc(fill, beenOpened);
		if ((Object)(object)previousPlayerHeldBy != (Object)null)
		{
			previousPlayerHeldBy.activatingItem = false;
		}
		((GrabbableObject)this).DiscardItem();
	}

	public void Stop()
	{
		drinking = false;
		previousPlayerHeldBy.activatingItem = false;
		audio.Stop();
		base.playerHeldBy.playerBodyAnimator.ResetTrigger("shakeItem");
		previousPlayerHeldBy.playerBodyAnimator.SetBool("HoldMask", false);
	}

	[ServerRpc(RequireOwnership = false)]
	public void SendFillServerRpc(float fill, bool opened)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: 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_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: 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(2325525434u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref fill, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref opened, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2325525434u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				SendFillClientRpc(fill, opened);
			}
		}
	}

	[ClientRpc]
	public void SendFillClientRpc(float Fill, bool opened)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: 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_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: 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)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3478490468u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref Fill, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref opened, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3478490468u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
		{
			loaded = true;
			fill = Fill;
			beenOpened = opened;
			if (fill <= 0f)
			{
				base.itemUsedUp = true;
			}
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void RequestFillDataServerRpc()
	{
		//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)
		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(2198512995u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2198512995u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				RequestFillDataClientRpc();
			}
		}
	}

	[ClientRpc]
	public void RequestFillDataClientRpc()
	{
		//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)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(982176427u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 982176427u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && ((NetworkBehaviour)this).IsServer)
			{
				SendFillServerRpc(fill, beenOpened);
			}
		}
	}

	[ServerRpc]
	public void OpenBottleServerRpc()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Invalid comparison between Unknown and I4
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Invalid comparison between Unknown and I4
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			ServerRpcParams val = default(ServerRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(309127621u, val, (RpcDelivery)0);
			((NetworkBehaviour)this).__endSendServerRpc(ref val2, 309127621u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			OpenBottleClientRpc();
		}
	}

	[ClientRpc]
	public void OpenBottleClientRpc()
	{
		//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)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3348258258u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3348258258u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !((NetworkBehaviour)this).IsOwner)
			{
				((MonoBehaviour)this).StartCoroutine(OpenBottle());
			}
		}
	}

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

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

	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeRPCS_DrinkCan()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Expected O, but got Unknown
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Expected O, but got Unknown
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Expected O, but got Unknown
		NetworkManager.__rpc_func_table.Add(2325525434u, new RpcReceiveHandler(__rpc_handler_2325525434));
		NetworkManager.__rpc_func_table.Add(3478490468u, new RpcReceiveHandler(__rpc_handler_3478490468));
		NetworkManager.__rpc_func_table.Add(2198512995u, new RpcReceiveHandler(__rpc_handler_2198512995));
		NetworkManager.__rpc_func_table.Add(982176427u, new RpcReceiveHandler(__rpc_handler_982176427));
		NetworkManager.__rpc_func_table.Add(309127621u, new RpcReceiveHandler(__rpc_handler_309127621));
		NetworkManager.__rpc_func_table.Add(3348258258u, new RpcReceiveHandler(__rpc_handler_3348258258));
	}

	private static void __rpc_handler_2325525434(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_004a: 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)
		//IL_005f: 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)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			float num = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref num, default(ForPrimitives));
			bool opened = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref opened, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((DrinkCan)(object)target).SendFillServerRpc(num, opened);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3478490468(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_004a: 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)
		//IL_005f: 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)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			float num = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref num, default(ForPrimitives));
			bool opened = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref opened, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)2;
			((DrinkCan)(object)target).SendFillClientRpc(num, opened);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2198512995(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;
			((DrinkCan)(object)target).RequestFillDataServerRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_982176427(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)2;
			((DrinkCan)(object)target).RequestFillDataClientRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_309127621(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: 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_008c: 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_0055: Invalid comparison between Unknown and I4
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
		{
			if ((int)networkManager.LogLevel <= 1)
			{
				Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
			}
		}
		else
		{
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((DrinkCan)(object)target).OpenBottleServerRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3348258258(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)2;
			((DrinkCan)(object)target).OpenBottleClientRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	protected internal override string __getTypeName()
	{
		return "DrinkCan";
	}
}
public static class Effects
{
	[CompilerGenerated]
	private sealed class <ApplyDeafness>d__5 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		private float <normal>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				HUDManager.Instance.DisplayTip("Warning", "Deafness inbound.", true, false, "LC_Tip1");
				<>2__current = (object)new WaitForSeconds(3f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<normal>5__1 = AudioListener.volume;
				AudioListener.volume = 0f;
				<>2__current = (object)new WaitForSeconds(Random.Range(16f, 32f));
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				AudioListener.volume = <normal>5__1;
				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 <ApplyGhost>d__6 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PlayerControllerB player;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				HUDManager.Instance.DisplayTip("Warning", "Hallucinations inbound.", true, false, "LC_Tip1");
				<>2__current = (object)new WaitForSeconds(3f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				player.insanityLevel = player.maxInsanityLevel;
				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 <ApplyHydrophobia>d__8 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PlayerControllerB player;

		private float <duration>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				HUDManager.Instance.DisplayTip("Warning", "Hydrophobia inbound. (Don't drink and swim folks)", true, false, "LC_Tip1");
				<>2__current = (object)new WaitForSeconds(3f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<duration>5__1 = 0f;
				break;
			case 2:
				<>1__state = -1;
				break;
			}
			if (<duration>5__1 < 60f)
			{
				if (player.isUnderwater)
				{
					player.DamagePlayer(1, false, true, (CauseOfDeath)0, 0, false, default(Vector3));
				}
				<duration>5__1 += Time.deltaTime;
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 2;
				return true;
			}
			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 <ApplyPoison>d__9 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PlayerControllerB player;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				HUDManager.Instance.DisplayTip("Warning", "Abnormally high alcohol blood content. Death is iminant.", true, false, "LC_Tip1");
				<>2__current = (object)new WaitForSeconds(5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				player.DamagePlayer(9999, true, true, (CauseOfDeath)8, 1, false, Vector3.up);
				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 <ApplyVision>d__7 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PlayerControllerB player;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				HUDManager.Instance.DisplayTip("Warning", "Blurred vision inbound.", true, false, "LC_Tip1");
				<>2__current = (object)new WaitForSeconds(3f);
				<>1__state = 1;
				return true;
			case 1:
			{
				<>1__state = -1;
				PlayerControllerB obj = player;
				obj.drunkness += 0.33f;
				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();
		}
	}

	public static float drank;

	public const float timeBetweenDrinks = 200f;

	public static float timeSinceLastDrink;

	private static EnemyType _ghostGirl;

	public static void ApplyDrinkEffect(PlayerControllerB player)
	{
		float num = Time.time - timeSinceLastDrink;
		drank -= num;
		drank = Mathf.Clamp(drank, 0f, 800f);
		drank += 200f;
		drank = Mathf.Clamp(drank, 0f, 800f);
		timeSinceLastDrink = Time.time;
		if (drank >= 500f)
		{
			drank = 0f;
			((MonoBehaviour)player).StartCoroutine(ApplyPoison(player));
			return;
		}
		switch (Random.Range(0, 4))
		{
		case 0:
			((MonoBehaviour)player).StartCoroutine(ApplyGhost(player));
			break;
		case 1:
			((MonoBehaviour)player).StartCoroutine(ApplyHydrophobia(player));
			break;
		case 2:
			((MonoBehaviour)player).StartCoroutine(ApplyVision(player));
			break;
		case 3:
			((MonoBehaviour)player).StartCoroutine(ApplyDeafness());
			break;
		}
	}

	public static void HealPlayer(PlayerControllerB player, int amount)
	{
		player.health = Mathf.Clamp(player.health + amount, 0, 100);
		HUDManager.Instance.UpdateHealthUI(player.health, false);
	}

	[IteratorStateMachine(typeof(<ApplyDeafness>d__5))]
	public static IEnumerator ApplyDeafness()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ApplyDeafness>d__5(0);
	}

	[IteratorStateMachine(typeof(<ApplyGhost>d__6))]
	public static IEnumerator ApplyGhost(PlayerControllerB player)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ApplyGhost>d__6(0)
		{
			player = player
		};
	}

	[IteratorStateMachine(typeof(<ApplyVision>d__7))]
	public static IEnumerator ApplyVision(PlayerControllerB player)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ApplyVision>d__7(0)
		{
			player = player
		};
	}

	[IteratorStateMachine(typeof(<ApplyHydrophobia>d__8))]
	public static IEnumerator ApplyHydrophobia(PlayerControllerB player)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ApplyHydrophobia>d__8(0)
		{
			player = player
		};
	}

	[IteratorStateMachine(typeof(<ApplyPoison>d__9))]
	public static IEnumerator ApplyPoison(PlayerControllerB player)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ApplyPoison>d__9(0)
		{
			player = player
		};
	}

	[HarmonyPatch(typeof(StartOfRound), "Awake")]
	[HarmonyPostfix]
	private static EnemyType GetGhostGirl()
	{
		if ((Object)(object)_ghostGirl != (Object)null)
		{
			return _ghostGirl;
		}
		SelectableLevel[] levels = StartOfRound.Instance.levels;
		SelectableLevel[] array = levels;
		foreach (SelectableLevel val in array)
		{
			foreach (SpawnableEnemyWithRarity enemy in val.Enemies)
			{
				CuteaMod.mls.LogMessage((object)("Enemy Name: '" + ((Object)enemy.enemyType).name + "'"));
				if (!(((Object)enemy.enemyType).name == "DressGirl"))
				{
					continue;
				}
				_ghostGirl = enemy.enemyType;
				return _ghostGirl;
			}
		}
		return null;
	}

	[HarmonyPatch("DespawnPropsAtEndOfRound")]
	[HarmonyPostfix]
	public static void NewDay()
	{
		drank = 0f;
		timeSinceLastDrink = 0f;
	}
}
public class ShadowHat : GrabbableObject
{
	[CompilerGenerated]
	private sealed class <SetText>d__1 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public ShadowHat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				((Component)<>4__this).gameObject.GetComponentInChildren<ScanNodeProperties>().subText = "Owned by TheInvertedShadow";
				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();
		}
	}

	public override void Start()
	{
		((GrabbableObject)this).Start();
		((MonoBehaviour)this).StartCoroutine(SetText());
	}

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

	[HarmonyPatch(typeof(ShadowHat), "SetScrapValue")]
	[HarmonyPostfix]
	public static void SetScrapValuePatch(ShadowHat __instance)
	{
		((Component)__instance).GetComponentInChildren<ScanNodeProperties>().subText = "Owned by TheInvertedShadow";
	}

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

	protected internal override string __getTypeName()
	{
		return "ShadowHat";
	}
}
public class CookieJar : GrabbableObject
{
	[CompilerGenerated]
	private sealed class <SendServerEating>d__15 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public CookieJar <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.animator.SetTrigger("Eat");
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.eatParticles.Play();
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.eatParticles.Stop();
				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 <StartEating>d__14 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public CookieJar <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (((NetworkBehaviour)<>4__this).IsOwner)
				{
					<>4__this.SendEatingServerRpc();
				}
				<>4__this.previousPlayerHeldBy.playerBodyAnimator.SetBool("HoldMask", true);
				<>4__this.animator.SetTrigger("Eat");
				<>2__current = (object)new WaitForSeconds(0.75f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.eatParticles.Play();
				<>4__this.audioSource.PlayOneShot(eatSFX);
				<>2__current = (object)new WaitForSeconds(1.2f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.eatParticles.Stop();
				<>4__this.cookies--;
				<>4__this.SendCookieAmount();
				((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.healOverTime(<>4__this.previousPlayerHeldBy));
				((Component)<>4__this.cookieTransforms[<>4__this.cookies]).gameObject.SetActive(false);
				<>4__this.previousPlayerHeldBy.playerBodyAnimator.SetBool("HoldMask", false);
				if (<>4__this.cookies <= 0)
				{
					<>4__this.FinishedEating();
				}
				else
				{
					<>4__this.Stop();
				}
				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 <healOverTime>d__20 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PlayerControllerB player;

		public CookieJar <>4__this;

		private int <i>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<i>5__1 = 0;
				break;
			case 1:
				<>1__state = -1;
				player.health = (int)Mathf.MoveTowards((float)player.health, 100f, 1f);
				HUDManager.Instance.UpdateHealthUI(player.health, false);
				<i>5__1++;
				break;
			}
			if (<i>5__1 < <>4__this.healingPerCookie)
			{
				<>2__current = (object)new WaitForSeconds(1f / <>4__this.healingSpeed);
				<>1__state = 1;
				return true;
			}
			player.criticallyInjured = false;
			HUDManager.Instance.UpdateHealthUI(player.health, 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();
		}
	}

	private bool fullyEaten = false;

	public int cookies = 5;

	public Transform[] cookieTransforms;

	private int healingPerCookie = 20;

	private float healingSpeed = 20f;

	public static AudioClip eatSFX;

	private Transform cookieContainer;

	public ParticleSystem eatParticles;

	private AudioSource audioSource;

	private Animator animator;

	private const string eatAnimation = "HoldMask";

	private PlayerControllerB previousPlayerHeldBy;

	public override void Start()
	{
		((GrabbableObject)this).Start();
		animator = ((Component)this).GetComponent<Animator>();
		audioSource = ((Component)this).gameObject.GetComponent<AudioSource>();
		eatParticles = ((Component)this).GetComponentInChildren<ParticleSystem>();
		cookieContainer = ((Component)this).transform.Find("JarMesh/Cookies");
		List<Transform> list = new List<Transform>();
		foreach (Transform item in ((Component)cookieContainer).GetComponentsInChildren<Transform>().ToList())
		{
			if (((Object)item).name.Contains("Cookie") && (Object)(object)item != (Object)(object)cookieContainer)
			{
				list.Add(item);
			}
		}
		list.Reverse();
		cookieTransforms = list.ToArray();
		base.useCooldown = 0.3f;
		if (!((NetworkBehaviour)this).IsServer)
		{
			RequestStateServerRpc();
		}
	}

	public override void ItemActivate(bool used, bool buttonDown = true)
	{
		((GrabbableObject)this).ItemActivate(used, buttonDown);
		if (fullyEaten)
		{
			previousPlayerHeldBy.playerBodyAnimator.SetTrigger("shakeItem");
		}
		else if (buttonDown)
		{
			base.isBeingUsed = true;
			previousPlayerHeldBy.activatingItem = true;
			((MonoBehaviour)this).StartCoroutine(StartEating());
		}
	}

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

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

	public override void GrabItem()
	{
		((GrabbableObject)this).GrabItem();
		previousPlayerHeldBy = base.playerHeldBy;
	}

	public override void DiscardItem()
	{
		((GrabbableObject)this).DiscardItem();
		SendCookieAmount();
		Stop();
	}

	public void SendCookieAmount()
	{
		if (((NetworkBehaviour)this).IsOwner)
		{
			SendCookieServerRpc(cookies);
		}
	}

	public void FinishedEating()
	{
		fullyEaten = true;
		Stop();
	}

	[IteratorStateMachine(typeof(<healOverTime>d__20))]
	public IEnumerator healOverTime(PlayerControllerB player)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <healOverTime>d__20(0)
		{
			<>4__this = this,
			player = player
		};
	}

	public void Stop()
	{
		if ((Object)(object)previousPlayerHeldBy != (Object)null)
		{
			base.isBeingUsed = false;
			previousPlayerHeldBy.activatingItem = false;
			previousPlayerHeldBy.playerBodyAnimator.SetBool("HoldMask", false);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void SendCookieServerRpc(int cookies)
	{
		//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)
		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(1698813393u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, cookies);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1698813393u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				SendCookieClientRpc(cookies);
			}
		}
	}

	[ClientRpc]
	public void SendCookieClientRpc(int amount)
	{
		//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)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(222697835u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, amount);
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 222697835u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
		{
			cookies = amount;
			for (int i = 0; i < cookieTransforms.Length; i++)
			{
				((Component)cookieTransforms[i]).gameObject.SetActive(cookies > i);
			}
			if (cookies <= 0)
			{
				fullyEaten = true;
			}
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void RequestStateServerRpc()
	{
		//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)
		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(4282543262u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4282543262u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				RequestStateClientRpc();
			}
		}
	}

	[ClientRpc]
	public void RequestStateClientRpc()
	{
		//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)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3414504546u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3414504546u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && ((NetworkBehaviour)this).IsServer)
			{
				SendCookieServerRpc(cookies);
			}
		}
	}

	[ServerRpc(RequireOwnership = true)]
	public void SendEatingServerRpc()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Invalid comparison between Unknown and I4
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Invalid comparison between Unknown and I4
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			ServerRpcParams val = default(ServerRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2300776769u, val, (RpcDelivery)0);
			((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2300776769u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			SendEatingClientRpc();
		}
	}

	[ClientRpc]
	public void SendEatingClientRpc()
	{
		//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)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1122607531u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1122607531u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !((NetworkBehaviour)this).IsOwner)
			{
				((MonoBehaviour)this).StartCoroutine(SendServerEating());
			}
		}
	}

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

	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeRPCS_CookieJar()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Expected O, but got Unknown
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Expected O, but got Unknown
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Expected O, but got Unknown
		NetworkManager.__rpc_func_table.Add(1698813393u, new RpcReceiveHandler(__rpc_handler_1698813393));
		NetworkManager.__rpc_func_table.Add(222697835u, new RpcReceiveHandler(__rpc_handler_222697835));
		NetworkManager.__rpc_func_table.Add(4282543262u, new RpcReceiveHandler(__rpc_handler_4282543262));
		NetworkManager.__rpc_func_table.Add(3414504546u, new RpcReceiveHandler(__rpc_handler_3414504546));
		NetworkManager.__rpc_func_table.Add(2300776769u, new RpcReceiveHandler(__rpc_handler_2300776769));
		NetworkManager.__rpc_func_table.Add(1122607531u, new RpcReceiveHandler(__rpc_handler_1122607531));
	}

	private static void __rpc_handler_1698813393(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 num = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref num);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((CookieJar)(object)target).SendCookieServerRpc(num);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_222697835(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 amount = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref amount);
			target.__rpc_exec_stage = (__RpcExecStage)2;
			((CookieJar)(object)target).SendCookieClientRpc(amount);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_4282543262(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;
			((CookieJar)(object)target).RequestStateServerRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3414504546(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)2;
			((CookieJar)(object)target).RequestStateClientRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2300776769(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: 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_008c: 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_0055: Invalid comparison between Unknown and I4
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
		{
			if ((int)networkManager.LogLevel <= 1)
			{
				Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
			}
		}
		else
		{
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((CookieJar)(object)target).SendEatingServerRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1122607531(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)2;
			((CookieJar)(object)target).SendEatingClientRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	protected internal override string __getTypeName()
	{
		return "CookieJar";
	}
}
public class Mango : GrabbableObject
{
	[CompilerGenerated]
	private sealed class <StartEating>d__17 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Mango <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.eating = true;
				<>4__this.audioSource.PlayOneShot(eatSFX);
				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 <healOverTime>d__23 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PlayerControllerB player;

		public Mango <>4__this;

		private int <i>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				player.criticallyInjured = false;
				<i>5__1 = 0;
				break;
			case 1:
				<>1__state = -1;
				player.health = (int)Mathf.MoveTowards((float)player.health, 100f, 1f);
				HUDManager.Instance.UpdateHealthUI(player.health, false);
				<i>5__1++;
				break;
			}
			if (<i>5__1 < <>4__this.healingPerBite)
			{
				<>2__current = (object)new WaitForSeconds(1f / <>4__this.healingSpeed);
				<>1__state = 1;
				return true;
			}
			player.criticallyInjured = false;
			HUDManager.Instance.UpdateHealthUI(player.health, 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();
		}
	}

	public float eat = 0f;

	private float eatSpeed = 1f;

	private int healingPerBite = 200;

	private float healingSpeed = 20f;

	private int fullyEatenValue = 8;

	private bool fullyEaten = false;

	private bool eating = false;

	private Coroutine startEating;

	public static AudioClip finishedSFX;

	public static AudioClip eatSFX;

	private AudioSource audioSource;

	private PlayerControllerB previousPlayerHeldBy;

	private Material shader;

	private MeshFilter mesh;

	public override void Start()
	{
		((GrabbableObject)this).Start();
		shader = ((Renderer)((Component)this).gameObject.GetComponent<MeshRenderer>()).material;
		mesh = ((Component)this).GetComponent<MeshFilter>();
		audioSource = ((Component)this).gameObject.GetComponent<AudioSource>();
		if (!((NetworkBehaviour)this).IsServer)
		{
			RequestStateServerRpc();
		}
	}

	public override void Update()
	{
		((GrabbableObject)this).Update();
		if (eating)
		{
			if ((Object)(object)previousPlayerHeldBy == (Object)null || !base.isHeld || eat >= 1f)
			{
				eating = false;
			}
			float oldValue = eat;
			eat = Mathf.MoveTowards(eat, 1f, Time.deltaTime / eatSpeed);
			UpdateShader(oldValue);
		}
	}

	public override void ItemActivate(bool used, bool buttonDown = true)
	{
		((GrabbableObject)this).ItemActivate(used, buttonDown);
		if (!fullyEaten)
		{
			if (buttonDown)
			{
				base.isBeingUsed = true;
				previousPlayerHeldBy.activatingItem = true;
				previousPlayerHeldBy.playerBodyAnimator.SetBool("useTZPItem", true);
				startEating = ((MonoBehaviour)this).StartCoroutine(StartEating());
			}
			else
			{
				base.isBeingUsed = false;
				Stop();
			}
		}
	}

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

	public override void GrabItem()
	{
		((GrabbableObject)this).GrabItem();
		previousPlayerHeldBy = base.playerHeldBy;
	}

	public override void DiscardItem()
	{
		((GrabbableObject)this).DiscardItem();
		SendEat();
		Stop();
	}

	public void SendEat()
	{
		if (((NetworkBehaviour)this).IsOwner)
		{
			SendEatServerRpc(fullyEaten);
		}
	}

	public void UpdateShader(float oldValue)
	{
		if (!fullyEaten)
		{
			shader.SetFloat("_Eat", eat);
			if (((NetworkBehaviour)this).IsOwner && Mathf.Floor(eat) != Mathf.Floor(oldValue))
			{
				Stop();
				((MonoBehaviour)this).StartCoroutine(healOverTime(previousPlayerHeldBy));
				FinishedEating();
				SendEat();
			}
		}
	}

	public void FinishedEating()
	{
		fullyEaten = true;
		audioSource.PlayOneShot(finishedSFX);
		mesh.mesh = null;
		((GrabbableObject)this).SetScrapValue(fullyEatenValue);
		Stop();
	}

	[IteratorStateMachine(typeof(<healOverTime>d__23))]
	public IEnumerator healOverTime(PlayerControllerB player)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <healOverTime>d__23(0)
		{
			<>4__this = this,
			player = player
		};
	}

	public void Stop()
	{
		if (startEating != null)
		{
			((MonoBehaviour)this).StopCoroutine(startEating);
		}
		eating = false;
		if ((Object)(object)previousPlayerHeldBy != (Object)null)
		{
			previousPlayerHeldBy.activatingItem = false;
			previousPlayerHeldBy.playerBodyAnimator.SetBool("useTZPItem", false);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void SendEatServerRpc(bool finished)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: 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_0097: 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(4095707459u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref finished, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4095707459u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				SetEatClientRpc(finished);
			}
		}
	}

	[ClientRpc]
	public void SetEatClientRpc(bool finished)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: 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_0097: 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 != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2553325489u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref finished, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2553325489u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && finished)
			{
				FinishedEating();
			}
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void RequestStateServerRpc()
	{
		//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)
		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(17809223u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 17809223u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				RequestStateClientRpc();
			}
		}
	}

	[ClientRpc]
	public void RequestStateClientRpc()
	{
		//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)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1997154150u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1997154150u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && ((NetworkBehaviour)this).IsServer)
			{
				SendEatServerRpc(fullyEaten);
			}
		}
	}

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

	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeRPCS_Mango()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Expected O, but got Unknown
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		NetworkManager.__rpc_func_table.Add(4095707459u, new RpcReceiveHandler(__rpc_handler_4095707459));
		NetworkManager.__rpc_func_table.Add(2553325489u, new RpcReceiveHandler(__rpc_handler_2553325489));
		NetworkManager.__rpc_func_table.Add(17809223u, new RpcReceiveHandler(__rpc_handler_17809223));
		NetworkManager.__rpc_func_table.Add(1997154150u, new RpcReceiveHandler(__rpc_handler_1997154150));
	}

	private static void __rpc_handler_4095707459(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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			bool finished = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref finished, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((Mango)(object)target).SendEatServerRpc(finished);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2553325489(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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			bool eatClientRpc = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref eatClientRpc, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)2;
			((Mango)(object)target).SetEatClientRpc(eatClientRpc);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_17809223(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;
			((Mango)(object)target).RequestStateServerRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1997154150(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)2;
			((Mango)(object)target).RequestStateClientRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	protected internal override string __getTypeName()
	{
		return "Mango";
	}
}
public class PonyBase : GrabbableObject
{
	public enum AnimationState
	{
		Idle,
		Walking,
		Sitting,
		Held
	}

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

		private object <>2__current;

		public PonyBase <>4__this;

		private bool <isinship>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.agent = ((Component)<>4__this).gameObject.AddComponent<NavMeshAgent>();
				<>4__this.agent.areaMask = -1;
				((Behaviour)<>4__this.agent).enabled = false;
				<>4__this.AbleAgent(move: false);
				<>4__this.agent.speed = 3.5f;
				<>4__this.agent.angularSpeed = 720f;
				<>4__this.agent.acceleration = 8f;
				<>4__this.agent.stoppingDistance = 0.5f;
				<>4__this.agent.autoBraking = true;
				<>4__this.agent.autoRepath = true;
				<>4__this.agent.height = 1f;
				<>4__this.agent.baseOffset = 1.5f;
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<isinship>5__1 = <>4__this.isInShip(((Component)<>4__this).transform.position);
				((Behaviour)<>4__this.agent).enabled = true;
				if (<isinship>5__1)
				{
					<>4__this.AbleAgent(move: false);
					<>4__this.UpdateState(AnimationState.Sitting);
				}
				else
				{
					<>4__this.AbleAgent(move: true);
					if (<>4__this.isHostOrServer())
					{
						((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.NextMove());
					}
				}
				<>4__this.finishedLoading = true;
				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 <GetIntoShip>d__31 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public float wait;

		public PonyBase <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.canMove = false;
				<>2__current = (object)new WaitForSeconds(wait);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.UpdateState(AnimationState.Sitting);
				<>4__this.AbleAgent(move: false);
				((Component)<>4__this).transform.SetParent(StartOfRound.Instance.elevatorTransform, true);
				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 <NextMove>d__26 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PonyBase <>4__this;

		private Vector3 <pos>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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.AbleAgent(move: false);
				<>4__this.UpdateState(AnimationState.Idle);
				<>2__current = (object)new WaitForSeconds(Random.Range(<>4__this.waitInbetweenMoveCycles.x, <>4__this.waitInbetweenMoveCycles.y));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<pos>5__1 = RoundManager.Instance.GetNavMeshPosition(((Component)<>4__this).transform.position, RoundManager.Instance.navHit, -1f, -1);
				<>4__this.SetRandomDestination();
				<>4__this.SendDestinationServerRpc(<pos>5__1, <>4__this.destination);
				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();
		}
	}

	private AudioSource audio;

	public static AudioClip squeak;

	public float walkDistance = 10f;

	public float updatePath = 0f;

	public bool finishedLoading = false;

	public bool canMove = true;

	public NavMeshAgent agent;

	public NavMeshPath navmeshPath;

	public Vector3 destination;

	public float speed = 5f;

	public float moveTime;

	public Vector2 moveInterval = new Vector2(1f, 6f);

	public Vector2 waitInbetweenMoveCycles = new Vector2(0.5f, 1f);

	public int heldType = 1;

	private bool walking = false;

	private Animator ani;

	public static Collider shipCollider;

	public override void Start()
	{
		((GrabbableObject)this).Start();
		base.useCooldown = 0.2f;
		ani = ((Component)this).GetComponent<Animator>();
		ani.SetInteger("HeldType", heldType);
		audio = ((Component)this).GetComponent<AudioSource>();
		((MonoBehaviour)this).StartCoroutine(CheckAgent());
	}

	public override void ItemActivate(bool used, bool buttonDown = true)
	{
		((GrabbableObject)this).ItemActivate(used, buttonDown);
		ani.SetTrigger("Squish");
		audio.Stop();
		audio.PlayOneShot(squeak);
	}

	public override void Update()
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		baseUpdateFunction();
		if (!finishedLoading)
		{
			return;
		}
		Animator obj = ani;
		Vector3 velocity = agent.velocity;
		obj.SetBool("Walking", ((Vector3)(ref velocity)).magnitude > 0.01f && walking && canMove && !base.isHeld && agent.isOnNavMesh);
		if (!canMove || base.isHeld || !agent.isOnNavMesh)
		{
			return;
		}
		if (updatePath <= 0f)
		{
			agent.SetDestination(destination);
			updatePath = 0.2f + Random.Range(0f, 0.1f);
		}
		else
		{
			updatePath -= Time.deltaTime;
		}
		if (isHostOrServer())
		{
			if (moveTime <= 0f)
			{
				((MonoBehaviour)this).StartCoroutine(NextMove());
			}
			moveTime -= Time.deltaTime;
		}
	}

	public void baseUpdateFunction()
	{
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0262: 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_0214: Unknown result type (might be due to invalid IL or missing references)
		if (base.currentUseCooldown >= 0f)
		{
			base.currentUseCooldown -= Time.deltaTime;
		}
		if (((NetworkBehaviour)this).IsOwner)
		{
			if (base.isBeingUsed && base.itemProperties.requiresBattery)
			{
				if (base.insertedBattery.charge > 0f)
				{
					if (!base.itemProperties.itemIsTrigger)
					{
						Battery insertedBattery = base.insertedBattery;
						insertedBattery.charge -= Time.deltaTime / base.itemProperties.batteryUsage;
					}
				}
				else if (!base.insertedBattery.empty)
				{
					base.insertedBattery.empty = true;
					if (base.isBeingUsed)
					{
						Debug.Log((object)"Use up batteries local");
						base.isBeingUsed = false;
						((GrabbableObject)this).UseUpBatteries();
					}
				}
			}
			if (!base.wasOwnerLastFrame)
			{
				base.wasOwnerLastFrame = true;
			}
		}
		else if (base.wasOwnerLastFrame)
		{
			base.wasOwnerLastFrame = false;
		}
		if (base.isHeld || !((Object)(object)base.parentObject == (Object)null))
		{
			return;
		}
		if (base.fallTime < 1f)
		{
			base.reachedFloorTarget = false;
			((GrabbableObject)this).FallWithCurve();
			if (((Component)this).transform.localPosition.y - base.targetFloorPosition.y < 0.1f && !base.hasHitGround)
			{
				((GrabbableObject)this).PlayDropSFX();
				((GrabbableObject)this).OnHitGround();
			}
		}
		else if (!base.reachedFloorTarget)
		{
			base.reachedFloorTarget = true;
			if (base.floorYRot == -1)
			{
				((Component)this).transform.rotation = Quaternion.Euler(base.itemProperties.restingRotation.x, ((Component)this).transform.eulerAngles.y, base.itemProperties.restingRotation.z);
			}
			else
			{
				((Component)this).transform.rotation = Quaternion.Euler(base.itemProperties.restingRotation.x, (float)(base.floorYRot + base.itemProperties.floorYOffset) + 90f, base.itemProperties.restingRotation.z);
			}
		}
	}

	public override void DiscardItem()
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		((GrabbableObject)this).DiscardItem();
		bool flag = !isInShip(((Component)this).transform.position) && StartOfRound.Instance.currentLevel.levelID != 0;
		AbleAgent(move: false);
		if (flag)
		{
			((MonoBehaviour)this).StartCoroutine(NextMove());
		}
		else
		{
			UpdateState(AnimationState.Sitting, ignoreServer: true);
		}
	}

	public override void GrabItem()
	{
		((GrabbableObject)this).GrabItem();
		((MonoBehaviour)this).StopAllCoroutines();
		UpdateState(AnimationState.Held, ignoreServer: true);
		AbleAgent(move: false);
	}

	public void UpdateState(AnimationState newState, bool ignoreServer = false)
	{
		if (isHostOrServer())
		{
			SendAnimationServerRpc(newState);
		}
		ani.SetBool("Sitting", false);
		ani.SetBool("Walking", false);
		ani.SetBool("Held", false);
		walking = false;
		switch (newState)
		{
		case AnimationState.Walking:
			walking = true;
			break;
		case AnimationState.Sitting:
			ani.SetBool("Sitting", true);
			break;
		case AnimationState.Held:
			ani.SetBool("Held", true);
			break;
		case AnimationState.Idle:
			ani.SetTrigger("Idle");
			break;
		}
	}

	public void AbleAgent(bool move)
	{
		if (isHostOrServer())
		{
			SendAgentMoveServerRpc(move);
		}
		agent.updatePosition = move;
		agent.updateRotation = move;
		canMove = move;
	}

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

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

	public bool FindPath(Vector3 position)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: 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)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		destination = RoundManager.Instance.GetNavMeshPosition(position, RoundManager.Instance.navHit, 5f, -1);
		agent.SetDestination(destination);
		return true;
	}

	public bool isInShip(Vector3 point)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: 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)
		if ((Object)(object)shipCollider == (Object)null)
		{
			shipCollider = StartOfRound.Instance.shipBounds;
		}
		Bounds bounds = shipCollider.bounds;
		return ((Bounds)(ref bounds)).Contains(point);
	}

	public void SetRandomDestination()
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: 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_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		for (int num = 5; num > 0; num--)
		{
			Vector3 position = ((Component)this).transform.position + Vector2.op_Implicit(Random.insideUnitCircle) * walkDistance;
			if (FindPath(position))
			{
				break;
			}
		}
		if (isInShip(destination))
		{
			GetIntoShipServerRpc(agent.remainingDistance / agent.speed + 1f);
		}
	}

	[IteratorStateMachine(typeof(<GetIntoShip>d__31))]
	public IEnumerator GetIntoShip(float wait)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <GetIntoShip>d__31(0)
		{
			<>4__this = this,
			wait = wait
		};
	}

	public bool isHostOrServer()
	{
		return ((NetworkBehaviour)this).IsOwner;
	}

	[ServerRpc]
	public void SendDestinationServerRpc(Vector3 position, Vector3 destination)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Invalid comparison between Unknown and I4
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Invalid comparison between Unknown and I4
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			ServerRpcParams val = default(ServerRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4061055872u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
			((FastBufferWriter)(ref val2)).WriteValueSafe(ref destination);
			((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4061055872u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			SetDestinationClientRpc(position, destination);
		}
	}

	[ClientRpc]
	public void SetDestinationClientRpc(Vector3 position, Vector3 dest)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: 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_0096: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: 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 != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1275489729u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref dest);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1275489729u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && finishedLoading)
			{
				destination = dest;
				agent.Warp(RoundManager.Instance.GetNavMeshPosition(position, RoundManager.Instance.navHit, 3f, -1));
				AbleAgent(move: true);
				UpdateState(AnimationState.Walking, ignoreServer: true);
				((Behaviour)agent).enabled = true;
				moveTime = Random.Range(moveInterval.x, moveInterval.y);
			}
		}
	}

	[ServerRpc]
	public void GetIntoShipServerRpc(float time)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Invalid comparison between Unknown and I4
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: 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)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Invalid comparison between Unknown and I4
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			ServerRpcParams val = defa