using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("FartingMatvey")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.3.0")]
[assembly: AssemblyInformationalVersion("1.0.3")]
[assembly: AssemblyProduct("FartingMatvey")]
[assembly: AssemblyTitle("FartingMatvey")]
[assembly: AssemblyVersion("1.0.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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;
		}
	}
}
namespace FartingMatvey
{
	internal static class EffectRules
	{
		public const float Duration = 100f;

		public const float SpeedPenalty = 0.3f;

		public const float MinimumInterval = 8f;

		public const float MaximumInterval = 15f;

		public const float AudioTail = 2f;

		public const float MinimumPitch = 0.9f;

		public const float MaximumPitch = 1.1f;

		public const float AudioMargin = 0.25f;

		public const int ClipCount = 8;

		public static float ApplySpeed(float baseSpeed, float currentSpeed)
		{
			return Math.Max(0f, currentSpeed - baseSpeed * 0.3f);
		}
	}
	internal sealed class FartSchedule
	{
		private readonly Random random;

		private readonly float[] durations;

		private int previous = -1;

		internal float NextAt { get; private set; }

		internal float AudioTail { get; }

		public FartSchedule(Random random, float[] clipDurations = null)
		{
			this.random = random ?? throw new ArgumentNullException("random");
			AudioTail = 2f;
			if (clipDurations != null)
			{
				if (clipDurations.Length != 8)
				{
					throw new ArgumentException("Expected eight sound durations.", "clipDurations");
				}
				durations = (float[])clipDurations.Clone();
				float[] array = durations;
				foreach (float num in array)
				{
					if (float.IsNaN(num) || float.IsInfinity(num) || num <= 0f || num > 15f)
					{
						throw new ArgumentException("Invalid sound duration.", "clipDurations");
					}
					AudioTail = Math.Max(AudioTail, num / 0.9f + 0.25f);
				}
			}
			Reset();
		}

		public void Reset()
		{
			previous = -1;
			NextAt = Range(2f, 4f);
		}

		public bool TryNext(float elapsed, out int clip, out float pitch)
		{
			clip = -1;
			pitch = 1f;
			if (float.IsNaN(elapsed) || elapsed < NextAt || elapsed >= 100f - AudioTail)
			{
				return false;
			}
			int num = random.Next(8 - ((previous >= 0) ? 1 : 0));
			if (previous >= 0 && num >= previous)
			{
				num++;
			}
			previous = (clip = num);
			pitch = Range(0.9f, 1.1f);
			float num2 = Range(8f, 15f);
			if (durations != null)
			{
				num2 = Math.Max(num2, durations[clip] / pitch + 0.25f);
			}
			NextAt = elapsed + num2;
			return true;
		}

		private float Range(float min, float max)
		{
			return min + (float)random.NextDouble() * (max - min);
		}
	}
	internal static class FartSynthesis
	{
		public const int SampleRate = 22050;

		private static readonly double[] Length = new double[8] { 0.38, 0.61, 0.83, 1.15, 1.38, 0.49, 0.96, 0.7 };

		private static readonly double[] Frequency = new double[8] { 92.0, 63.0, 120.0, 53.0, 76.0, 148.0, 67.0, 104.0 };

		public static float[] Create(int variant)
		{
			if (variant < 0 || variant >= 8)
			{
				throw new ArgumentOutOfRangeException("variant");
			}
			Random random = new Random(1701 + variant * 997);
			double num = Length[variant];
			float[] array = new float[(int)(22050.0 * num)];
			double num2 = 0.0;
			double num3 = 0.0;
			double num4 = 0.0;
			double num5 = 0.0;
			float num6 = 0f;
			for (int i = 0; i < array.Length; i++)
			{
				double num7 = (double)i / 22050.0;
				double num8 = num7 / num;
				double num9 = random.NextDouble() * 2.0 - 1.0;
				num3 += 0.035 * (num9 - num3);
				double num10 = Math.Sin(Math.PI * 2.0 * (22.0 + (double)variant * 3.7) * num7);
				double num11 = Frequency[variant] * (1.18 - 0.62 * num8) * (1.0 + 0.13 * num10 + 0.45 * num3);
				if (variant == 5)
				{
					num11 *= 1.0 + 0.35 * Math.Sin(Math.PI * 6.0 * num7);
				}
				num2 += Math.PI * 2.0 * num11 / 22050.0;
				double num12 = Math.Tanh(2.9 * (Math.Sin(num2) + 0.38 * Math.Sin(2.0 * num2 + 0.5)));
				double num13 = ((variant == 2 || variant == 6) ? (0.18 + 0.82 * Math.Pow(0.5 + 0.5 * Math.Sin(Math.PI * 2.0 * (double)(7 + variant) * num7), 1.8)) : (0.65 + 0.35 * (0.5 + 0.5 * num10)));
				double num14 = Math.Min(1.0, num7 / 0.012) * Math.Pow(Math.Max(0.0, 1.0 - num8), 0.65) * Math.Min(1.0, (num - num7) / 0.055) * num13 * (0.7 * num12 + 0.28 * num9 + 1.8 * num3);
				num5 = 0.992 * (num5 + num14 - num4);
				num4 = num14;
				array[i] = (float)num5;
				num6 = Math.Max(num6, Math.Abs(array[i]));
			}
			if (num6 > 0f)
			{
				for (int j = 0; j < array.Length; j++)
				{
					array[j] *= 0.78f / num6;
				}
			}
			array[0] = (array[^1] = 0f);
			return array;
		}
	}
	internal static class JetRules
	{
		internal const float Duration = 0.55f;

		internal const float InitialSpeed = 8f;

		internal static float SpeedAt(float elapsed)
		{
			if (float.IsNaN(elapsed) || elapsed < 0f || elapsed >= 0.55f)
			{
				return 0f;
			}
			return 8f * (1f - elapsed / 0.55f);
		}
	}
	[HarmonyPatch(typeof(Player), "Awake")]
	internal static class PlayerAudioPatch
	{
		private static void Postfix(Player __instance)
		{
			if (!Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<MatveyAudio>()))
			{
				((Component)__instance).gameObject.AddComponent<MatveyAudio>();
			}
		}
	}
	public sealed class MatveyAudio : MonoBehaviour
	{
		private const string PlayRpc = "Matvey_PlayFart_v1";

		private const string StopRpc = "Matvey_StopFart_v1";

		private ZNetView view;

		private Player player;

		private AudioSource source;

		private ParticleSystem gas;

		private bool registered;

		private float lastPlay = -100f;

		private bool usesMixer;

		private void Start()
		{
			Initialize();
		}

		private bool Initialize()
		{
			if (registered)
			{
				return true;
			}
			view = ((Component)this).GetComponent<ZNetView>();
			player = ((Component)this).GetComponent<Player>();
			if (!Object.op_Implicit((Object)(object)view) || !view.IsValid() || !Object.op_Implicit((Object)(object)player))
			{
				return false;
			}
			view.Register<int, float>("Matvey_PlayFart_v1", (Action<long, int, float>)ReceivePlay);
			view.Register("Matvey_StopFart_v1", (Action<long>)ReceiveStop);
			registered = true;
			return true;
		}

		internal void Broadcast(int clip, float pitch)
		{
			if (Initialize() && view.IsOwner())
			{
				view.InvokeRPC(ZNetView.Everybody, "Matvey_PlayFart_v1", new object[2] { clip, pitch });
			}
		}

		internal void BroadcastStop()
		{
			if (Initialize() && view.IsOwner())
			{
				view.InvokeRPC(ZNetView.Everybody, "Matvey_StopFart_v1", Array.Empty<object>());
			}
		}

		private bool FromOwner(long sender)
		{
			if (Object.op_Implicit((Object)(object)view) && view.IsValid())
			{
				return sender == view.GetZDO().GetOwner();
			}
			return false;
		}

		private void ReceivePlay(long sender, int clip, float pitch)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			if (!FromOwner(sender) || !Object.op_Implicit((Object)(object)player) || ((Character)player).IsDead() || Application.isBatchMode || Plugin.Sounds == null || clip < 0 || clip >= Plugin.Sounds.Length || float.IsNaN(pitch) || float.IsInfinity(pitch) || Time.unscaledTime - lastPlay < 2f)
			{
				return;
			}
			lastPlay = Time.unscaledTime;
			EnsureSource();
			source.clip = Plugin.Sounds[clip];
			source.pitch = Mathf.Clamp(pitch, 0.9f, 1.1f);
			source.volume = Plugin.SoundVolume.Value * (usesMixer ? 1f : AudioMan.GetSFXVolume());
			source.Play();
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Vector3 val = ((Component)Player.m_localPlayer).transform.position - ((Component)this).transform.position;
				if (!(((Vector3)(ref val)).sqrMagnitude <= 1225f))
				{
					return;
				}
			}
			if (!Object.op_Implicit((Object)(object)gas))
			{
				gas = MatveyGas.Create(((Component)this).transform);
			}
			MatveyGas.Play(gas, ((Component)this).transform);
		}

		private void ReceiveStop(long sender)
		{
			if (FromOwner(sender))
			{
				if (Object.op_Implicit((Object)(object)source))
				{
					source.Stop();
				}
				if (Object.op_Implicit((Object)(object)gas))
				{
					gas.Stop(true, (ParticleSystemStopBehavior)0);
				}
			}
		}

		private void EnsureSource()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)source))
			{
				return;
			}
			GameObject val = new GameObject("MatveyAudio");
			val.transform.SetParent(((Component)this).transform, false);
			val.transform.localPosition = new Vector3(0f, 0.8f, 0f);
			source = val.AddComponent<AudioSource>();
			source.playOnAwake = false;
			source.loop = false;
			source.spatialBlend = 1f;
			source.dopplerLevel = 0f;
			source.minDistance = 2f;
			source.maxDistance = 18f;
			source.rolloffMode = (AudioRolloffMode)1;
			if (Object.op_Implicit((Object)(object)AudioMan.instance) && Object.op_Implicit((Object)(object)AudioMan.instance.m_masterMixer))
			{
				AudioMixerGroup[] array = AudioMan.instance.m_masterMixer.FindMatchingGroups("SFX");
				if (array.Length != 0)
				{
					source.outputAudioMixerGroup = array[0];
					usesMixer = true;
				}
			}
		}

		private void Update()
		{
			if (Object.op_Implicit((Object)(object)player) && ((Character)player).IsDead())
			{
				if (Object.op_Implicit((Object)(object)source) && source.isPlaying)
				{
					source.Stop();
				}
				if (Object.op_Implicit((Object)(object)gas) && gas.IsAlive())
				{
					gas.Stop(true, (ParticleSystemStopBehavior)0);
				}
			}
		}
	}
	internal static class MatveyGas
	{
		private static Material material;

		private static Texture2D texture;

		private static bool attempted;

		private static bool Prepare()
		{
			//IL_00ea: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			if (attempted)
			{
				return Object.op_Implicit((Object)(object)material);
			}
			attempted = true;
			Shader val = Shader.Find("Particles/Standard Unlit");
			Material val2 = null;
			if (!Object.op_Implicit((Object)(object)val) || !val.isSupported)
			{
				ParticleSystemRenderer[] array = Resources.FindObjectsOfTypeAll<ParticleSystemRenderer>();
				for (int i = 0; i < array.Length; i++)
				{
					Material sharedMaterial = ((Renderer)array[i]).sharedMaterial;
					if (Object.op_Implicit((Object)(object)sharedMaterial) && Object.op_Implicit((Object)(object)sharedMaterial.shader) && sharedMaterial.shader.isSupported && ((Object)sharedMaterial.shader).name.ToLowerInvariant().Contains("particle") && sharedMaterial.HasProperty("_MainTex"))
					{
						val2 = sharedMaterial;
						val = sharedMaterial.shader;
						break;
					}
				}
			}
			if (!Object.op_Implicit((Object)(object)val) || !val.isSupported)
			{
				Plugin instance = Plugin.Instance;
				if (instance != null)
				{
					instance.LoggerForEffects.LogWarning((object)"No supported particle shader for Matvey gas; audio and movement remain available.");
				}
				return false;
			}
			texture = new Texture2D(32, 32, (TextureFormat)4, false)
			{
				name = "Matvey soft gas opacity",
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1
			};
			Color[] array2 = (Color[])(object)new Color[1024];
			for (int j = 0; j < 32; j++)
			{
				for (int k = 0; k < 32; k++)
				{
					float num = ((float)k - 15.5f) / 15.5f;
					float num2 = ((float)j - 15.5f) / 15.5f;
					float num3 = Mathf.Pow(Mathf.Clamp01(1f - num * num - num2 * num2), 1.5f);
					array2[j * 32 + k] = new Color(1f, 1f, 1f, num3);
				}
			}
			texture.SetPixels(array2);
			texture.Apply(false, true);
			material = (Object.op_Implicit((Object)(object)val2) ? new Material(val2) : new Material(val));
			((Object)material).name = "Matvey green gas";
			material.mainTexture = (Texture)(object)texture;
			material.mainTextureScale = Vector2.one;
			material.mainTextureOffset = Vector2.zero;
			material.renderQueue = 3000;
			string[] array3 = new string[5] { "_ALPHATEST_ON", "_ALPHAPREMULTIPLY_ON", "_EMISSION", "_NORMALMAP", "_FADING_ON" };
			foreach (string text in array3)
			{
				material.DisableKeyword(text);
			}
			material.EnableKeyword("_ALPHABLEND_ON");
			if (material.HasProperty("_Mode"))
			{
				material.SetFloat("_Mode", 2f);
			}
			if (material.HasProperty("_SrcBlend"))
			{
				material.SetInt("_SrcBlend", 5);
			}
			if (material.HasProperty("_DstBlend"))
			{
				material.SetInt("_DstBlend", 10);
			}
			if (material.HasProperty("_ZWrite"))
			{
				material.SetInt("_ZWrite", 0);
			}
			if (material.HasProperty("_Cull"))
			{
				material.SetInt("_Cull", 0);
			}
			array3 = new string[3] { "_Color", "_TintColor", "_BaseColor" };
			foreach (string text2 in array3)
			{
				if (material.HasProperty(text2))
				{
					material.SetColor(text2, Color.white);
				}
			}
			return true;
		}

		internal static ParticleSystem Create(Transform player)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0035: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			if (!Prepare())
			{
				return null;
			}
			GameObject val = new GameObject("Matvey green puff");
			val.transform.SetParent(player, false);
			val.transform.localPosition = new Vector3(0f, 0.85f, -0.35f);
			ParticleSystem val2 = val.AddComponent<ParticleSystem>();
			val2.Stop(true, (ParticleSystemStopBehavior)0);
			MainModule main = val2.main;
			((MainModule)(ref main)).loop = false;
			((MainModule)(ref main)).playOnAwake = false;
			((MainModule)(ref main)).duration = 1.2f;
			((MainModule)(ref main)).startLifetime = MinMaxCurve.op_Implicit(1.05f);
			((MainModule)(ref main)).startSpeed = MinMaxCurve.op_Implicit(0f);
			((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(0.5f);
			((MainModule)(ref main)).maxParticles = 24;
			((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)1;
			EmissionModule emission = val2.emission;
			((EmissionModule)(ref emission)).enabled = false;
			ShapeModule shape = val2.shape;
			((ShapeModule)(ref shape)).enabled = false;
			ColorOverLifetimeModule colorOverLifetime = val2.colorOverLifetime;
			((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
			Gradient val3 = new Gradient();
			val3.SetKeys((GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey(Color.white, 0f),
				new GradientColorKey(new Color(0.65f, 0.75f, 0.4f), 1f)
			}, (GradientAlphaKey[])(object)new GradientAlphaKey[3]
			{
				new GradientAlphaKey(0f, 0f),
				new GradientAlphaKey(1f, 0.12f),
				new GradientAlphaKey(0f, 1f)
			});
			((ColorOverLifetimeModule)(ref colorOverLifetime)).color = MinMaxGradient.op_Implicit(val3);
			SizeOverLifetimeModule sizeOverLifetime = val2.sizeOverLifetime;
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).enabled = true;
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).size = new MinMaxCurve(1f, new AnimationCurve((Keyframe[])(object)new Keyframe[2]
			{
				new Keyframe(0f, 0.6f),
				new Keyframe(1f, 1.9f)
			}));
			ParticleSystemRenderer component = ((Component)val2).GetComponent<ParticleSystemRenderer>();
			component.renderMode = (ParticleSystemRenderMode)0;
			((Renderer)component).sharedMaterial = material;
			((Renderer)component).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)component).receiveShadows = false;
			return val2;
		}

		internal static void Play(ParticleSystem particles, Transform player)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_003e: 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_005b: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_0119: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)particles))
			{
				particles.Stop(true, (ParticleSystemStopBehavior)0);
				particles.Play();
				Vector3 val = Vector3.ProjectOnPlane(player.forward, Vector3.up);
				Vector3 val2 = -((Vector3)(ref val)).normalized;
				for (int i = 0; i < 10; i++)
				{
					EmitParams val3 = default(EmitParams);
					((EmitParams)(ref val3)).position = ((Component)particles).transform.position + Random.insideUnitSphere * 0.09f;
					((EmitParams)(ref val3)).velocity = val2 * Random.Range(0.7f, 1.7f) + player.right * Random.Range(-0.3f, 0.3f) + Vector3.up * Random.Range(0.15f, 0.4f);
					((EmitParams)(ref val3)).startLifetime = Random.Range(0.75f, 1.05f);
					((EmitParams)(ref val3)).startSize = Random.Range(0.4f, 0.7f);
					((EmitParams)(ref val3)).startColor = Color32.op_Implicit(new Color(Random.Range(0.43f, 0.58f), Random.Range(0.62f, 0.76f), 0.12f, 0.8f));
					((EmitParams)(ref val3)).rotation = Random.Range(0f, 360f);
					EmitParams val4 = val3;
					particles.Emit(val4, 1);
				}
			}
		}

		internal static void Cleanup()
		{
			if (Object.op_Implicit((Object)(object)material))
			{
				Object.Destroy((Object)(object)material);
			}
			if (Object.op_Implicit((Object)(object)texture))
			{
				Object.Destroy((Object)(object)texture);
			}
			material = null;
			texture = null;
			attempted = false;
		}
	}
	[HarmonyPatch(typeof(Character), "AddPushbackForce")]
	internal static class MatveyJetPatch
	{
		private static readonly int EffectHash = StringExtensionMethods.GetStableHashCode("SE_MatveySendsRegards");

		private static void Postfix(Character __instance, ref Vector3 velocity)
		{
			if (__instance is Player && __instance.IsOwner() && !__instance.IsDead())
			{
				SEMan sEMan = __instance.GetSEMan();
				(((sEMan != null) ? sEMan.GetStatusEffect(EffectHash) : null) as SE_Matvey)?.ApplyJet(ref velocity);
			}
		}
	}
	[BepInPlugin("local.matvey.fartingmead", "Farting Matvey", "1.0.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string Guid = "local.matvey.fartingmead";

		public const string MeadName = "MeadMatvey";

		public const string BaseName = "MeadBaseMatvey";

		public const string EffectName = "SE_MatveySendsRegards";

		internal static Plugin Instance;

		internal static ConfigEntry<float> SoundVolume;

		internal static AudioClip[] Sounds;

		internal static float[] SoundDurations;

		internal static Sprite StatusIcon;

		private Harmony harmony;

		private Sprite baseIcon;

		private Sprite meadIcon;

		private ConfigEntry<int> iconVariant;

		private SE_Matvey effect;

		private readonly List<Object> ownedAssets = new List<Object>();

		internal ManualLogSource LoggerForEffects => ((BaseUnityPlugin)this).Logger;

		private void Awake()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			Instance = this;
			iconVariant = ((BaseUnityPlugin)this).Config.Bind<int>("Visuals", "StatusIcon", 1, new ConfigDescription("1 = Matvey mead with green foam; 2 = tipsy swirl; 3 = green cloud. Applied after restarting the game.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 3), Array.Empty<object>()));
			SoundVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Audio", "Volume", 0.65f, new ConfigDescription("Local sound volume, additionally controlled by the game's SFX volume.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			AddLocalization();
			baseIcon = LoadSprite("mead-base.png");
			meadIcon = LoadSprite("mead.png");
			StatusIcon = LoadSprite("status-" + iconVariant.Value + ".png");
			effect = ScriptableObject.CreateInstance<SE_Matvey>();
			((Object)effect).name = "SE_MatveySendsRegards";
			((StatusEffect)effect).m_name = "$matvey_effect";
			((StatusEffect)effect).m_icon = StatusIcon;
			((StatusEffect)effect).m_ttl = 100f;
			((StatusEffect)effect).m_hidden = false;
			((StatusEffect)effect).m_flashIcon = false;
			((StatusEffect)effect).m_startMessageType = (MessageType)2;
			((StatusEffect)effect).m_startMessage = "$matvey_effect";
			((StatusEffect)effect).m_stopMessage = "$matvey_finished";
			((StatusEffect)effect).m_stopMessageType = (MessageType)1;
			((StatusEffect)effect).m_startEffects = new EffectList();
			((StatusEffect)effect).m_stopEffects = new EffectList();
			if (!ItemManager.Instance.AddStatusEffect(new CustomStatusEffect((StatusEffect)(object)effect, false)))
			{
				throw new InvalidOperationException("Could not register the Matvey status effect.");
			}
			ownedAssets.Add((Object)(object)effect);
			if (!Application.isBatchMode)
			{
				CreateSounds();
			}
			harmony = new Harmony("local.matvey.fartingmead");
			harmony.PatchAll(typeof(Plugin).Assembly);
			PrefabManager.OnVanillaPrefabsAvailable += RegisterItems;
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Matvey ready: 100 seconds, movement -30%, reactive forward bursts and green gas, 8 sound variants, HUD icon " + iconVariant.Value));
		}

		private Sprite LoadSprite(string file)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0093: 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)
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("FartingMatvey.Assets." + file);
			if (stream == null)
			{
				throw new FileNotFoundException("Missing embedded icon", file);
			}
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (!ImageConversion.LoadImage(val, memoryStream.ToArray()))
			{
				throw new InvalidDataException("Invalid icon " + file);
			}
			((Object)val).name = "Matvey_" + file;
			((Texture)val).filterMode = (FilterMode)0;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)val2).name = "Matvey_" + file;
			ownedAssets.Add((Object)(object)val);
			ownedAssets.Add((Object)(object)val2);
			return val2;
		}

		private void CreateSounds()
		{
			Sounds = (AudioClip[])(object)new AudioClip[8];
			SoundDurations = new float[8];
			string directory = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "Sounds");
			for (int i = 0; i < Sounds.Length; i++)
			{
				string text = "matvey-" + (i + 1).ToString("00") + ".wav";
				WaveSamples waveSamples = LoadSound(i, directory, text);
				AudioClip val = AudioClip.Create("Matvey_fart_" + (i + 1), waveSamples.Frames, waveSamples.Channels, waveSamples.SampleRate, false);
				ownedAssets.Add((Object)(object)val);
				if (!val.SetData(waveSamples.Samples, 0))
				{
					throw new InvalidOperationException("Could not load sound " + text);
				}
				Sounds[i] = val;
				SoundDurations[i] = waveSamples.Duration;
			}
		}

		private WaveSamples LoadSound(int variant, string directory, string file)
		{
			string path = Path.Combine(directory, file);
			if (File.Exists(path))
			{
				try
				{
					using Stream stream = File.OpenRead(path);
					WaveSamples waveSamples = WaveSamples.Read(stream);
					((BaseUnityPlugin)this).Logger.LogInfo((object)("Custom sound " + file + ": " + waveSamples.Duration.ToString("0.000") + " seconds."));
					return waveSamples;
				}
				catch (Exception ex) when (ex is IOException || ex is InvalidDataException || ex is UnauthorizedAccessException || ex is ArgumentException)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not read " + file + "; using the bundled sound. " + ex.Message));
				}
			}
			using (Stream stream2 = Assembly.GetExecutingAssembly().GetManifestResourceStream("FartingMatvey.Assets.Sounds." + file))
			{
				if (stream2 != null)
				{
					return WaveSamples.Read(stream2);
				}
			}
			return new WaveSamples(FartSynthesis.Create(variant), 1, 22050);
		}

		private void RegisterItems()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Expected O, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Expected O, but got Unknown
			PrefabManager.OnVanillaPrefabsAvailable -= RegisterItems;
			try
			{
				string[] array = new string[8] { "MeadPoisonResist", "MeadBasePoisonResist", "Honey", "Mushroom", "Ooze", "Pukeberries", "piece_MeadCauldron", "fermenter" };
				foreach (string text in array)
				{
					if (!Object.op_Implicit((Object)(object)PrefabManager.Instance.GetPrefab(text)))
					{
						throw new InvalidOperationException("Missing vanilla prefab: " + text);
					}
				}
				CustomItem val = new CustomItem("MeadMatvey", "MeadPoisonResist");
				SharedData shared = val.ItemDrop.m_itemData.m_shared;
				shared.m_name = "$item_matvey";
				shared.m_description = "$item_matvey_description";
				shared.m_icons = (Sprite[])(object)new Sprite[1] { meadIcon };
				shared.m_consumeStatusEffect = (StatusEffect)(object)effect;
				shared.m_maxStackSize = 10;
				shared.m_food = 0f;
				shared.m_foodStamina = 0f;
				shared.m_foodEitr = 0f;
				if (!ItemManager.Instance.AddItem(val))
				{
					throw new InvalidOperationException("Could not add MeadMatvey");
				}
				ItemConfig val2 = new ItemConfig
				{
					Name = "$item_matveybase",
					Description = "$item_matveybase_description",
					CraftingStation = "piece_MeadCauldron",
					MinStationLevel = 1,
					Amount = 1,
					Icon = baseIcon
				};
				val2.AddRequirement("Honey", 5, 0);
				val2.AddRequirement("Mushroom", 2, 0);
				val2.AddRequirement("Ooze", 1, 0);
				val2.AddRequirement("Pukeberries", 1, 0);
				CustomItem val3 = new CustomItem("MeadBaseMatvey", "MeadBasePoisonResist", val2);
				if (!ItemManager.Instance.AddItem(val3))
				{
					throw new InvalidOperationException("Could not add MeadBaseMatvey");
				}
				if (!ItemManager.Instance.AddItemConversion(new CustomItemConversion((ConversionConfig)new FermenterConversionConfig
				{
					FromItem = "MeadBaseMatvey",
					ToItem = "MeadMatvey",
					Station = Fermenters.Fermenter,
					ProducedItems = 6
				})))
				{
					throw new InvalidOperationException("Could not register Matvey fermentation.");
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Registered MeadBaseMatvey -> 6 MeadMatvey. Recipe: Honey 5, Mushroom 2, Ooze 1, Pukeberries 1.");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Matvey item registration failed: " + ex));
			}
		}

		private void AddLocalization()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>
			{
				["item_matvey"] = "Пердящий Матвей",
				["item_matvey_description"] = "Матвей уверял, что это нормальный осадок. На 100 секунд: скорость передвижения −30%, периодические залпы со звуком, зелёным облаком и коротким толчком вперёд на земле.",
				["item_matveybase"] = "Основа медовухи: Пердящий Матвей",
				["item_matveybase_description"] = "Мёд, грибы, слизь и рвотная ягода. Требует брожения. Готовая медовуха на 100 секунд снижает скорость на 30% и вызывает залпы с зелёным облаком и коротким толчком вперёд на земле. Бочка уже жалеет, что согласилась.",
				["matvey_effect"] = "Матвей передаёт привет",
				["matvey_tooltip"] = "Скорость передвижения −30%\nРеактивные залпы: короткий толчок вперёд на земле, звук и зелёное облако.\nДлительность: 100 секунд.",
				["matvey_finished"] = "Матвей попрощался."
			};
			CustomLocalization localization = LocalizationManager.Instance.GetLocalization();
			string text = "English";
			localization.AddTranslation(ref text, dictionary);
			text = "Russian";
			localization.AddTranslation(ref text, dictionary);
		}

		private void OnDestroy()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= RegisterItems;
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			MatveyGas.Cleanup();
			foreach (Object ownedAsset in ownedAssets)
			{
				if (Object.op_Implicit(ownedAsset))
				{
					Object.Destroy(ownedAsset);
				}
			}
			Sounds = null;
			SoundDurations = null;
			Instance = null;
		}
	}
	public sealed class SE_Matvey : StatusEffect
	{
		private FartSchedule schedule;

		private float jetElapsed = 0.55f;

		private Vector3 jetDirection;

		public override bool CanAdd(Character character)
		{
			return character is Player;
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			schedule = new FartSchedule(new Random(Environment.TickCount ^ ((Object)character).GetInstanceID()), Plugin.SoundDurations);
			CancelJet();
		}

		public override void ResetTime()
		{
			((StatusEffect)this).ResetTime();
			schedule?.Reset();
			CancelJet();
		}

		public override void UpdateStatusEffect(float dt)
		{
			//IL_0082: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			((StatusEffect)this).UpdateStatusEffect(dt);
			jetElapsed = Mathf.Min(0.55f, jetElapsed + dt);
			if (Object.op_Implicit((Object)(object)base.m_character) && !base.m_character.IsDead() && base.m_character.IsOwner() && !((StatusEffect)this).IsDone() && schedule != null && schedule.TryNext(base.m_time, out var clip, out var pitch))
			{
				if (CanJet())
				{
					Vector3 val = Vector3.ProjectOnPlane(((Component)base.m_character).transform.forward, Vector3.up);
					jetDirection = ((Vector3)(ref val)).normalized;
					jetElapsed = 0f;
				}
				((Component)base.m_character).GetComponent<MatveyAudio>()?.Broadcast(clip, pitch);
			}
		}

		private bool CanJet()
		{
			if (Object.op_Implicit((Object)(object)base.m_character) && base.m_character.IsOwner() && !((StatusEffect)this).IsDone() && base.m_character.IsOnGround() && !base.m_character.IsAttached() && !base.m_character.IsTeleporting() && !base.m_character.InCutscene() && !base.m_character.InIntro() && !base.m_character.IsDebugFlying())
			{
				return !base.m_character.IsKnockedBack();
			}
			return false;
		}

		internal void ApplyJet(ref Vector3 velocity)
		{
			//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_0032: 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)
			float num = JetRules.SpeedAt(jetElapsed);
			if (!(num <= 0f))
			{
				if (!CanJet())
				{
					CancelJet();
				}
				else
				{
					velocity += jetDirection * num;
				}
			}
		}

		private void CancelJet()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			jetElapsed = 0.55f;
			jetDirection = Vector3.zero;
		}

		public override bool IsDone()
		{
			if (!(base.m_time >= base.m_ttl))
			{
				if (Object.op_Implicit((Object)(object)base.m_character))
				{
					return base.m_character.IsDead();
				}
				return false;
			}
			return true;
		}

		public override void ModifySpeed(float baseSpeed, ref float speed, Character character, Vector3 dir)
		{
			if (!((StatusEffect)this).IsDone())
			{
				speed = EffectRules.ApplySpeed(baseSpeed, speed);
			}
		}

		public override string GetTooltipString()
		{
			return Localization.instance.Localize("$matvey_tooltip");
		}

		public override void Stop()
		{
			schedule = null;
			CancelJet();
			if (Object.op_Implicit((Object)(object)base.m_character) && base.m_character.IsOwner())
			{
				((Component)base.m_character).GetComponent<MatveyAudio>()?.BroadcastStop();
			}
			((StatusEffect)this).Stop();
		}
	}
	internal sealed class WaveSamples
	{
		internal const int MaximumFileBytes = 16777216;

		internal const float MaximumDuration = 15f;

		internal float[] Samples { get; }

		internal int Channels { get; }

		internal int SampleRate { get; }

		internal int Frames => Samples.Length / Channels;

		internal float Duration => (float)Frames / (float)SampleRate;

		internal WaveSamples(float[] samples, int channels, int sampleRate)
		{
			Samples = samples;
			Channels = channels;
			SampleRate = sampleRate;
		}

		internal static WaveSamples Read(Stream stream)
		{
			if (!stream.CanRead || !stream.CanSeek || stream.Length < 44 || stream.Length > 16777216)
			{
				throw new InvalidDataException("WAV must be a readable file no larger than 16 MiB.");
			}
			stream.Position = 0L;
			using BinaryReader binaryReader = new BinaryReader(stream, Encoding.ASCII, leaveOpen: true);
			if (FourCC(binaryReader) != "RIFF")
			{
				throw new InvalidDataException("Expected RIFF WAV.");
			}
			long num = 8L + (long)binaryReader.ReadUInt32();
			if (num < 44 || num > stream.Length || FourCC(binaryReader) != "WAVE")
			{
				throw new InvalidDataException("Invalid or truncated WAV header.");
			}
			bool flag = false;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			long num5 = -1L;
			uint num6 = 0u;
			while (stream.Position + 8 <= num)
			{
				string text = FourCC(binaryReader);
				uint num7 = binaryReader.ReadUInt32();
				long position = stream.Position;
				long num8 = position + num7 + (num7 & 1);
				if (num8 > num)
				{
					throw new InvalidDataException("Truncated WAV chunk.");
				}
				if (text == "fmt ")
				{
					if (flag || num7 < 16)
					{
						throw new InvalidDataException("Invalid WAV format chunk.");
					}
					flag = true;
					ushort num9 = binaryReader.ReadUInt16();
					num2 = binaryReader.ReadUInt16();
					uint num10 = binaryReader.ReadUInt32();
					uint num11 = binaryReader.ReadUInt32();
					num4 = binaryReader.ReadUInt16();
					ushort num12 = binaryReader.ReadUInt16();
					if (num9 != 1 || num12 != 16 || (num2 != 1 && num2 != 2))
					{
						throw new InvalidDataException("Export as WAV PCM 16-bit, mono or stereo.");
					}
					if (num10 < 8000 || num10 > 192000 || num4 != num2 * 2 || num11 != num10 * num4)
					{
						throw new InvalidDataException("Invalid WAV sample rate or frame size.");
					}
					num3 = (int)num10;
				}
				else if (text == "data")
				{
					if (num5 >= 0)
					{
						throw new InvalidDataException("Multiple WAV data chunks are unsupported.");
					}
					num5 = position;
					num6 = num7;
				}
				stream.Position = num8;
			}
			if (stream.Position != num || !flag || num5 < 0 || num6 == 0 || num6 % num4 != 0L)
			{
				throw new InvalidDataException("Missing or incomplete WAV audio data.");
			}
			if ((double)num6 / (double)num4 / (double)num3 > 15.0)
			{
				throw new InvalidDataException("Sound must be at most 15 seconds long.");
			}
			stream.Position = num5;
			float[] array = new float[(int)num6 / 2];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = (float)binaryReader.ReadInt16() / 32768f;
			}
			return new WaveSamples(array, num2, num3);
		}

		private static string FourCC(BinaryReader reader)
		{
			return Encoding.ASCII.GetString(reader.ReadBytes(4));
		}
	}
}