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

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class ValuableExplosivo : Trap
{
	private class TriggerInternoExplosivo : MonoBehaviour
	{
		private ValuableExplosivo explosivo;

		public void Inicializar(ValuableExplosivo referencia)
		{
			explosivo = referencia;
		}

		private void OnTriggerEnter(Collider other)
		{
			if (!((Object)(object)explosivo == (Object)null))
			{
				PlayerController componentInParent = ((Component)other).GetComponentInParent<PlayerController>();
				PlayerAvatar componentInParent2 = ((Component)other).GetComponentInParent<PlayerAvatar>();
				PhysGrabObject componentInParent3 = ((Component)other).GetComponentInParent<PhysGrabObject>();
				bool flag = (Object)(object)componentInParent3 != (Object)null && componentInParent3.isEnemy;
				if ((Object)(object)componentInParent != (Object)null || (Object)(object)componentInParent2 != (Object)null || flag)
				{
					explosivo.AtivarPorTrigger();
				}
			}
		}
	}

	[Header("Áudio")]
	public AudioSource somPrincipal;

	public AudioSource somDirecional;

	public AudioClip somAlarme;

	public AudioClip somExplosao;

	[Header("Explosão")]
	public float chanceExplodir = 1f;

	public float raioExplosao = 0.35f;

	public int dano = 120;

	public int danoInimigo = 200;

	public float forcaExplosao = 1.2f;

	[Header("Alerta Inimigo")]
	public float alcanceSom = 15f;

	public float alcanceExplosao = 60f;

	[Header("Trigger")]
	public Collider triggerColisor;

	[Header("Partículas")]
	public GameObject explosaoPrefab;

	private Rigidbody rb;

	private PhysGrabObjectImpactDetector detectorImpacto;

	private float ultimoToque = -999f;

	public float intervaloToque = 0.2f;

	private bool explodido = false;

	public override void Start()
	{
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Expected O, but got Unknown
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Expected O, but got Unknown
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Expected O, but got Unknown
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Expected O, but got Unknown
		((Trap)this).Start();
		rb = ((Component)this).GetComponent<Rigidbody>();
		detectorImpacto = ((Component)this).GetComponent<PhysGrabObjectImpactDetector>();
		if ((Object)(object)somPrincipal == (Object)null)
		{
			somPrincipal = ((Component)this).GetComponent<AudioSource>();
		}
		if ((Object)(object)somDirecional == (Object)null && (Object)(object)((Component)this).transform.Find("SomDirecional") != (Object)null)
		{
			somDirecional = ((Component)((Component)this).transform.Find("SomDirecional")).GetComponent<AudioSource>();
		}
		if ((Object)(object)detectorImpacto != (Object)null)
		{
			detectorImpacto.onImpactMedium.RemoveListener(new UnityAction(ImpactoMedio));
			detectorImpacto.onImpactHeavy.RemoveListener(new UnityAction(ImpactoForte));
			detectorImpacto.onImpactMedium.AddListener(new UnityAction(ImpactoMedio));
			detectorImpacto.onImpactHeavy.AddListener(new UnityAction(ImpactoForte));
		}
		if ((Object)(object)triggerColisor != (Object)null)
		{
			((Component)triggerColisor).gameObject.AddComponent<TriggerInternoExplosivo>().Inicializar(this);
		}
	}

	private void OnDestroy()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Expected O, but got Unknown
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Expected O, but got Unknown
		if ((Object)(object)detectorImpacto != (Object)null)
		{
			detectorImpacto.onImpactMedium.RemoveListener(new UnityAction(ImpactoMedio));
			detectorImpacto.onImpactHeavy.RemoveListener(new UnityAction(ImpactoForte));
		}
	}

	private void ImpactoMedio()
	{
		TocarAlarme("ImpactoMédio");
	}

	private void ImpactoForte()
	{
		TocarAlarme("ImpactoForte");
	}

	private void TocarAlarme(string tipo)
	{
		if (!explodido && !(Time.time - ultimoToque < intervaloToque))
		{
			ultimoToque = Time.time;
			TocarSom();
			if (SemiFunc.IsMultiplayer() && (Object)(object)base.photonView != (Object)null)
			{
				base.photonView.RPC("RPC_ReproduzirSom", (RpcTarget)1, new object[1] { tipo });
			}
		}
	}

	public void AtivarPorTrigger()
	{
		if (!explodido && !(Time.time - ultimoToque < intervaloToque))
		{
			ultimoToque = Time.time;
			TocarSom();
			if (SemiFunc.IsMultiplayer() && (Object)(object)base.photonView != (Object)null)
			{
				base.photonView.RPC("RPC_ReproduzirSom", (RpcTarget)1, new object[1] { "Trigger" });
			}
		}
	}

	private void TocarSom()
	{
		AudioSource val = (((Object)(object)somDirecional != (Object)null) ? somDirecional : somPrincipal);
		if ((Object)(object)val != (Object)null && (Object)(object)somAlarme != (Object)null)
		{
			val.maxDistance = alcanceSom;
			val.PlayOneShot(somAlarme);
		}
	}

	[PunRPC]
	public void RPC_ReproduzirSom(string tipo)
	{
		if (!explodido)
		{
			TocarSom();
			if (Random.value < chanceExplodir)
			{
				explodido = true;
				Explodir();
			}
			else
			{
				base.enemyInvestigate = true;
				base.enemyInvestigateRange = alcanceSom;
			}
		}
	}

	private void Explodir()
	{
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		Debug.Log((object)"[ValuableExplosivo] Explodiu!");
		if ((Object)(object)somPrincipal != (Object)null && (Object)(object)somExplosao != (Object)null)
		{
			somPrincipal.maxDistance = alcanceExplosao;
			somPrincipal.PlayOneShot(somExplosao);
		}
		if ((Object)(object)explosaoPrefab != (Object)null)
		{
			GameObject val = Object.Instantiate<GameObject>(explosaoPrefab, ((Component)this).transform.position, Quaternion.identity);
			Object.Destroy((Object)(object)val, 5f);
		}
		Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, raioExplosao);
		Collider[] array2 = array;
		foreach (Collider val2 in array2)
		{
			Rigidbody attachedRigidbody = val2.attachedRigidbody;
			if ((Object)(object)attachedRigidbody != (Object)null)
			{
				attachedRigidbody.AddExplosionForce(500f * forcaExplosao, ((Component)this).transform.position, raioExplosao);
			}
			PlayerAvatar componentInParent = ((Component)val2).GetComponentInParent<PlayerAvatar>();
			if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.playerHealth != (Object)null)
			{
				componentInParent.playerHealth.health = Mathf.Max(0, componentInParent.playerHealth.health - dano);
			}
			PhysGrabObject componentInParent2 = ((Component)val2).GetComponentInParent<PhysGrabObject>();
			if ((Object)(object)componentInParent2 != (Object)null && componentInParent2.isEnemy && !componentInParent2.dead)
			{
				componentInParent2.dead = true;
			}
		}
		base.enemyInvestigate = true;
		base.enemyInvestigateRange = alcanceExplosao;
		if ((Object)(object)base.physGrabObject != (Object)null)
		{
			base.physGrabObject.dead = true;
		}
	}
}
public class Armadilha1 : Trap
{
	[Header("Visuais")]
	public ParticleSystem particulasAtivacao;

	public AudioClip somAlto;

	public float volumeSom = 1f;

	public float alcanceAlerta = 50f;

	[Header("Áudio")]
	public AudioSource fonteAudio;

	[Header("Câmera")]
	public float intensidadeCamera = 2.5f;

	public float tempoShake = 0.5f;

	public float distanciaMin = 4f;

	public float distanciaMax = 12f;

	[Header("Tempo de efeito")]
	public float duracaoParticula = 3f;

	public float duracaoSom = 3f;

	private bool efeitoParticulaAtivo = false;

	private bool efeitoSomAtivo = false;

	private bool cameraTremendo = false;

	private bool armadilhaAtiva = false;

	private float cronometroParticula = 0f;

	private float cronometroSom = 0f;

	private PhysGrabObject pegaObjeto;

	private bool segurandoAntes = false;

	public override void Start()
	{
		((Trap)this).Start();
		if ((Object)(object)fonteAudio == (Object)null)
		{
			fonteAudio = ((Component)this).GetComponent<AudioSource>();
			if ((Object)(object)fonteAudio == (Object)null)
			{
				fonteAudio = ((Component)this).gameObject.AddComponent<AudioSource>();
				fonteAudio.spatialBlend = 1f;
			}
		}
		pegaObjeto = ((Component)this).GetComponent<PhysGrabObject>();
	}

	public override void Update()
	{
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		((Trap)this).Update();
		bool flag = (Object)(object)pegaObjeto != (Object)null && pegaObjeto.grabbed;
		if (!armadilhaAtiva && !base.trapTriggered && flag)
		{
			((Trap)this).TrapActivateSync();
			base.trapTriggered = true;
			base.trapStart = true;
			DispararArmadilha();
			armadilhaAtiva = true;
		}
		if (base.trapTriggered && !flag && segurandoAntes && !armadilhaAtiva)
		{
			base.trapTriggered = false;
			base.trapStart = false;
		}
		segurandoAntes = flag;
		if (efeitoParticulaAtivo && (Object)(object)particulasAtivacao != (Object)null)
		{
			cronometroParticula += Time.deltaTime;
			if (cronometroParticula >= duracaoParticula)
			{
				particulasAtivacao.Stop(true, (ParticleSystemStopBehavior)1);
				efeitoParticulaAtivo = false;
			}
		}
		if (efeitoSomAtivo && (Object)(object)fonteAudio != (Object)null)
		{
			cronometroSom += Time.deltaTime;
			if (cronometroSom >= duracaoSom)
			{
				fonteAudio.Stop();
				efeitoSomAtivo = false;
			}
		}
		if (cameraTremendo)
		{
			if ((Object)(object)GameDirector.instance?.CameraImpact != (Object)null)
			{
				GameDirector.instance.CameraImpact.ShakeDistance(intensidadeCamera, distanciaMin, distanciaMax, ((Component)this).transform.position, 0.2f);
			}
			if (!efeitoParticulaAtivo && !efeitoSomAtivo)
			{
				cameraTremendo = false;
			}
		}
		if (armadilhaAtiva && !efeitoParticulaAtivo && !efeitoSomAtivo && !cameraTremendo && !flag)
		{
			armadilhaAtiva = false;
			base.trapTriggered = false;
			base.trapStart = false;
		}
	}

	private void DispararArmadilha()
	{
		if ((Object)(object)particulasAtivacao != (Object)null)
		{
			particulasAtivacao.Play();
			efeitoParticulaAtivo = true;
			cronometroParticula = 0f;
		}
		if ((Object)(object)somAlto != (Object)null && (Object)(object)fonteAudio != (Object)null)
		{
			fonteAudio.PlayOneShot(somAlto, volumeSom);
			efeitoSomAtivo = true;
			cronometroSom = 0f;
		}
		cameraTremendo = true;
		base.enemyInvestigate = true;
		base.enemyInvestigateRange = alcanceAlerta;
	}
}
public class FalarCustomizado : MonoBehaviourPun
{
	private enum EstadoDeFala
	{
		Silencioso,
		Tagarelando
	}

	public PhysGrabObject objetoFalante;

	[Header("Frases Personalizadas")]
	[Tooltip("Frases que o objeto pode dizer ao ser pego")]
	public string[] frasesEngracadas = new string[5] { "I may be small, but I’m full of energy!", "Being happy is my superpower!", "Time for some splashy fun!", "Everything's more fun with friends!", "Let’s go on an adventure!" };

	private float tempoDeReativacao = 0.5f;

	private EstadoDeFala estadoAtual = EstadoDeFala.Silencioso;

	private void Start()
	{
		if ((Object)(object)objetoFalante == (Object)null)
		{
			objetoFalante = ((Component)this).GetComponent<PhysGrabObject>();
		}
	}

	private void Update()
	{
		if (SemiFunc.IsMultiplayer())
		{
			AtualizarEstadoDeFala();
		}
	}

	private void AtualizarEstadoDeFala()
	{
		switch (estadoAtual)
		{
		case EstadoDeFala.Silencioso:
			ChecarPegadaInicial();
			break;
		case EstadoDeFala.Tagarelando:
			VerificarSeSoltou();
			break;
		}
	}

	private void ChecarPegadaInicial()
	{
		if (tempoDeReativacao > 0f && objetoFalante.grabbed)
		{
			tempoDeReativacao -= Time.deltaTime;
		}
		else if ((Object)(object)PhysGrabber.instance != (Object)null && PhysGrabber.instance.grabbed && (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject == (Object)(object)objetoFalante)
		{
			estadoAtual = EstadoDeFala.Tagarelando;
			ExibirFraseNoChat();
		}
	}

	private void VerificarSeSoltou()
	{
		if (!ChatManager.instance.StateIsPossessed() || (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject != (Object)(object)objetoFalante)
		{
			estadoAtual = EstadoDeFala.Silencioso;
			tempoDeReativacao = Random.Range(1f, 3f);
		}
	}

	private void ExibirFraseNoChat()
	{
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		if (frasesEngracadas != null && frasesEngracadas.Length != 0)
		{
			string text = frasesEngracadas[Random.Range(0, frasesEngracadas.Length)];
			Color val = default(Color);
			((Color)(ref val))..ctor(0.05f, 0.68f, 0.68f, 1f);
			ChatManager.instance.PossessChatScheduleStart(10);
			ChatManager.instance.PossessChat((PossessChatID)0, text, 3f, val, 0f, false, 0, (UnityEvent)null);
			ChatManager.instance.PossessChatScheduleEnd();
		}
	}
}
public class PulinPulin : Trap
{
	public float impulsoVertical = 6f;

	public float impulsoFrontal = 3f;

	public float intervaloEntreSaltos = 0.25f;

	public AudioSource somSource;

	public AudioClip somPulo;

	[Header("Atrair Inimigos")]
	public float raioDeAlerta = 7f;

	private Rigidbody corpo;

	private PhysGrabObjectImpactDetector impactoDetector;

	private float momentoUltimoPulo = -999f;

	public override void Start()
	{
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Expected O, but got Unknown
		((Trap)this).Start();
		corpo = ((Component)this).GetComponent<Rigidbody>();
		impactoDetector = ((Component)this).GetComponent<PhysGrabObjectImpactDetector>();
		if ((Object)(object)somSource == (Object)null)
		{
			somSource = ((Component)this).GetComponent<AudioSource>();
		}
		if ((Object)(object)impactoDetector != (Object)null)
		{
			impactoDetector.onAllImpacts.AddListener(new UnityAction(QuandoBate));
		}
	}

	private void OnDestroy()
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Expected O, but got Unknown
		if ((Object)(object)impactoDetector != (Object)null)
		{
			impactoDetector.onAllImpacts.RemoveListener(new UnityAction(QuandoBate));
		}
	}

	private void QuandoBate()
	{
		if (!(Time.time - momentoUltimoPulo < intervaloEntreSaltos))
		{
			momentoUltimoPulo = Time.time;
			FazerPulo();
			if (SemiFunc.IsMultiplayer() && (Object)(object)base.photonView != (Object)null)
			{
				base.photonView.RPC("SincronizarSalto", (RpcTarget)1, Array.Empty<object>());
			}
		}
	}

	[PunRPC]
	public void SincronizarSalto()
	{
		FazerPulo();
	}

	private void FazerPulo()
	{
		//IL_001c: 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_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: 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)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)corpo == (Object)null))
		{
			corpo.velocity = Vector3.zero;
			corpo.angularVelocity = Vector3.zero;
			Vector3 val = Vector3.up * impulsoVertical + ((Component)this).transform.forward * impulsoFrontal;
			corpo.AddForce(val, (ForceMode)1);
			if ((Object)(object)somSource != (Object)null && (Object)(object)somPulo != (Object)null)
			{
				somSource.PlayOneShot(somPulo);
			}
			base.enemyInvestigate = true;
			base.enemyInvestigateRange = raioDeAlerta;
		}
	}
}
public class X0 : MonoBehaviour
{
}
[BepInPlugin("x.y.z.ctrlrev", "CTRL_REVERT", "1.0.0")]
public class Y0 : BaseUnityPlugin
{
	[HarmonyPatch(typeof(SemiFunc), "InputMovementX")]
	public class Z1
	{
		private static void Postfix(ref float __result)
		{
			if (a1)
			{
				__result = 0f - __result;
			}
		}
	}

	[HarmonyPatch(typeof(SemiFunc), "InputMovementY")]
	public class Z2
	{
		private static void Postfix(ref float __result)
		{
			if (a1)
			{
				__result = 0f - __result;
			}
		}
	}

	[HarmonyPatch(typeof(PlayerController), "FixedUpdate")]
	public class Z3
	{
		private static void Prefix(PlayerController __instance)
		{
			bool v = false;
			GameObject physGrabObject = __instance.physGrabObject;
			if ((Object)(object)physGrabObject != (Object)null && (Object)(object)physGrabObject.GetComponent<X0>() != (Object)null)
			{
				v = true;
			}
			b1(v);
		}
	}

	private static bool a1;

	private void Awake()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		new Harmony("x.y.z.ctrlrev").PatchAll();
	}

	public static void b1(bool v)
	{
		a1 = v;
	}
}
public class ValuableSpawnador : MonoBehaviour
{
	public Transform SpawnPoint;

	public GameObject ValuablePrefab;

	public void FalarnoChat()
	{
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		List<string> list = new List<string>
		{
			"This feels ominous", "I have a bad feeling about this", "I don't think we should be doing this", "I'm scared", "I think we should just leave it", "I feel like something bad's about to happen", "Guys I don't know about this", "That sent a chill through my circuits", "We shouldn't break this open", "It feels... angry",
			"Oh why does it feel like this thing is mad at me", "I don't think the treasure inside is worth it", "Today feels a little worse"
		};
		string text = list[Random.Range(0, list.Count)];
		ChatManager.instance.PossessChatScheduleStart(10);
		ChatManager.instance.PossessChat((PossessChatID)4, text, 0.7f, Color.red, 0f, false, 0, (UnityEvent)null);
		ChatManager.instance.PossessChatScheduleEnd();
	}

	public void Spawn()
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		if (!SemiFunc.IsMultiplayer())
		{
			Object.Instantiate<GameObject>(ValuablePrefab, SpawnPoint.position, Quaternion.identity);
		}
		else
		{
			PhotonNetwork.InstantiateRoomObject("Valuables/" + ((Object)ValuablePrefab).name, SpawnPoint.position, Quaternion.identity, (byte)0, (object[])null);
		}
	}
}
public class CuraValiosa : MonoBehaviour
{
	[Header("Componentes")]
	private PhysGrabObject physGrabObject;

	[Header("Configuração da Cura")]
	public float quantidadeDeCura = 10f;

	public float intervaloDeCura = 2f;

	[Header("Limites de Uso")]
	public bool usoInfinito = false;

	public int maxCurativos = 10;

	private int curativosAtuais = 0;

	private float timer;

	private PlayerHealth targetHealth;

	private bool isBeingHeld = false;

	private void Start()
	{
		physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
		if ((Object)(object)physGrabObject == (Object)null)
		{
			Debug.LogError((object)"ERRO EM CURAVALIOSA: Componente PhysGrabObject não encontrado!");
		}
	}

	private void LateUpdate()
	{
		if (physGrabObject.grabbed && !isBeingHeld)
		{
			isBeingHeld = true;
			timer = intervaloDeCura;
		}
		else if (!physGrabObject.grabbed && isBeingHeld)
		{
			isBeingHeld = false;
			targetHealth = null;
		}
		if (!isBeingHeld)
		{
			return;
		}
		if ((Object)(object)targetHealth == (Object)null)
		{
			TryToFindTargetHealth();
		}
		if ((Object)(object)targetHealth != (Object)null && (usoInfinito || curativosAtuais < maxCurativos))
		{
			timer -= Time.deltaTime;
			if (timer <= 0f)
			{
				timer = intervaloDeCura;
				CurarJogador();
			}
		}
	}

	private void TryToFindTargetHealth()
	{
		if (physGrabObject.playerGrabbing.Count == 0)
		{
			return;
		}
		foreach (PhysGrabber item in physGrabObject.playerGrabbing)
		{
			if ((Object)(object)item != (Object)null && (item.photonView.IsMine || !PhotonNetwork.IsConnected) && (Object)(object)item.playerAvatar != (Object)null)
			{
				targetHealth = ((Component)item.playerAvatar).GetComponentInChildren<PlayerHealth>(true);
				if ((Object)(object)targetHealth != (Object)null)
				{
					Debug.Log((object)"SUCESSO: Alvo de cura [PlayerHealth] encontrado e armazenado!");
					break;
				}
			}
		}
	}

	private void CurarJogador()
	{
		if (!((Object)(object)targetHealth == (Object)null))
		{
			int num = Mathf.RoundToInt(quantidadeDeCura);
			targetHealth.health = Mathf.Min(targetHealth.health + num, targetHealth.maxHealth);
			if (!usoInfinito)
			{
				curativosAtuais++;
			}
			Debug.Log((object)string.Format("Jogador curado em {0}. Usos restantes: {1}", num, usoInfinito ? "Infinito" : ((object)(maxCurativos - curativosAtuais))));
		}
	}
}
public class AleatorioMexer : MonoBehaviour
{
	private PhysGrabObject physGrabObject;

	public float minScale = 0.5f;

	public float maxScale = 2f;

	public float changeInterval = 0.2f;

	private Vector3 originalScale;

	private float timer;

	private void Start()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
		originalScale = ((Component)this).transform.localScale;
		timer = 0f;
	}

	private void Update()
	{
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		if (physGrabObject.grabbed)
		{
			timer -= Time.deltaTime;
			if (timer <= 0f)
			{
				timer = changeInterval;
				float num = Random.Range(minScale, maxScale);
				float num2 = Random.Range(minScale, maxScale);
				float num3 = Random.Range(minScale, maxScale);
				((Component)this).transform.localScale = new Vector3(num, num2, num3);
			}
		}
		else
		{
			((Component)this).transform.localScale = originalScale;
			timer = 0f;
		}
	}
}
public class AnimCimaBaixo : MonoBehaviour
{
	public float floatAmplitude = 0.5f;

	public float floatFrequency = 1f;

	public float baseHeightOffset = 0f;

	public float minDistanceToGround = 0.02f;

	public float raycastDistance = 1.5f;

	private Vector3 initialWorldPosition;

	private PhysGrabObject grabObject;

	private Rigidbody rb;

	private Collider col;

	private void Start()
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		grabObject = ((Component)this).GetComponent<PhysGrabObject>();
		rb = ((Component)this).GetComponent<Rigidbody>();
		col = ((Component)this).GetComponent<Collider>();
		initialWorldPosition = ((Component)this).transform.position + Vector3.up * baseHeightOffset;
		if ((Object)(object)rb != (Object)null)
		{
			rb.isKinematic = true;
			rb.useGravity = false;
		}
		if ((Object)(object)col != (Object)null)
		{
			col.enabled = false;
		}
	}

	private void Update()
	{
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: 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_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: 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_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: 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_0090: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)grabObject != (Object)null) || !grabObject.grabbed)
		{
			float num = Mathf.Sin(Time.time * floatFrequency) * floatAmplitude;
			Vector3 val = initialWorldPosition + new Vector3(0f, num, 0f);
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(val, Vector3.down, ref val2, raycastDistance, -1, (QueryTriggerInteraction)1))
			{
				float num2 = ((RaycastHit)(ref val2)).point.y + minDistanceToGround;
				if (val.y < num2)
				{
					val.y = num2;
				}
			}
			((Component)this).transform.position = val;
			if ((Object)(object)rb != (Object)null)
			{
				rb.isKinematic = true;
				rb.useGravity = false;
			}
			if ((Object)(object)col != (Object)null)
			{
				col.enabled = false;
			}
		}
		else
		{
			initialWorldPosition = ((Component)this).transform.position + Vector3.up * baseHeightOffset;
			if ((Object)(object)rb != (Object)null)
			{
				rb.isKinematic = false;
				rb.useGravity = true;
			}
			if ((Object)(object)col != (Object)null)
			{
				col.enabled = true;
			}
		}
	}
}
public class AnimGirar : MonoBehaviour
{
	public Vector3 rotationSpeed = new Vector3(0f, 90f, 0f);

	private void Update()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.Rotate(rotationSpeed * Time.deltaTime);
	}
}
public class AnimPulse : MonoBehaviour
{
	[Header("Configurações de Pulso")]
	public Vector3 maxScale = new Vector3(1.5f, 1.5f, 1.5f);

	public float pulseDuration = 1f;

	private Vector3 originalScale;

	private float timer;

	private void Start()
	{
		//IL_0008: 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)
		originalScale = ((Component)this).transform.localScale;
	}

	private void Update()
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		timer += Time.deltaTime;
		float num = Mathf.PingPong(timer / pulseDuration, 1f);
		((Component)this).transform.localScale = Vector3.Lerp(originalScale, maxScale, num);
	}
}
public class TiroAutomatico : MonoBehaviour
{
	private PhysGrabObject physGrabObject;

	private ItemToggle itemToggle;

	public int numberOfBullets = 1;

	[Range(0f, 65f)]
	public float gunRandomSpread;

	public float gunRange = 50f;

	public float distanceKeep = 0.8f;

	public float gunRecoilForce = 1f;

	public float cameraShakeMultiplier = 1f;

	public float torqueMultiplier = 1f;

	public float grabStrengthMultiplier = 1f;

	public float shootCooldown = 1f;

	public float batteryDrain = 0.1f;

	public bool batteryDrainFullBar;

	public int batteryDrainFullBars = 1;

	[Range(0f, 100f)]
	public float misfirePercentageChange = 50f;

	public AnimationCurve shootLineWidthCurve;

	public float grabVerticalOffset = -0.2f;

	public float aimVerticalOffset = -10f;

	public float investigateRadius = 20f;

	public Transform gunMuzzle;

	public GameObject bulletPrefab;

	public GameObject muzzleFlashPrefab;

	public Transform gunTrigger;

	public Sound soundShoot;

	public Sound soundShootGlobal;

	public Sound soundNoAmmoClick;

	public Sound soundHit;

	private float shootCooldownTimer;

	private ItemBattery itemBattery;

	private PhotonView photonView;

	private PhysGrabObjectImpactDetector impactDetector;

	private AnimationCurve triggerAnimationCurve;

	private float triggerAnimationEval;

	private bool triggerAnimationActive;

	private void Start()
	{
		physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
		itemToggle = ((Component)this).GetComponent<ItemToggle>();
		itemBattery = ((Component)this).GetComponent<ItemBattery>();
		photonView = ((Component)this).GetComponent<PhotonView>();
		impactDetector = ((Component)this).GetComponent<PhysGrabObjectImpactDetector>();
		triggerAnimationCurve = AssetManager.instance.animationCurveClickInOut;
	}

	private void Update()
	{
		if (physGrabObject.grabbed && physGrabObject.grabbedLocal)
		{
			PhysGrabber.instance.OverrideGrabDistance(distanceKeep);
		}
		UpdateTriggerAnimation();
		if (physGrabObject.grabbedLocal && IsUseInputHeld())
		{
			itemToggle.toggleState = true;
			if (shootCooldownTimer <= 0f)
			{
				Shoot();
				shootCooldownTimer = shootCooldown;
			}
		}
		else
		{
			itemToggle.toggleState = false;
		}
		if (shootCooldownTimer > 0f)
		{
			shootCooldownTimer -= Time.deltaTime;
		}
		UpdateOnlyMaster();
	}

	private void UpdateTriggerAnimation()
	{
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		if (triggerAnimationActive)
		{
			float num = 45f;
			triggerAnimationEval += Time.deltaTime * 4f;
			gunTrigger.localRotation = Quaternion.Euler(num * triggerAnimationCurve.Evaluate(triggerAnimationEval), 0f, 0f);
			if (triggerAnimationEval >= 1f)
			{
				gunTrigger.localRotation = Quaternion.Euler(0f, 0f, 0f);
				triggerAnimationActive = false;
				triggerAnimationEval = 1f;
			}
		}
	}

	private void UpdateOnlyMaster()
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		if (!SemiFunc.IsMasterClientOrSingleplayer() || !physGrabObject.grabbed)
		{
			return;
		}
		Quaternion val = Quaternion.Euler(aimVerticalOffset, 0f, 0f);
		Quaternion val2 = Quaternion.Euler(0f, 0f, 0f);
		Quaternion identity = Quaternion.identity;
		bool flag = false;
		bool flag2 = false;
		bool flag3 = true;
		foreach (PhysGrabber item in physGrabObject.playerGrabbing)
		{
			if (flag3)
			{
				if (item.playerAvatar.isCrouching || item.playerAvatar.isCrawling)
				{
					flag2 = true;
				}
				flag3 = false;
			}
			if (item.isRotating)
			{
				flag = true;
			}
		}
		if (!flag)
		{
			physGrabObject.TurnXYZ(val, val2, identity);
		}
		float num = grabVerticalOffset;
		if (flag2)
		{
			num += 0.5f;
		}
		physGrabObject.OverrideGrabVerticalPosition(num);
		if (!flag)
		{
			if (grabStrengthMultiplier != 1f)
			{
				physGrabObject.OverrideGrabStrength(grabStrengthMultiplier, 0.1f);
			}
			if (torqueMultiplier != 1f)
			{
				physGrabObject.OverrideTorqueStrength(torqueMultiplier, 0.1f);
			}
			if (itemBattery.batteryLife <= 0f)
			{
				physGrabObject.OverrideTorqueStrength(0.1f, 0.1f);
			}
		}
		else
		{
			physGrabObject.OverrideAngularDrag(40f, 0.1f);
			physGrabObject.OverrideTorqueStrength(6f, 0.1f);
		}
	}

	public void Shoot()
	{
		if (!(itemBattery.batteryLife <= 0f) || Random.Range(0, 10000) == 0)
		{
			if (SemiFunc.IsMultiplayer())
			{
				photonView.RPC("ShootRPC", (RpcTarget)0, Array.Empty<object>());
			}
			else
			{
				ShootRPC();
			}
		}
	}

	[PunRPC]
	public void ShootRPC()
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: 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_0187: Unknown result type (might be due to invalid IL or missing references)
		//IL_018c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0287: Unknown result type (might be due to invalid IL or missing references)
		//IL_028c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0294: Unknown result type (might be due to invalid IL or missing references)
		//IL_0299: Unknown result type (might be due to invalid IL or missing references)
		//IL_029e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_023c: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		//IL_024c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0251: Unknown result type (might be due to invalid IL or missing references)
		//IL_0255: Unknown result type (might be due to invalid IL or missing references)
		//IL_0257: Unknown result type (might be due to invalid IL or missing references)
		//IL_025c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0260: 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_0267: Unknown result type (might be due to invalid IL or missing references)
		//IL_0269: Unknown result type (might be due to invalid IL or missing references)
		//IL_026e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0270: Unknown result type (might be due to invalid IL or missing references)
		//IL_0275: Unknown result type (might be due to invalid IL or missing references)
		//IL_0279: Unknown result type (might be due to invalid IL or missing references)
		//IL_027e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
		float num = 3f * cameraShakeMultiplier;
		float num2 = 16f * cameraShakeMultiplier;
		SemiFunc.CameraShakeImpactDistance(gunMuzzle.position, 5f * cameraShakeMultiplier, 0.1f, num, num2);
		SemiFunc.CameraShakeDistance(gunMuzzle.position, 0.1f * cameraShakeMultiplier, 0.1f * cameraShakeMultiplier, num, num2);
		soundShoot.Play(gunMuzzle.position, 1f, 1f, 1f, 1f);
		soundShootGlobal.Play(gunMuzzle.position, 1f, 1f, 1f, 1f);
		MuzzleFlash();
		StartTriggerAnimation();
		if (!SemiFunc.IsMasterClientOrSingleplayer())
		{
			return;
		}
		EnemyDirector instance = EnemyDirector.instance;
		if ((Object)(object)instance != (Object)null && investigateRadius > 0f)
		{
			MethodInfo method = ((object)instance).GetType().GetMethod("SetInvestigate", new Type[2]
			{
				typeof(Vector3),
				typeof(float)
			});
			if (method != null)
			{
				method.Invoke(instance, new object[2]
				{
					((Component)this).transform.position,
					investigateRadius
				});
			}
		}
		physGrabObject.rb.AddForceAtPosition(-gunMuzzle.forward * gunRecoilForce, gunMuzzle.position, (ForceMode)1);
		if (!batteryDrainFullBar)
		{
			ItemBattery obj = itemBattery;
			obj.batteryLife -= batteryDrain;
		}
		else
		{
			itemBattery.RemoveFullBar(batteryDrainFullBars);
		}
		RaycastHit val4 = default(RaycastHit);
		for (int i = 0; i < numberOfBullets; i++)
		{
			Vector3 val = gunMuzzle.forward;
			if (gunRandomSpread > 0f)
			{
				float num3 = Random.Range(0f, gunRandomSpread / 2f);
				float num4 = Random.Range(0f, 360f);
				Vector3 val2 = Vector3.Cross(val, Random.onUnitSphere);
				Vector3 normalized = ((Vector3)(ref val2)).normalized;
				Quaternion val3 = Quaternion.AngleAxis(num3, normalized);
				val2 = Quaternion.AngleAxis(num4, val) * val3 * val;
				val = ((Vector3)(ref val2)).normalized;
			}
			Vector3 endPosition = gunMuzzle.position + val * gunRange;
			bool hit = false;
			if (Physics.Raycast(gunMuzzle.position, val, ref val4, gunRange, LayerMask.op_Implicit(SemiFunc.LayerMaskGetVisionObstruct()) + LayerMask.GetMask(new string[1] { "Enemy" })))
			{
				endPosition = ((RaycastHit)(ref val4)).point;
				hit = true;
			}
			ShootBullet(endPosition, hit);
		}
	}

	private void ShootBullet(Vector3 _endPosition, bool _hit)
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (SemiFunc.IsMasterClientOrSingleplayer())
		{
			if (SemiFunc.IsMultiplayer())
			{
				photonView.RPC("ShootBulletRPC", (RpcTarget)0, new object[2] { _endPosition, _hit });
			}
			else
			{
				ShootBulletRPC(_endPosition, _hit);
			}
		}
	}

	[PunRPC]
	public void ShootBulletRPC(Vector3 _endPosition, bool _hit)
	{
		//IL_0078: 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_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		if (physGrabObject.playerGrabbing.Count > 1)
		{
			foreach (PhysGrabber item in physGrabObject.playerGrabbing)
			{
				if ((Object)(object)item != (Object)null)
				{
					Debug.Log((object)"[TiroAutomatico] Ignorando OverrideGrabRelease, método não existe mais.");
				}
			}
		}
		ItemGunBullet component = Object.Instantiate<GameObject>(bulletPrefab, gunMuzzle.position, gunMuzzle.rotation).GetComponent<ItemGunBullet>();
		component.hitPosition = _endPosition;
		component.bulletHit = _hit;
		soundHit.Play(_endPosition, 1f, 1f, 1f, 1f);
		component.shootLineWidthCurve = shootLineWidthCurve;
		component.ActivateAll();
	}

	private void MuzzleFlash()
	{
		//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)
		Object.Instantiate<GameObject>(muzzleFlashPrefab, gunMuzzle.position, gunMuzzle.rotation, gunMuzzle).GetComponent<ItemGunMuzzleFlash>().ActivateAllEffects();
	}

	private void StartTriggerAnimation()
	{
		triggerAnimationActive = true;
		triggerAnimationEval = 0f;
	}

	private bool IsUseInputHeld()
	{
		return Input.GetKey((KeyCode)101);
	}
}
public class BloxyVelocidade : MonoBehaviour
{
	public float boostMultiplier = 8f;

	public float boostDuration = 10f;

	private ItemToggle itemToggle;

	private ItemEquippable itemEquippable;

	private ItemAttributes itemAttributes;

	private PhotonView photonView;

	private PhysGrabObject physGrabObject;

	[Space]
	public ParticleSystem rejectParticles;

	[Space]
	public MeshRenderer mesh;

	private Material material;

	private Color materialEmissionOriginal;

	private int materialPropertyEmission = Shader.PropertyToID("_EmissionColor");

	[Header("AUDIO")]
	public AudioSource audioSourceUse;

	public AudioSource audioSourceReject;

	private bool used;

	private float lightIntensityLerp;

	public AnimationCurve lightIntensityCurve;

	private ParticleSystem boostParticles;

	private void Start()
	{
		//IL_006c: 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)
		itemToggle = ((Component)this).GetComponent<ItemToggle>();
		itemEquippable = ((Component)this).GetComponent<ItemEquippable>();
		itemAttributes = ((Component)this).GetComponent<ItemAttributes>();
		photonView = ((Component)this).GetComponent<PhotonView>();
		physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
		if ((Object)(object)mesh != (Object)null)
		{
			material = ((Renderer)mesh).material;
			materialEmissionOriginal = material.GetColor(materialPropertyEmission);
		}
		if (!((Object)(object)audioSourceUse == (Object)null) && !((Object)(object)audioSourceReject == (Object)null))
		{
			return;
		}
		AudioSource componentInChildren = ((Component)this).GetComponentInChildren<AudioSource>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			if ((Object)(object)audioSourceUse == (Object)null)
			{
				audioSourceUse = componentInChildren;
			}
			if ((Object)(object)audioSourceReject == (Object)null)
			{
				audioSourceReject = componentInChildren;
			}
		}
	}

	private void Update()
	{
		if (SemiFunc.RunIsShop())
		{
			return;
		}
		LightLogic();
		if (!SemiFunc.IsMasterClientOrSingleplayer() || !itemToggle.toggleState || used)
		{
			return;
		}
		PlayerAvatar val = SemiFunc.PlayerAvatarGetFromPhotonID(itemToggle.playerTogglePhotonID);
		if (Object.op_Implicit((Object)(object)val))
		{
			PlayerController instance = PlayerController.instance;
			if (instance.overrideSpeedMultiplier > 1f)
			{
				RejectUse();
			}
			else
			{
				ApplySpeedBoost();
			}
		}
	}

	private void RejectUse()
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: 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_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		if (SemiFunc.IsMultiplayer())
		{
			photonView.RPC("RejectRPC", (RpcTarget)0, Array.Empty<object>());
		}
		else
		{
			RejectRPC();
		}
		itemToggle.ToggleItem(false, -1);
		if ((Object)(object)physGrabObject != (Object)null && (Object)(object)physGrabObject.rb != (Object)null)
		{
			physGrabObject.rb.AddForce(Vector3.up * 2f, (ForceMode)1);
			physGrabObject.rb.AddTorque(-((Component)physGrabObject).transform.right * 0.05f, (ForceMode)1);
		}
	}

	private void ApplySpeedBoost()
	{
		//IL_0091: 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)
		PlayUseSoundLocalSafe();
		PlayerController.instance.OverrideSpeed(boostMultiplier, boostDuration);
		StatsManager.instance.ItemRemove(itemAttributes.instanceName);
		if ((Object)(object)physGrabObject != (Object)null && (Object)(object)physGrabObject.impactDetector != (Object)null)
		{
			physGrabObject.impactDetector.indestructibleBreakEffects = true;
		}
		if (SemiFunc.IsMultiplayer())
		{
			photonView.RPC("UsedRPC", (RpcTarget)0, Array.Empty<object>());
		}
		else
		{
			UsedRPC();
		}
	}

	private void LightLogic()
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		if (used && !((Object)(object)material == (Object)null) && lightIntensityLerp < 1f)
		{
			lightIntensityLerp += 1f * Time.deltaTime;
			material.SetColor(materialPropertyEmission, Color.Lerp(Color.black, materialEmissionOriginal, lightIntensityCurve.Evaluate(lightIntensityLerp)));
		}
	}

	[PunRPC]
	private void UsedRPC(PhotonMessageInfo info = default(PhotonMessageInfo))
	{
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)audioSourceUse != (Object)null && (Object)(object)audioSourceUse.clip != (Object)null)
		{
			audioSourceUse.PlayOneShot(audioSourceUse.clip);
		}
		else
		{
			AudioSource componentInChildren = ((Component)this).GetComponentInChildren<AudioSource>();
			if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.clip != (Object)null)
			{
				AudioSource.PlayClipAtPoint(componentInChildren.clip, ((Component)this).transform.position);
			}
		}
		GameDirector.instance.CameraImpact.ShakeDistance(5f, 1f, 6f, ((Component)this).transform.position, 0.2f);
		itemToggle.ToggleDisable(true);
		itemAttributes.DisableUI(true);
		Object.Destroy((Object)(object)itemEquippable);
		CreateBoostParticles(((Component)PlayerController.instance).transform);
		used = true;
		if ((Object)(object)boostParticles != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)boostParticles).gameObject, boostDuration);
		}
	}

	private void PlayUseSoundLocalSafe()
	{
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)audioSourceUse != (Object)null && (Object)(object)audioSourceUse.clip != (Object)null)
		{
			audioSourceUse.PlayOneShot(audioSourceUse.clip);
			return;
		}
		AudioSource componentInChildren = ((Component)this).GetComponentInChildren<AudioSource>();
		if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.clip != (Object)null)
		{
			AudioSource.PlayClipAtPoint(componentInChildren.clip, ((Component)this).transform.position);
		}
	}

	[PunRPC]
	private void RejectRPC(PhotonMessageInfo info = default(PhotonMessageInfo))
	{
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)audioSourceReject != (Object)null && (Object)(object)audioSourceReject.clip != (Object)null)
		{
			audioSourceReject.PlayOneShot(audioSourceReject.clip);
		}
		else
		{
			AudioSource componentInChildren = ((Component)this).GetComponentInChildren<AudioSource>();
			if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.clip != (Object)null)
			{
				AudioSource.PlayClipAtPoint(componentInChildren.clip, ((Component)this).transform.position);
			}
		}
		PlayerAvatar val = SemiFunc.PlayerAvatarGetFromPhotonID(itemToggle.playerTogglePhotonID);
		if ((Object)(object)val != (Object)null && val.isLocal)
		{
			val.physGrabber.ReleaseObjectRPC(false, 1f);
		}
		if ((Object)(object)rejectParticles != (Object)null)
		{
			rejectParticles.Play();
		}
		GameDirector.instance.CameraImpact.ShakeDistance(5f, 1f, 6f, ((Component)this).transform.position, 0.2f);
	}

	private void CreateBoostParticles(Transform playerTransform)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: 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)
		//IL_005b: 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_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Expected O, but got Unknown
		//IL_0107: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Expected O, but got Unknown
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("BoostParticles");
		val.transform.SetParent(playerTransform);
		val.transform.localPosition = Vector3.zero;
		boostParticles = val.AddComponent<ParticleSystem>();
		MainModule main = boostParticles.main;
		((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(Color.blue);
		((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(0.05f);
		((MainModule)(ref main)).startLifetime = MinMaxCurve.op_Implicit(0.5f);
		((MainModule)(ref main)).startSpeed = MinMaxCurve.op_Implicit(0.2f);
		((MainModule)(ref main)).loop = true;
		((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)1;
		EmissionModule emission = boostParticles.emission;
		((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(40f);
		ShapeModule shape = boostParticles.shape;
		((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)0;
		((ShapeModule)(ref shape)).radius = 0.3f;
		ParticleSystemRenderer component = ((Component)boostParticles).GetComponent<ParticleSystemRenderer>();
		((Renderer)component).material = new Material(Shader.Find("Particles/Standard Unlit"));
		((Renderer)component).material.color = Color.blue;
		component.renderMode = (ParticleSystemRenderMode)0;
		Texture2D val2 = new Texture2D(32, 32);
		for (int i = 0; i < 32; i++)
		{
			for (int j = 0; j < 32; j++)
			{
				float num = i - 16;
				float num2 = j - 16;
				float num3 = Mathf.Sqrt(num * num + num2 * num2) / 16f;
				val2.SetPixel(i, j, (num3 <= 1f) ? Color.white : Color.clear);
			}
		}
		val2.Apply();
		((Renderer)component).material.mainTexture = (Texture)(object)val2;
		boostParticles.Play();
	}

	private void OnDestroy()
	{
		if ((Object)(object)boostParticles != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)boostParticles).gameObject);
		}
		if ((Object)(object)rejectParticles != (Object)null && rejectParticles.isPlaying)
		{
			rejectParticles.Stop();
		}
	}
}
public class BombaExplosiva : MonoBehaviour
{
	public float explosionRadius = 5f;

	public float explosionForce = 700f;

	public float damage = 200f;

	public GameObject explosionEffect;

	public float explosionDelay = 0f;

	private bool hasExploded = false;

	private void Start()
	{
		if (explosionDelay > 0f)
		{
			((MonoBehaviour)this).Invoke("Explode", explosionDelay);
		}
	}

	private void OnCollisionEnter(Collision collision)
	{
		if (!hasExploded && explosionDelay <= 0f)
		{
			Explode();
		}
	}

	public void Explode()
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		if (hasExploded)
		{
			return;
		}
		hasExploded = true;
		if ((Object)(object)explosionEffect != (Object)null)
		{
			Object.Instantiate<GameObject>(explosionEffect, ((Component)this).transform.position, Quaternion.identity);
		}
		Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, explosionRadius);
		Collider[] array2 = array;
		foreach (Collider val in array2)
		{
			Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
			if ((Object)(object)component != (Object)null)
			{
				component.AddExplosionForce(explosionForce, ((Component)this).transform.position, explosionRadius);
			}
			PlayerHealth component2 = ((Component)val).GetComponent<PlayerHealth>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.Hurt((int)damage, false, -1);
			}
		}
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}
}
public class MaterialGlowPulse : MonoBehaviour
{
	public Renderer targetRenderer;

	public float glowInterval = 1f;

	public float glowIntensity = 2f;

	private Material material;

	private Color originalColor;

	private float time;

	private void Start()
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)targetRenderer == (Object)null)
		{
			targetRenderer = ((Component)this).GetComponent<Renderer>();
		}
		material = targetRenderer.material;
		originalColor = material.color;
	}

	private void Update()
	{
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		time += Time.deltaTime;
		float num = (Mathf.Sin(time / glowInterval * MathF.PI * 2f) + 1f) / 2f;
		float num2 = Mathf.Lerp(1f, glowIntensity, num);
		material.color = originalColor * num2;
	}
}
public class RotateCameraWhileHeld : MonoBehaviour
{
	private PhysGrabObject physGrabObject;

	private bool isHeld = false;

	private bool wasHeld = false;

	private bool isReturning = false;

	public float rotationSpeed = 180f;

	public float returnSpeed = 5f;

	private Quaternion originalRotation;

	private void Start()
	{
		//IL_0028: 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)
		physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
		if ((Object)(object)Camera.main != (Object)null)
		{
			originalRotation = ((Component)Camera.main).transform.rotation;
		}
	}

	private void Update()
	{
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		Camera main = Camera.main;
		if ((Object)(object)main == (Object)null || (Object)(object)physGrabObject == (Object)null)
		{
			return;
		}
		isHeld = physGrabObject.grabbed;
		if (isHeld)
		{
			isReturning = false;
			((Component)main).transform.Rotate(Vector3.forward, rotationSpeed * Time.deltaTime);
		}
		else if (!isHeld && wasHeld)
		{
			isReturning = true;
		}
		if (isReturning)
		{
			((Component)main).transform.rotation = Quaternion.Lerp(((Component)main).transform.rotation, originalRotation, returnSpeed * Time.deltaTime);
			if (Quaternion.Angle(((Component)main).transform.rotation, originalRotation) < 0.1f)
			{
				((Component)main).transform.rotation = originalRotation;
				isReturning = false;
			}
		}
		wasHeld = isHeld;
	}
}
public class HurtColliderCura : MonoBehaviour
{
	public float amount = 25f;

	private void OnTriggerEnter(Collider other)
	{
		PlayerHealth componentInParent = ((Component)other).GetComponentInParent<PlayerHealth>();
		if ((Object)(object)componentInParent != (Object)null)
		{
			componentInParent.Heal((int)amount, true);
		}
	}
}
[DisallowMultipleComponent]
public class CorParaTodos : MonoBehaviourPun
{
	[Header("Renderers to affect (leave empty = auto-detect)")]
	public Renderer[] targetRenderers;

	[Header("Cor")]
	[Tooltip("Se true, gera uma cor aleatória forte. Se false, usa a cor fixa abaixo.")]
	public bool overrideWithRandomColor = true;

	[Tooltip("Cor fixa (usada se overrideWithRandomColor = false)")]
	public Color fixedColor = Color.white;

	[Tooltip("Cor que será realmente usada (gerada ou fixa, e persistente)")]
	public Color savedColor = new Color(0f, 0f, 0f, 0f);

	private void Start()
	{
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: 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_00bb: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		if (savedColor.a == 0f)
		{
			if (PhotonNetwork.InRoom && ((MonoBehaviourPun)this).photonView.IsMine)
			{
				savedColor = (overrideWithRandomColor ? GenerateVibrantColor() : fixedColor);
				((MonoBehaviourPun)this).photonView.RPC("SyncColorRPC", (RpcTarget)3, new object[3] { savedColor.r, savedColor.g, savedColor.b });
			}
			else if (!PhotonNetwork.InRoom)
			{
				savedColor = (overrideWithRandomColor ? GenerateVibrantColor() : fixedColor);
				ApplyColor(savedColor);
			}
		}
		else
		{
			ApplyColor(savedColor);
		}
	}

	[PunRPC]
	private void SyncColorRPC(float r, float g, float b)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: 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)
		savedColor = new Color(r, g, b);
		ApplyColor(savedColor);
	}

	private void ApplyColor(Color color)
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Expected O, but got Unknown
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: 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)
		Renderer[] array = (Renderer[])((targetRenderers != null && targetRenderers.Length != 0) ? ((Array)targetRenderers) : ((Array)((Component)this).GetComponentsInChildren<Renderer>()));
		Renderer[] array2 = array;
		foreach (Renderer val in array2)
		{
			if (!((Object)(object)val == (Object)null))
			{
				MaterialPropertyBlock val2 = new MaterialPropertyBlock();
				val.GetPropertyBlock(val2);
				Material sharedMaterial = val.sharedMaterial;
				if (sharedMaterial.HasProperty("_BaseColor"))
				{
					val2.SetColor("_BaseColor", color);
				}
				else if (sharedMaterial.HasProperty("_Color"))
				{
					val2.SetColor("_Color", color);
				}
				val.SetPropertyBlock(val2);
			}
		}
		Light[] componentsInChildren = ((Component)this).GetComponentsInChildren<Light>(true);
		Light[] array3 = componentsInChildren;
		foreach (Light val3 in array3)
		{
			val3.color = color;
		}
	}

	public static Color GenerateVibrantColor()
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: 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)
		return Color.HSVToRGB(Random.value, 0.7f, 0.9f);
	}
}
public class Curar : MonoBehaviour
{
	private void OnDestroy()
	{
		PlayerHealth playerHealth = PlayerAvatar.instance.playerHealth;
		playerHealth.health = Mathf.Min(playerHealth.health + 50, playerHealth.maxHealth);
	}
}
public class CustomPrefabPool : MonoBehaviour, IPunPrefabPool
{
	private readonly Dictionary<string, GameObject> prefabDictionary = new Dictionary<string, GameObject>();

	private readonly string[] ignoreLogsContains = new string[7] { "PlayerAvatar", "Voice", "Level/", "Start Room", "Manor", "Lobby", "Module" };

	public void RegisterValuable(string prefabName)
	{
		if (string.IsNullOrEmpty(prefabName))
		{
			Debug.LogError((object)"[CustomPrefabPool] Nome do prefab vazio!");
		}
		else if (!prefabDictionary.ContainsKey(prefabName))
		{
			GameObject val = Resources.Load<GameObject>(prefabName);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogError((object)("[CustomPrefabPool] Não encontrado em Resources: " + prefabName));
				return;
			}
			prefabDictionary[prefabName] = val;
			Debug.Log((object)("[CustomPrefabPool] Registrado prefab: " + prefabName));
		}
	}

	public GameObject Instantiate(string prefabId, Vector3 position, Quaternion rotation)
	{
		//IL_004a: 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_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		string[] array = ignoreLogsContains;
		foreach (string value in array)
		{
			if (prefabId.Contains(value))
			{
				return null;
			}
		}
		if (prefabDictionary.TryGetValue(prefabId, out GameObject value2))
		{
			GameObject val = Object.Instantiate<GameObject>(value2, position, rotation);
			val.SetActive(false);
			return val;
		}
		GameObject val2 = Resources.Load<GameObject>(prefabId);
		if ((Object)(object)val2 != (Object)null)
		{
			GameObject val3 = Object.Instantiate<GameObject>(val2, position, rotation);
			val3.SetActive(false);
			Debug.LogWarning((object)("[CustomPrefabPool] '" + prefabId + "' não registrado. Usando fallback de Resources."));
			return val3;
		}
		Debug.LogError((object)("[CustomPrefabPool] ERRO: '" + prefabId + "' não encontrado!"));
		return null;
	}

	public void Destroy(GameObject go)
	{
		Object.Destroy((Object)(object)go);
	}
}
public class Doomsekkar : MonoBehaviour
{
	private bool isItemHeld = false;

	private float holdTime = 0f;

	public float holdThreshold = 2f;

	private bool isSpeaking = false;

	private string GenerateAffectionateSentence()
	{
		string[] array = new string[1] { "Destiny's powerful hand has made the bed of my future, and it's up to me to lie in it." };
		return array[Random.Range(0, array.Length)];
	}

	private void Update()
	{
		if (Input.GetKey((KeyCode)101))
		{
			if (!isItemHeld)
			{
				isItemHeld = true;
			}
			if (isItemHeld)
			{
				holdTime += Time.deltaTime;
				if (!isSpeaking && holdTime >= holdThreshold)
				{
					StartSpeaking();
				}
			}
		}
		else if (isItemHeld)
		{
			isItemHeld = false;
			holdTime = 0f;
			isSpeaking = false;
		}
	}

	public void StartSpeaking()
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		isSpeaking = true;
		string text = GenerateAffectionateSentence();
		Color val = default(Color);
		((Color)(ref val))..ctor(1f, 0.3f, 0.6f, 1f);
		ChatManager.instance.PossessChatScheduleStart(10);
		ChatManager.instance.PossessChat((PossessChatID)1, text, 1f, val, 0f, false, 0, (UnityEvent)null);
		ChatManager.instance.PossessChatScheduleEnd();
	}
}
public class PulaPulaEin : MonoBehaviour
{
	public float launchForce = 6f;

	public float jumpForce = 4f;

	public float cooldown = 0.5f;

	public float minImpactForce = 2f;

	private Rigidbody rb;

	private bool launched = false;

	private void Start()
	{
		rb = ((Component)this).GetComponent<Rigidbody>();
	}

	private void OnCollisionEnter(Collision collision)
	{
		//IL_0013: 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_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: 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)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		if (!launched && collision.contacts.Length != 0)
		{
			Vector3 val = collision.relativeVelocity;
			if (((Vector3)(ref val)).magnitude > minImpactForce)
			{
				val = ((Component)this).transform.forward;
				Vector3 val2 = ((Vector3)(ref val)).normalized * launchForce + Vector3.up * jumpForce;
				rb.AddForce(val2, (ForceMode)2);
				launched = true;
				((MonoBehaviour)this).Invoke("ResetLaunch", cooldown);
			}
		}
	}

	private void ResetLaunch()
	{
		launched = false;
	}
}
public class ChangeEixo : MonoBehaviour
{
	private PhysGrabObject physGrabObject;

	public float changeInterval = 0.5f;

	private float timer = 0f;

	private Quaternion startRotation;

	private Quaternion targetRotation;

	private bool isRotating = false;

	private void Start()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
		startRotation = ((Component)this).transform.rotation;
		targetRotation = startRotation;
	}

	private void Update()
	{
		//IL_0118: 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_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		if (physGrabObject.grabbed)
		{
			if (!isRotating)
			{
				timer = 0f;
				startRotation = ((Component)this).transform.rotation;
				int num = Random.Range(0, 3);
				int[] array = new int[3] { 90, 180, 270 };
				int num2 = array[Random.Range(0, array.Length)];
				Vector3 zero = Vector3.zero;
				switch (num)
				{
				case 0:
					((Vector3)(ref zero))..ctor((float)num2, 0f, 0f);
					break;
				case 1:
					((Vector3)(ref zero))..ctor(0f, (float)num2, 0f);
					break;
				case 2:
					((Vector3)(ref zero))..ctor(0f, 0f, (float)num2);
					break;
				}
				targetRotation = startRotation * Quaternion.Euler(zero);
				isRotating = true;
			}
			else
			{
				timer += Time.deltaTime;
				float num3 = timer / changeInterval;
				((Component)this).transform.rotation = Quaternion.Slerp(startRotation, targetRotation, num3);
				if (num3 >= 1f)
				{
					isRotating = false;
				}
			}
		}
		else
		{
			isRotating = false;
			timer = 0f;
		}
	}
}
public class ItemBehaviour : MonoBehaviour
{
	public GameObject valuablePrefab;

	public GameObject explosionEffectPrefab;

	public Vector3 spawnOffset = new Vector3(2f, 1f, 0f);

	private bool _used = false;

	public float raycastDistance = 10f;

	[Range(0f, 1f)]
	public float explosionChance = 0.3f;

	public float explosionRadius = 5f;

	public int explosionDamage = 20;

	private void Update()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		if (!Input.GetMouseButtonDown(0))
		{
			return;
		}
		Ray val = Camera.main.ScreenPointToRay(Input.mousePosition);
		RaycastHit val2 = default(RaycastHit);
		if (Physics.Raycast(val, ref val2, raycastDistance) && (Object)(object)((Component)((RaycastHit)(ref val2)).collider).gameObject == (Object)(object)((Component)this).gameObject && !_used)
		{
			_used = true;
			if (Random.Range(0f, 1f) <= explosionChance)
			{
				Explode();
			}
			else
			{
				GenerateNewValuable();
			}
		}
	}

	private void GenerateNewValuable()
	{
		//IL_0025: 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_0030: 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_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)valuablePrefab == (Object)null)
		{
			Debug.LogError((object)"Prefab de valuable não foi atribuído!");
			return;
		}
		Vector3 val = ((Component)this).transform.position + spawnOffset;
		Object.Instantiate<GameObject>(valuablePrefab, val, Quaternion.identity);
		Debug.Log((object)"Novo valuable gerado!");
	}

	private void Explode()
	{
		//IL_0040: 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_002e: Unknown result type (might be due to invalid IL or missing references)
		Debug.Log((object)"Explodindo!");
		if ((Object)(object)explosionEffectPrefab != (Object)null)
		{
			Object.Instantiate<GameObject>(explosionEffectPrefab, ((Component)this).transform.position, Quaternion.identity);
		}
		Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, explosionRadius);
		Collider[] array2 = array;
		foreach (Collider val in array2)
		{
			if (((Component)val).CompareTag("Player"))
			{
				PlayerAvatar componentInParent = ((Component)val).GetComponentInParent<PlayerAvatar>();
				if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.playerHealth != (Object)null)
				{
					Debug.Log((object)$"Dano aplicado ao jogador: {explosionDamage}");
					PlayerHealth playerHealth = componentInParent.playerHealth;
					playerHealth.health -= explosionDamage;
					componentInParent.playerHealth.Hurt(explosionDamage, false, -1);
				}
			}
		}
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		Gizmos.color = Color.red;
		Gizmos.DrawWireSphere(((Component)this).transform.position, explosionRadius);
	}
}
public class ItemBehaviour2 : MonoBehaviour
{
	[Header("Spawn de")]
	public GameObject[] valuablePrefabs;

	public Vector3 spawnOffset = new Vector3(2f, 1f, 0f);

	[Header("Explosão")]
	public GameObject explosionEffectPrefab;

	public float explosionRadius = 5f;

	public int explosionDamage = 20;

	[Range(0f, 1f)]
	public float explosionChance = 0.3f;

	[Header("Interação")]
	public float raycastDistance = 10f;

	private bool _used = false;

	private void Update()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		if (!Input.GetMouseButtonDown(0))
		{
			return;
		}
		Ray val = Camera.main.ScreenPointToRay(Input.mousePosition);
		RaycastHit val2 = default(RaycastHit);
		if (Physics.Raycast(val, ref val2, raycastDistance) && (Object)(object)((Component)((RaycastHit)(ref val2)).collider).gameObject == (Object)(object)((Component)this).gameObject && !_used)
		{
			_used = true;
			if (Random.Range(0f, 1f) <= explosionChance)
			{
				Explode();
			}
			else
			{
				GenerateRandomValuable();
			}
		}
	}

	private void GenerateRandomValuable()
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		if (valuablePrefabs == null || valuablePrefabs.Length == 0)
		{
			Debug.LogError((object)"Nenhum prefab de valuable foi atribuído!");
			return;
		}
		int num = Random.Range(0, valuablePrefabs.Length);
		GameObject val = valuablePrefabs[num];
		Vector3 val2 = ((Component)this).transform.position + spawnOffset;
		Object.Instantiate<GameObject>(val, val2, Quaternion.identity);
		Debug.Log((object)("Valuable gerado: " + ((Object)val).name));
	}

	private void Explode()
	{
		//IL_0040: 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_002e: Unknown result type (might be due to invalid IL or missing references)
		Debug.Log((object)"Explodindo!");
		if ((Object)(object)explosionEffectPrefab != (Object)null)
		{
			Object.Instantiate<GameObject>(explosionEffectPrefab, ((Component)this).transform.position, Quaternion.identity);
		}
		Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, explosionRadius);
		Collider[] array2 = array;
		foreach (Collider val in array2)
		{
			if (((Component)val).CompareTag("Player"))
			{
				PlayerAvatar componentInParent = ((Component)val).GetComponentInParent<PlayerAvatar>();
				if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.playerHealth != (Object)null)
				{
					Debug.Log((object)$"Dano aplicado ao jogador: {explosionDamage}");
					PlayerHealth playerHealth = componentInParent.playerHealth;
					playerHealth.health -= explosionDamage;
					componentInParent.playerHealth.Hurt(explosionDamage, false, -1);
				}
			}
		}
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		Gizmos.color = Color.red;
		Gizmos.DrawWireSphere(((Component)this).transform.position, explosionRadius);
	}
}
public class ItemBehaviourSemLimite : MonoBehaviour
{
	[Header("Spawn de Valuables")]
	public GameObject[] valuablePrefabs;

	public Vector3 spawnOffset = new Vector3(2f, 1f, 0f);

	[Header("Explosão")]
	public GameObject explosionEffectPrefab;

	public float explosionRadius = 5f;

	public int explosionDamage = 20;

	[Range(0f, 1f)]
	public float explosionChance = 0.3f;

	[Header("Som da Explosão")]
	public AudioClip explosionSound;

	private AudioSource audioSource;

	[Header("Interação")]
	public float raycastDistance = 10f;

	private void Start()
	{
		audioSource = ((Component)this).GetComponent<AudioSource>();
	}

	private void Update()
	{
		//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_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		if (!Input.GetMouseButtonDown(0))
		{
			return;
		}
		Ray val = Camera.main.ScreenPointToRay(Input.mousePosition);
		RaycastHit val2 = default(RaycastHit);
		if (Physics.Raycast(val, ref val2, raycastDistance) && (Object)(object)((Component)((RaycastHit)(ref val2)).collider).gameObject == (Object)(object)((Component)this).gameObject)
		{
			if (Random.Range(0f, 1f) <= explosionChance)
			{
				Explode();
			}
			else
			{
				GenerateRandomValuable();
			}
		}
	}

	private void GenerateRandomValuable()
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		if (valuablePrefabs == null || valuablePrefabs.Length == 0)
		{
			Debug.LogError((object)"Nenhum prefab de valuable foi atribuído!");
			return;
		}
		int num = Random.Range(0, valuablePrefabs.Length);
		GameObject val = valuablePrefabs[num];
		Vector3 val2 = ((Component)this).transform.position + spawnOffset;
		Object.Instantiate<GameObject>(val, val2, Quaternion.identity);
		Debug.Log((object)("Valuable gerado: " + ((Object)val).name));
	}

	private void Explode()
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		Debug.Log((object)"Explodindo!");
		if ((Object)(object)explosionEffectPrefab != (Object)null)
		{
			Object.Instantiate<GameObject>(explosionEffectPrefab, ((Component)this).transform.position, Quaternion.identity);
		}
		if ((Object)(object)explosionSound != (Object)null)
		{
			if ((Object)(object)audioSource != (Object)null)
			{
				audioSource.PlayOneShot(explosionSound);
			}
			else
			{
				AudioSource.PlayClipAtPoint(explosionSound, ((Component)this).transform.position);
			}
		}
		Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, explosionRadius);
		Collider[] array2 = array;
		foreach (Collider val in array2)
		{
			if (((Component)val).CompareTag("Player"))
			{
				PlayerAvatar componentInParent = ((Component)val).GetComponentInParent<PlayerAvatar>();
				if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.playerHealth != (Object)null)
				{
					Debug.Log((object)$"Dano aplicado ao jogador: {explosionDamage}");
					PlayerHealth playerHealth = componentInParent.playerHealth;
					playerHealth.health -= explosionDamage;
					componentInParent.playerHealth.Hurt(explosionDamage, false, -1);
				}
			}
		}
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		Gizmos.color = Color.red;
		Gizmos.DrawWireSphere(((Component)this).transform.position, explosionRadius);
	}
}
public class ExplodeOnDestroy : MonoBehaviourPun
{
	public GameObject explosionEffectPrefab;

	public float explosionRadius = 5f;

	public float explosionForce = 500f;

	public int explosionDamage = 30;

	public float damageRadius = 3f;

	public bool beingExtracted = false;

	private void OnDestroy()
	{
		//IL_0050: 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_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Unknown result type (might be due to invalid IL or missing references)
		if (beingExtracted)
		{
			return;
		}
		if ((Object)(object)explosionEffectPrefab != (Object)null)
		{
			GameObject val = Object.Instantiate<GameObject>(explosionEffectPrefab, ((Component)this).transform.position, Quaternion.identity);
			Object.Destroy((Object)(object)val, 5f);
		}
		Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, explosionRadius);
		Collider[] array2 = array;
		Ray val4 = default(Ray);
		RaycastHit val5 = default(RaycastHit);
		foreach (Collider val2 in array2)
		{
			float num = Vector3.Distance(((Component)this).transform.position, ((Component)val2).transform.position);
			Rigidbody component = ((Component)val2).GetComponent<Rigidbody>();
			if ((Object)(object)component != (Object)null)
			{
				component.AddExplosionForce(explosionForce, ((Component)this).transform.position, explosionRadius);
			}
			if (!(num <= damageRadius) || !((Component)val2).CompareTag("Player"))
			{
				continue;
			}
			Vector3 val3 = ((Component)val2).transform.position - ((Component)this).transform.position;
			Vector3 normalized = ((Vector3)(ref val3)).normalized;
			((Ray)(ref val4))..ctor(((Component)this).transform.position, normalized);
			if (Physics.Raycast(val4, ref val5, damageRadius) && (Object)(object)((Component)((RaycastHit)(ref val5)).collider).gameObject == (Object)(object)((Component)val2).gameObject)
			{
				PhotonView component2 = ((Component)val2).GetComponent<PhotonView>();
				if (!SemiFunc.IsMultiplayer() || ((Object)(object)component2 != (Object)null && component2.IsMine))
				{
					PlayerHealth playerHealth = PlayerAvatar.instance.playerHealth;
					playerHealth.health -= explosionDamage;
					PlayerAvatar.instance.playerHealth.Hurt(explosionDamage, false, -1);
				}
			}
		}
	}
}
public class TalkingValuable : MonoBehaviour
{
	private bool isItemHeld = false;

	private float holdTime = 0f;

	public float holdThreshold = 2f;

	private bool isSpeaking = false;

	private string GenerateAffectionateSentence()
	{
		string[] array = new string[5] { "STAAN", "STAAAN", "STAAAAAN", "STAAAAAAAN", "STAAAAAAAAAAAN" };
		return array[Random.Range(0, array.Length)];
	}

	public void StartSpeaking()
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		isSpeaking = true;
		string text = GenerateAffectionateSentence();
		Color val = default(Color);
		((Color)(ref val))..ctor(1f, 0.3f, 0.6f, 1f);
		ChatManager.instance.PossessChatScheduleStart(10);
		ChatManager.instance.PossessChat((PossessChatID)1, text, 1f, val, 0f, false, 0, (UnityEvent)null);
		ChatManager.instance.PossessChatScheduleEnd();
	}
}
public class FaladorEngracado : MonoBehaviourPun
{
	private enum EstadoDeFala
	{
		Silencioso,
		Tagarelando
	}

	public PhysGrabObject objetoFalante;

	private float tempoDeReativacao = 0.5f;

	private EstadoDeFala estadoAtual = EstadoDeFala.Silencioso;

	private readonly string[] frasesEngracadas = new string[5] { "STAAAAAN", "I just wanted a normal day, man.", "Everything I know is a lie!", "Kyle, what the hell is going on?", "Sometimes I feel like I’m the only sane one here." };

	private void Start()
	{
		if ((Object)(object)objetoFalante == (Object)null)
		{
			objetoFalante = ((Component)this).GetComponent<PhysGrabObject>();
		}
	}

	private void Update()
	{
		if (SemiFunc.IsMultiplayer())
		{
			AtualizarEstadoDeFala();
		}
	}

	private void AtualizarEstadoDeFala()
	{
		switch (estadoAtual)
		{
		case EstadoDeFala.Silencioso:
			ChecarPegadaInicial();
			break;
		case EstadoDeFala.Tagarelando:
			VerificarSeSoltou();
			break;
		}
	}

	private void ChecarPegadaInicial()
	{
		if (tempoDeReativacao > 0f && objetoFalante.grabbed)
		{
			tempoDeReativacao -= Time.deltaTime;
		}
		else if ((Object)(object)PhysGrabber.instance != (Object)null && PhysGrabber.instance.grabbed && (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject == (Object)(object)objetoFalante)
		{
			estadoAtual = EstadoDeFala.Tagarelando;
			ExibirFraseNoChat();
		}
	}

	private void VerificarSeSoltou()
	{
		if (!ChatManager.instance.StateIsPossessed() || (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject != (Object)(object)objetoFalante)
		{
			estadoAtual = EstadoDeFala.Silencioso;
			tempoDeReativacao = Random.Range(1f, 3f);
		}
	}

	private void ExibirFraseNoChat()
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		string text = frasesEngracadas[Random.Range(0, frasesEngracadas.Length)];
		Color val = default(Color);
		((Color)(ref val))..ctor(0.05f, 0.68f, 0.68f, 1f);
		ChatManager.instance.PossessChatScheduleStart(10);
		ChatManager.instance.PossessChat((PossessChatID)0, text, 3f, val, 0f, false, 0, (UnityEvent)null);
		ChatManager.instance.PossessChatScheduleEnd();
	}
}
public class FaladorEngracado2 : MonoBehaviourPun
{
	private enum EstadoDeFala
	{
		Silencioso,
		Tagarelando
	}

	public PhysGrabObject objetoFalante;

	private float tempoDeReativacao = 0.5f;

	private EstadoDeFala estadoAtual = EstadoDeFala.Silencioso;

	private readonly string[] frasesEngracadas = new string[5] { "I may be small, but I’m full of energy!", "Being happy is my superpower!", "Time for some splashy fun!", "Everything's more fun with friends!", "Let’s go on an adventure!" };

	private void Start()
	{
		if ((Object)(object)objetoFalante == (Object)null)
		{
			objetoFalante = ((Component)this).GetComponent<PhysGrabObject>();
		}
	}

	private void Update()
	{
		if (SemiFunc.IsMultiplayer())
		{
			AtualizarEstadoDeFala();
		}
	}

	private void AtualizarEstadoDeFala()
	{
		switch (estadoAtual)
		{
		case EstadoDeFala.Silencioso:
			ChecarPegadaInicial();
			break;
		case EstadoDeFala.Tagarelando:
			VerificarSeSoltou();
			break;
		}
	}

	private void ChecarPegadaInicial()
	{
		if (tempoDeReativacao > 0f && objetoFalante.grabbed)
		{
			tempoDeReativacao -= Time.deltaTime;
		}
		else if ((Object)(object)PhysGrabber.instance != (Object)null && PhysGrabber.instance.grabbed && (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject == (Object)(object)objetoFalante)
		{
			estadoAtual = EstadoDeFala.Tagarelando;
			ExibirFraseNoChat();
		}
	}

	private void VerificarSeSoltou()
	{
		if (!ChatManager.instance.StateIsPossessed() || (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject != (Object)(object)objetoFalante)
		{
			estadoAtual = EstadoDeFala.Silencioso;
			tempoDeReativacao = Random.Range(1f, 3f);
		}
	}

	private void ExibirFraseNoChat()
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		string text = frasesEngracadas[Random.Range(0, frasesEngracadas.Length)];
		Color val = default(Color);
		((Color)(ref val))..ctor(0.05f, 0.68f, 0.68f, 1f);
		ChatManager.instance.PossessChatScheduleStart(10);
		ChatManager.instance.PossessChat((PossessChatID)0, text, 3f, val, 0f, false, 0, (UnityEvent)null);
		ChatManager.instance.PossessChatScheduleEnd();
	}
}
public class FaladorEngracado3 : MonoBehaviourPun
{
	private enum EstadoDeFala
	{
		Silencioso,
		Tagarelando
	}

	public PhysGrabObject objetoFalante;

	private float tempoDeReativacao = 0.5f;

	private EstadoDeFala estadoAtual = EstadoDeFala.Silencioso;

	private readonly string[] frasesEngracadas = new string[4] { "if you break me you will die", "be careful", "you will die", "haha" };

	private void Start()
	{
		if ((Object)(object)objetoFalante == (Object)null)
		{
			objetoFalante = ((Component)this).GetComponent<PhysGrabObject>();
		}
	}

	private void Update()
	{
		if (SemiFunc.IsMultiplayer())
		{
			AtualizarEstadoDeFala();
		}
	}

	private void AtualizarEstadoDeFala()
	{
		switch (estadoAtual)
		{
		case EstadoDeFala.Silencioso:
			ChecarPegadaInicial();
			break;
		case EstadoDeFala.Tagarelando:
			VerificarSeSoltou();
			break;
		}
	}

	private void ChecarPegadaInicial()
	{
		if (tempoDeReativacao > 0f && objetoFalante.grabbed)
		{
			tempoDeReativacao -= Time.deltaTime;
		}
		else if ((Object)(object)PhysGrabber.instance != (Object)null && PhysGrabber.instance.grabbed && (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject == (Object)(object)objetoFalante)
		{
			estadoAtual = EstadoDeFala.Tagarelando;
			ExibirFraseNoChat();
		}
	}

	private void VerificarSeSoltou()
	{
		if (!ChatManager.instance.StateIsPossessed() || (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject != (Object)(object)objetoFalante)
		{
			estadoAtual = EstadoDeFala.Silencioso;
			tempoDeReativacao = Random.Range(1f, 3f);
		}
	}

	private void ExibirFraseNoChat()
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		string text = frasesEngracadas[Random.Range(0, frasesEngracadas.Length)];
		Color val = default(Color);
		((Color)(ref val))..ctor(0.02f, 0.62f, 0.62f, 1f);
		ChatManager.instance.PossessChatScheduleStart(10);
		ChatManager.instance.PossessChat((PossessChatID)0, text, 3f, val, 0f, false, 0, (UnityEvent)null);
		ChatManager.instance.PossessChatScheduleEnd();
	}
}
public class FaladorEngracadoDano3 : MonoBehaviourPun
{
	private enum EstadoDeFala
	{
		Silencioso,
		Tagarelando
	}

	public PhysGrabObject objetoFalante;

	private float tempoDeReativacao = 0.5f;

	private EstadoDeFala estadoAtual = EstadoDeFala.Silencioso;

	private readonly string[] frasesEngracadas = new string[3] { "Herobrine", "Have you seen the Herobrine?", "Only God can help you now." };

	private float tempoParaProximoDano = 1f;

	private float intervaloDano = 1f;

	private int danoPorTick = 1;

	private void Start()
	{
		if ((Object)(object)objetoFalante == (Object)null)
		{
			objetoFalante = ((Component)this).GetComponent<PhysGrabObject>();
		}
	}

	private void Update()
	{
		if (SemiFunc.IsMultiplayer())
		{
			AtualizarEstadoDeFala();
			AplicarDanoSeNecessario();
		}
	}

	private void AtualizarEstadoDeFala()
	{
		if ((Object)(object)PhysGrabber.instance != (Object)null && PhysGrabber.instance.grabbed && (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject == (Object)(object)objetoFalante)
		{
			if (estadoAtual == EstadoDeFala.Silencioso)
			{
				estadoAtual = EstadoDeFala.Tagarelando;
				tempoParaProximoDano = intervaloDano;
				ExibirFraseNoChat();
			}
		}
		else if (estadoAtual == EstadoDeFala.Tagarelando)
		{
			estadoAtual = EstadoDeFala.Silencioso;
			tempoDeReativacao = Random.Range(1f, 3f);
		}
	}

	private void AplicarDanoSeNecessario()
	{
		if (estadoAtual != EstadoDeFala.Tagarelando || (PhotonNetwork.IsConnected && !((MonoBehaviourPun)this).photonView.IsMine))
		{
			return;
		}
		tempoParaProximoDano -= Time.deltaTime;
		if (tempoParaProximoDano <= 0f)
		{
			tempoParaProximoDano = intervaloDano;
			if ((Object)(object)PlayerAvatar.instance != (Object)null && (Object)(object)PlayerAvatar.instance.playerHealth != (Object)null)
			{
				PlayerAvatar.instance.playerHealth.Hurt(danoPorTick, false, -1);
			}
		}
	}

	private void ExibirFraseNoChat()
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		string text = frasesEngracadas[Random.Range(0, frasesEngracadas.Length)];
		Color val = default(Color);
		((Color)(ref val))..ctor(0.05f, 0.68f, 0.68f, 1f);
		ChatManager.instance.PossessChatScheduleStart(10);
		ChatManager.instance.PossessChat((PossessChatID)0, text, 3f, val, 0f, false, 0, (UnityEvent)null);
		ChatManager.instance.PossessChatScheduleEnd();
	}
}
public class FaladorEngracadoTeto : MonoBehaviourPun
{
	private enum EstadoDeFala
	{
		Silencioso,
		Tagarelando
	}

	public PhysGrabObject objetoFalante;

	private float tempoDeReativacao = 0.5f;

	private EstadoDeFala estadoAtual = EstadoDeFala.Silencioso;

	private readonly string[] frasesEngracadas = new string[5] { "TETO", "TETOOO", "PEARTO", "PEARTOO", "TETO PEARTO" };

	private void Start()
	{
		if ((Object)(object)objetoFalante == (Object)null)
		{
			objetoFalante = ((Component)this).GetComponent<PhysGrabObject>();
		}
	}

	private void Update()
	{
		if (SemiFunc.IsMultiplayer())
		{
			AtualizarEstadoDeFala();
		}
	}

	private void AtualizarEstadoDeFala()
	{
		switch (estadoAtual)
		{
		case EstadoDeFala.Silencioso:
			ChecarPegadaInicial();
			break;
		case EstadoDeFala.Tagarelando:
			VerificarSeSoltou();
			break;
		}
	}

	private void ChecarPegadaInicial()
	{
		if (tempoDeReativacao > 0f && objetoFalante.grabbed)
		{
			tempoDeReativacao -= Time.deltaTime;
		}
		else if ((Object)(object)PhysGrabber.instance != (Object)null && PhysGrabber.instance.grabbed && (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject == (Object)(object)objetoFalante)
		{
			estadoAtual = EstadoDeFala.Tagarelando;
			ExibirFraseNoChat();
		}
	}

	private void VerificarSeSoltou()
	{
		if (!ChatManager.instance.StateIsPossessed() || (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject != (Object)(object)objetoFalante)
		{
			estadoAtual = EstadoDeFala.Silencioso;
			tempoDeReativacao = Random.Range(1f, 3f);
		}
	}

	private void ExibirFraseNoChat()
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		string text = frasesEngracadas[Random.Range(0, frasesEngracadas.Length)];
		Color val = default(Color);
		((Color)(ref val))..ctor(0.05f, 0.68f, 0.68f, 1f);
		ChatManager.instance.PossessChatScheduleStart(10);
		ChatManager.instance.PossessChat((PossessChatID)0, text, 3f, val, 0f, false, 0, (UnityEvent)null);
		ChatManager.instance.PossessChatScheduleEnd();
	}
}
public class Falatorio : MonoBehaviourPunCallbacks
{
	private enum State
	{
		Idle,
		Active
	}

	public PhysGrabObject physGrabObject;

	private float coolDownUntilNextSentence = 0.5f;

	private State currentState = State.Idle;

	private ParticleScriptExplosion particleScriptExplosion;

	public Transform Center;

	public Sound PreExplosionSound;

	private bool isExploding = false;

	[Range(0f, 100f)]
	public float ExplosionChance = 25f;

	private void Start()
	{
		particleScriptExplosion = ((Component)this).GetComponent<ParticleScriptExplosion>();
		if ((Object)(object)particleScriptExplosion == (Object)null)
		{
			Debug.LogError((object)"ParticleScriptExplosion component not found!");
		}
		if ((Object)(object)Center == (Object)null)
		{
			Debug.LogError((object)"Center transform is not assigned!");
		}
	}

	private void Update()
	{
		if (SemiFunc.IsMultiplayer())
		{
			switch (currentState)
			{
			case State.Idle:
				StateIdle();
				break;
			case State.Active:
				StateActive();
				break;
			}
		}
	}

	private void StateIdle()
	{
		if (coolDownUntilNextSentence > 0f && physGrabObject.grabbed)
		{
			coolDownUntilNextSentence -= Time.deltaTime;
		}
		else if ((Object)(object)PhysGrabber.instance != (Object)null && PhysGrabber.instance.grabbed && (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject == (Object)(object)physGrabObject)
		{
			currentState = State.Active;
			Debug.Log((object)"CHICKEN JOCKEY activated!");
		}
	}

	private void StateActive()
	{
		if (PhysGrabber.instance.grabbed && (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject != (Object)(object)physGrabObject)
		{
			currentState = State.Idle;
			coolDownUntilNextSentence = Random.Range(1f, 3f);
		}
		else
		{
			currentState = State.Idle;
			coolDownUntilNextSentence = Random.Range(1f, 3f);
		}
	}

	public void Explode()
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)particleScriptExplosion == (Object)null)
		{
			Debug.LogError((object)"particleScriptExplosion is null. Attach the component.");
			return;
		}
		if ((Object)(object)Center == (Object)null)
		{
			Debug.LogError((object)"Center transform is not assigned.");
			return;
		}
		particleScriptExplosion.Spawn(Center.position, 3f, 150, 150, 2f, false, false, 5f);
		physGrabObject.dead = true;
	}

	public void TryExplosion()
	{
		if (SemiFunc.IsMasterClient())
		{
			bool flag = Random.Range(0f, 1f) < ExplosionChance / 100f;
			if (!isExploding && flag)
			{
				((MonoBehaviourPun)this).photonView.RPC("StartExplosionRpc", (RpcTarget)0, Array.Empty<object>());
			}
		}
	}

	[PunRPC]
	public void StartExplosionRpc()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		isExploding = true;
		Sound preExplosionSound = PreExplosionSound;
		if (preExplosionSound != null)
		{
			preExplosionSound.Play(Center.position, 1f, 1f, 1f, 1f);
		}
		((MonoBehaviour)this).Invoke("Explode", 1.1f);
	}
}
public class GiraGirandoPo : MonoBehaviour
{
	private PhysGrabObject physGrabObject;

	private Rigidbody rb;

	public float forceAmount = 50f;

	public float rotationRadius = 1.5f;

	public float rotationSpeed = 3f;

	private Vector3 centerOffset;

	private float angle = 0f;

	private void Start()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
		rb = ((Component)this).GetComponent<Rigidbody>();
		centerOffset = Vector3.right * rotationRadius;
	}

	private void FixedUpdate()
	{
		//