using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.WebSockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using ButtplugSong;
using ButtplugSong.GUI;
using ButtplugSong.GUI.CustomUI;
using ButtplugSong.GUI.Network;
using ButtplugSong.GUI.VibeSettings;
using ButtplugSong.GUI.VibeSettings.LimitSettings;
using ButtplugSong.GUI.VibeSettings.Presets;
using ButtplugSong.GUI.VibeSettings.VibeSources;
using ButtplugSong.Helper;
using ButtplugSong.Network;
using GlobalEnums;
using GlobalSettings;
using GoodVibes;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Linq;
using UnityEngine;
using UnityEngine.Scripting;
using UnityEngine.UIElements;

[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("ButtplugSong")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.2.0")]
[assembly: AssemblyInformationalVersion("1.2.2+1a342453a3a9f4fa7c6a0b2a045a02a6e1ff9d44")]
[assembly: AssemblyProduct("ButtplugSong")]
[assembly: AssemblyTitle("Buttplug_Song")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/danatron1/ButtplugSong")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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 static class FloatHelper
{
	public static float Clamp(this float value, float min, float max)
	{
		if (value > max)
		{
			return max;
		}
		if (value < min)
		{
			return min;
		}
		return value;
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace GoodVibes
{
	internal enum WaveType
	{
		ConstantLinear,
		ConstantExponental,
		SineSmall,
		SineBig,
		Square,
		PulseWidth,
		Triangle,
		InverseTriangle,
		Bounce,
		ZigZag
	}
	public enum AfterZeroMode
	{
		Subtract,
		Multiply
	}
	internal class VibeLogic
	{
		private class ActivityLogEntry
		{
			internal string Identifier;

			internal string Details;

			internal ActivityLogEntry? TriggeredLog;

			public ActivityLogEntry(string identifier, string details)
			{
				Identifier = identifier;
				Details = details;
				base..ctor();
			}
		}

		public static bool Armed;

		private Action<string>? _logger;

		private (string identifier, string details)? triggeredActivityLog;

		internal bool timerCountdownPaused = true;

		internal bool vibeWhileTimerPaused = true;

		internal const float _actualHardTimerMaximum = 5999f;

		private float _maxTimer = 600f;

		private float _timeRemaining;

		internal AfterZeroMode afterZeroMode;

		internal float afterZeroPowerChange = 1f;

		internal float afterZeroTimer;

		internal float afterZeroPunctuate;

		private float punctuatingTimer;

		private float _maxPower = 1f;

		private float _minPower;

		private float _targetPower;

		public WaveType waveType;

		public float wavePeriod = 1f;

		public float ComboMultiplier = 1f;

		private float _timeSinceLastActivityLog;

		public float MaxTimer
		{
			get
			{
				return _maxTimer;
			}
			set
			{
				_maxTimer = value.Clamp(0f, 5999f);
				if (Time > _maxTimer)
				{
					Time = _maxTimer;
				}
			}
		}

		public bool TimerZero => _timeRemaining <= 0f;

		public bool IsVibing => ActualPower > 0f;

		public float Time
		{
			get
			{
				return _timeRemaining;
			}
			set
			{
				bool flag = !TimerZero;
				_timeRemaining = value.Clamp(0f, MaxTimer);
				if (TimerZero && flag)
				{
					TimerBecameZero();
				}
			}
		}

		public bool Punctuating => punctuatingTimer > 0f;

		public float MaxPower
		{
			get
			{
				return _maxPower;
			}
			set
			{
				float maxPower = _maxPower;
				_maxPower = value.Clamp(0f, 1f);
				if (MinPower > MaxPower)
				{
					MinPower = MaxPower;
				}
				if (_maxPower != maxPower)
				{
					UpdatePowerClamped(TargetPower);
				}
			}
		}

		public float MinPower
		{
			get
			{
				return _minPower;
			}
			set
			{
				float minPower = _minPower;
				_minPower = value.Clamp(0f, MaxPower);
				if (_minPower != minPower)
				{
					UpdatePowerClamped(TimerZero ? _minPower : TargetPower);
				}
			}
		}

		public float TargetPower
		{
			get
			{
				return _targetPower;
			}
			private set
			{
				UpdatePowerClamped(value);
			}
		}

		public float ActualPower
		{
			get
			{
				if (timerCountdownPaused && !vibeWhileTimerPaused)
				{
					return GetWavePower(MinPower);
				}
				if (Punctuating)
				{
					return MaxPower;
				}
				if (TimerZero)
				{
					return GetWavePower(MinPower);
				}
				return GetWavePower(TargetPower);
			}
		}

		public event Action? PowerChanged;

		public event Action<bool>? PunctuateChanged;

		public event Action? VibeSourceActivated;

		public event Action? TimerHitZero;

		public event Action<string, string, float>? AddActivityLog;

		private void TimerBecameZero()
		{
			if (TargetPower == MinPower && TimerZero)
			{
				return;
			}
			string text = "Timer Hit Zero";
			string text2;
			if (TargetPower == MinPower)
			{
				text += " : Power Min";
				text2 = "Power hit " + ((MinPower == 0f) ? "zero" : "minimum") + ".\nTimer reset to 0 seconds.";
				Time = 0f;
			}
			else
			{
				float num = (afterZeroMode switch
				{
					AfterZeroMode.Subtract => TargetPower - afterZeroPowerChange, 
					AfterZeroMode.Multiply => TargetPower * afterZeroPowerChange, 
					_ => throw new NotImplementedException(), 
				}).Clamp(MinPower, MaxPower);
				text2 = $"Power: {TargetPower * 100f:0.#}% {AfterZeroModeString()} {afterZeroPowerChange * 100f:0.#}% = {num * 100f:0.#}%";
				if (MinPower != 0f)
				{
					text2 += $" (minimum {MinPower * 100f:0.#}%)";
				}
				if (num - MinPower < 0.02f)
				{
					if (num - MinPower > Mathf.Epsilon)
					{
						text2 = text2 + "\n(New power almost " + ((MinPower == 0f) ? "zero" : "minimum") + "; cutting off)";
					}
					num = MinPower;
				}
				else if (afterZeroTimer <= 0f)
				{
					text2 = text2 + "\nNo timer increase, so setting power to " + ((MinPower == 0f) ? "0" : "minimum") + ".";
					num = MinPower;
				}
				else
				{
					text2 += string.Format("\nTimer set to {0} second{1}.", afterZeroTimer, (afterZeroTimer != 1f) ? "s" : "");
					Time += afterZeroTimer;
				}
				TargetPower = num;
			}
			if (afterZeroPunctuate > 0f)
			{
				AddPunctuateHit(afterZeroPunctuate);
				text2 += $"\nPunctuate: +{afterZeroPunctuate}s of max power";
			}
			triggeredActivityLog = (text, text2);
			this.TimerHitZero?.Invoke();
			string AfterZeroModeString()
			{
				return afterZeroMode switch
				{
					AfterZeroMode.Subtract => "-", 
					AfterZeroMode.Multiply => "*", 
					_ => throw new NotImplementedException(), 
				};
			}
		}

		public void DecreaseTimer(float realTimeAmount, float timerAmount)
		{
			TickActivityLogs(realTimeAmount);
			if (Punctuating)
			{
				punctuatingTimer -= realTimeAmount;
				if (punctuatingTimer <= 0f)
				{
					Time += punctuatingTimer;
					punctuatingTimer = 0f;
					this.PunctuateChanged?.Invoke(obj: false);
				}
			}
			else
			{
				Time -= timerAmount;
			}
			timerCountdownPaused = timerAmount <= float.Epsilon;
		}

		private void UpdatePowerClamped(float value)
		{
			float targetPower = _targetPower;
			_targetPower = value.Clamp(MinPower, MaxPower);
			if (_targetPower != targetPower)
			{
				PowerUpdated(targetPower, _targetPower);
			}
		}

		private void PowerUpdated(float before, float after)
		{
			if (after == MinPower)
			{
				TimerBecameZero();
			}
			this.PowerChanged?.Invoke();
		}

		private float GetWavePower(float power)
		{
			if (waveType == WaveType.ConstantLinear || power == 0f)
			{
				return power;
			}
			float num = Time / wavePeriod;
			return (waveType switch
			{
				WaveType.ConstantExponental => power * power, 
				WaveType.SineSmall => power * ((Mathf.Sin(num * MathF.PI * 2f) + 2f) / 3f), 
				WaveType.SineBig => Mathf.Sin(num * MathF.PI * 2f) * 0.8f * power + 0.8f * power, 
				WaveType.Square => (num % 1f > 0.5f) ? 0f : power, 
				WaveType.PulseWidth => (num % 1f > power) ? 0f : 1f, 
				WaveType.Triangle => num % 1f * power, 
				WaveType.InverseTriangle => power * (1f - num % 1f), 
				WaveType.Bounce => num % 1f * (1f - num % 1f) * power * 4f, 
				WaveType.ZigZag => Mathf.Max(num % 1f, 1f - num % 1f) * power + power / 4f, 
				_ => power, 
			}).Clamp(MinPower, MaxPower);
		}

		public VibeLogic(Action<string>? logger = null)
		{
			_logger = logger;
		}

		public void VibeSourceActivation(string identifier, float power, string powerMode, float time, string timeMode, float punctuateTime, float? basePower = null, float? baseTime = null)
		{
			string powerMode2 = powerMode;
			string timeMode2 = timeMode;
			string identifier2 = identifier;
			float powerBefore;
			float timeBefore;
			float newPower;
			float newTime;
			if (Armed)
			{
				powerBefore = TargetPower;
				timeBefore = Time;
				if (timeMode2 == "+" && !TimerZero)
				{
					time *= ComboMultiplier;
				}
				newPower = ChangeByMode(TargetPower, power, powerMode2).Clamp(MinPower, MaxPower);
				newTime = ChangeByMode(Time, time, timeMode2).Clamp(0f, MaxTimer);
				if (newTime != 0f)
				{
					TargetPower = newPower;
				}
				if (TargetPower != MinPower)
				{
					Time = newTime;
				}
				if (punctuateTime != 0f)
				{
					AddPunctuateHit(punctuateTime);
				}
				SendDetailedActivityLog();
				this.VibeSourceActivated?.Invoke();
			}
			static float ChangeByMode(float original, float modifier, string mode)
			{
				return mode switch
				{
					"+" => original + modifier, 
					"-" => original - modifier, 
					"=" => modifier, 
					"≥" => Mathf.Max(modifier, original), 
					"≤" => Mathf.Min(modifier, original), 
					"x" => original * modifier, 
					_ => original, 
				};
			}
			void SendDetailedActivityLog()
			{
				string text = "";
				if (!PowerFieldMeaningless(power, powerMode2))
				{
					text += $"Power: {powerMode2}{power * 100f:0.#}%";
					if (basePower.HasValue && basePower.Value != power)
					{
						text += $" ({basePower.Value * 100f:0.#}% x {power / basePower.Value:0.###})";
					}
					text = ((newPower != powerBefore) ? (text + $", {powerBefore * 100f:0.#}% -> {newPower * 100f:0.#}%") : (text + $", remain at {powerBefore * 100f:0.#}%"));
					if (MinPower != 0f && newPower == MinPower)
					{
						text += " (min)";
					}
					else if (MaxPower != 1f && newPower == MaxPower)
					{
						text += " (max)";
					}
				}
				if (!TimeFieldMeaningless(time, timeMode2))
				{
					text = text + "\nTime: " + timeMode2 + DisplayTime(time);
					if (baseTime.HasValue && baseTime.Value != time)
					{
						text += $" ({DisplayTime(baseTime.Value, includeS: false)} x {time / baseTime.Value:0.###})";
					}
					text = ((newTime != timeBefore) ? (text + ", " + DisplayTime(timeBefore, includeS: false) + " -> " + DisplayTime(newTime, includeS: false)) : (text + ", remain at " + DisplayTime(timeBefore)));
					if (MaxTimer == newTime)
					{
						text += " (max)";
					}
				}
				if (punctuateTime != 0f)
				{
					text += $"\nPunctuate: +{punctuateTime:0.##}s (now at {punctuatingTimer:0.##}s)";
				}
				text = text.Trim('\n');
				if (!string.IsNullOrWhiteSpace(text))
				{
					ProcessActivityLog(identifier2, text);
				}
			}
		}

		internal static string DisplayTime(float time, bool includeS = true)
		{
			int num = (int)(time / 60f);
			int num2 = num / 60;
			if (num2 >= 1)
			{
				return $"{num2:f0}:{num:00}:{time % 60f:00}";
			}
			if (num >= 1)
			{
				return $"{num:f0}:{time % 60f:00}";
			}
			if (includeS)
			{
				return $"{time:0.#}s";
			}
			return $"{time:0.#}";
		}

		private void AddPunctuateHit(float punctuateTime)
		{
			bool punctuating = Punctuating;
			punctuatingTimer += punctuateTime;
			if (Punctuating != punctuating)
			{
				this.PunctuateChanged?.Invoke(Punctuating);
			}
		}

		internal static bool PowerFieldMeaningless(float power, string powerMode)
		{
			switch (powerMode)
			{
			case "+":
			case "-":
			case "≥":
				return power <= 0f;
			case "≤":
				return power >= 1f;
			case "x":
				return power == 1f;
			default:
				return false;
			}
		}

		internal static bool TimeFieldMeaningless(float time, string timeMode)
		{
			switch (timeMode)
			{
			case "+":
			case "-":
			case "≥":
				return time <= 0f;
			case "x":
				return time == 1f;
			default:
				return false;
			}
		}

		private void Log(string s)
		{
			_logger?.Invoke(s);
		}

		private void TickActivityLogs(float deltaTime)
		{
			_timeSinceLastActivityLog += deltaTime;
			ProcessTriggeredActivityLog();
		}

		private void ProcessActivityLog(string identifier, string details)
		{
			this.AddActivityLog?.Invoke(identifier, details, _timeSinceLastActivityLog);
			_timeSinceLastActivityLog = 0f;
			ProcessTriggeredActivityLog();
		}

		private void ProcessTriggeredActivityLog()
		{
			(string, string)? tuple = triggeredActivityLog;
			if (tuple.HasValue)
			{
				string item = triggeredActivityLog.Value.identifier;
				string item2 = triggeredActivityLog.Value.details;
				triggeredActivityLog = null;
				ProcessActivityLog(item, item2);
			}
		}

		internal void MultiplyTimer(float multiplier, string? subID = null)
		{
			if (multiplier != 1f && Time != 0f)
			{
				float time = Time;
				Time *= multiplier;
				string text = "Multiply Timer";
				if (!string.IsNullOrWhiteSpace(subID))
				{
					text = text + " : " + subID;
				}
				ProcessActivityLog(text, $"Timer {multiplier}x multiplier: {DisplayTime(time, includeS: false)} -> {DisplayTime(Time, includeS: false)}");
			}
		}
	}
	public class VibeManager
	{
		private static VibeManager? _instance;

		internal GUIManager UI;

		internal VibeLogic Logic;

		internal PlugManager plug;

		public float PlugUpdateFrequency = 0.125f;

		private float timeSinceLastPlugUpdate;

		public static VibeManager Instance
		{
			get
			{
				if (_instance == null)
				{
					throw new NotImplementedException("Instantiate properly before referencing! >:(");
				}
				return _instance;
			}
			private set
			{
				_instance = value;
			}
		}

		public bool HasDevice => GetDevices().Any();

		public event Action? PlugReconnectEstablished;

		public event Action<float, float>? NeedsUpdate;

		public event Action<string>? LogMessage;

		public VibeManager(string modPath, Action<string>? logger = null)
		{
			Instance = this;
			if (logger != null)
			{
				LogMessage += logger;
			}
			Logic = new VibeLogic(Log);
			UI = GUIManager.CreateAndInitialize();
			Logic.PowerChanged += TargetPowerChanged;
			Logic.PunctuateChanged += PunctuateChanged;
			NeedsUpdate += Logic.DecreaseTimer;
			ModHooks.OnFinishedLoadingModsHook += FinishedLoading;
			ReconnectPlug();
		}

		private void FinishedLoading()
		{
			VibeLogic.Armed = true;
			UI.FinishedLoading();
		}

		public void Update(float realTime, float timerTime)
		{
			this.NeedsUpdate?.Invoke(realTime, timerTime);
			timeSinceLastPlugUpdate += realTime;
			if (timeSinceLastPlugUpdate > NetworkSettings.UpdateFrequency)
			{
				ForcePlugUpdate(routineUpdate: true);
			}
		}

		public void TargetPowerChanged()
		{
			ForcePlugUpdate(routineUpdate: false);
		}

		public void PunctuateChanged(bool _)
		{
			ForcePlugUpdate(routineUpdate: false);
		}

		public void ForcePlugUpdate(bool routineUpdate)
		{
			timeSinceLastPlugUpdate = 0f;
			plug.SetPowerLevel(Logic.ActualPower, routineUpdate);
		}

		internal IEnumerable<ButtplugDevice> GetDevices()
		{
			return plug.GetDevices();
		}

		internal void ReconnectPlug()
		{
			DisconnectPlug();
			plug = new PlugManager(Log, NetworkSettings.ServerAddress, NetworkSettings.Port, NetworkSettings.RetryAttempts);
			this.PlugReconnectEstablished?.Invoke();
		}

		internal void DisconnectPlug()
		{
			plug?.ShutDown();
		}

		internal void Log(string message)
		{
			LogAsync(message, 5);
		}

		internal async void LogAsync(string message, int attempts)
		{
			message = $"[@{DateTime.UtcNow.Minute:D2}:{DateTime.UtcNow.Second:D2}] {message}";
			for (int logAttempts = 0; logAttempts < attempts; logAttempts++)
			{
				try
				{
					this.LogMessage?.Invoke(message);
					break;
				}
				catch (IOException)
				{
					await Task.Delay(50);
				}
			}
		}
	}
}
namespace ButtplugSong
{
	[BepInPlugin("danatron1-ButtplugSongMod-Silksong", "ButtplugSong", "1.2.2")]
	public class ButtplugSongPlugin : BaseUnityPlugin
	{
		public static string ModPath = "Not yet loaded";

		private const string ModId = "danatron1-ButtplugSongMod-Silksong";

		private const string ModName = "ButtplugSong";

		private const string ModVersion = "1.2.2";

		private readonly Harmony harmony = new Harmony("danatron1-ButtplugSongMod-Silksong");

		private VibeManager vibe;

		public const string Id = "danatron1-ButtplugSongMod-Silksong";

		public static string Name => "ButtplugSong";

		public static string Version => "1.2.2";

		private void Awake()
		{
			ModPath = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			vibe = new VibeManager(ModPath, (Action<string>?)((BaseUnityPlugin)this).Logger.LogInfo);
			harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " (danatron1-ButtplugSongMod-Silksong) has loaded!"));
		}

		private void OnDestroy()
		{
			vibe?.DisconnectPlug();
			harmony.UnpatchSelf();
		}
	}
	[HarmonyPatch]
	internal static class ModHooks
	{
		[HarmonyPatch]
		private static class SavedItemGetPatch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				List<MethodBase> list = new List<MethodBase>();
				MethodInfo method = typeof(SavedItem).GetMethod("Get", new Type[2]
				{
					typeof(int),
					typeof(bool)
				});
				if (method != null && !method.IsAbstract)
				{
					list.Add(method);
				}
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					Type[] array;
					try
					{
						array = assembly.GetTypes();
					}
					catch (ReflectionTypeLoadException ex)
					{
						array = ex.Types.Where((Type t) => t != null).ToArray();
					}
					catch
					{
						continue;
					}
					Type[] array2 = array;
					foreach (Type type in array2)
					{
						if (!typeof(SavedItem).IsAssignableFrom(type) || type == typeof(SavedItem))
						{
							continue;
						}
						MethodInfo[] methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);
						foreach (MethodInfo methodInfo in methods)
						{
							if (methodInfo.Name == "Get" && !methodInfo.IsAbstract)
							{
								list.Add(methodInfo);
							}
						}
					}
				}
				return list;
			}

			[HarmonyPrefix]
			private static void Prefix(SavedItem __instance)
			{
				ModHooks.OnItemPickupHook?.Invoke(__instance);
			}
		}

		public static event Func<PlayerData, int, int>? OnTakeDamageHook;

		public static event Action<HeroController>? OnBindInterruptedHook;

		public static event Func<PlayerData, int, int>? OnAddHealthHook;

		public static event Func<HealthManager, HitInstance, int>? OnDealDamageHook;

		public static event Action<HeroController, bool, bool>? OnBeforeDeathHook;

		public static event Action<GameManager>? OnAfterDeathHook;

		public static event Action<HeroController>? OnGetCocoonHook;

		public static event Action<string, bool>? OnSetBoolHook;

		public static event Action<string, int>? OnSetIntHook;

		public static event Action<string?>? OnRumbleHook;

		public static event Func<PlayerData, int, int>? OnAddRosariesHook;

		public static event Func<PlayerData, int, int>? OnTakeRosariesHook;

		public static event Func<PlayerData, int, int>? OnAddShardsHook;

		public static event Func<PlayerData, int, int>? OnTakeShardsHook;

		public static event Action<HeroController>? OnHardLandingHook;

		public static event Action<DeliveryQuestItem>? OnCourierBreakItemHook;

		public static event Action? OnFinishedLoadingModsHook;

		public static event Action? OnMaxHealthUpHook;

		public static event Action? OnMaxSilkUpHook;

		public static event Action<ToolItem>? OnToolUnlockHook;

		public static event Action<SavedItem>? OnItemPickupHook;

		[HarmonyPatch(typeof(PlayerData), "TakeHealth")]
		[HarmonyPrefix]
		private static void PlayerData_TakeHealth(PlayerData __instance, ref int amount, ref bool hasBlueHealth, ref bool allowFracturedMaskBreak)
		{
			if (ModHooks.OnTakeDamageHook != null)
			{
				amount = ModHooks.OnTakeDamageHook(__instance, amount);
			}
		}

		[HarmonyPatch(typeof(HeroController), "BindInterrupted")]
		[HarmonyPostfix]
		private static void OnBindInterrupted(HeroController __instance)
		{
			ModHooks.OnBindInterruptedHook?.Invoke(__instance);
		}

		[HarmonyPatch(typeof(PlayerData), "AddHealth")]
		[HarmonyPrefix]
		private static void PlayerData_AddHealth(PlayerData __instance, ref int amount)
		{
			if (ModHooks.OnAddHealthHook != null)
			{
				amount = ModHooks.OnAddHealthHook(__instance, amount);
			}
		}

		[HarmonyPatch(typeof(HealthManager), "TakeDamage")]
		[HarmonyPrefix]
		private static void OnDealDamage(HealthManager __instance, ref HitInstance hitInstance)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (ModHooks.OnDealDamageHook != null)
			{
				hitInstance.DamageDealt = ModHooks.OnDealDamageHook(__instance, hitInstance);
			}
		}

		[HarmonyPatch(typeof(HeroController), "Die")]
		[HarmonyPrefix]
		private static void OnBeforePlayerDead(HeroController __instance, bool nonLethal, bool frostDeath)
		{
			ModHooks.OnBeforeDeathHook?.Invoke(__instance, nonLethal, frostDeath);
		}

		[HarmonyPatch(typeof(GameManager), "PlayerDead")]
		[HarmonyPrefix]
		private static void OnAfterPlayerDead(GameManager __instance, float waitTime)
		{
			ModHooks.OnAfterDeathHook?.Invoke(__instance);
		}

		[HarmonyPatch(typeof(HeroController), "CocoonBroken", new Type[]
		{
			typeof(bool),
			typeof(bool)
		})]
		[HarmonyPrefix]
		private static void OnGetCocoon(HeroController __instance, bool doAirPause, bool forceCanBind)
		{
			ModHooks.OnGetCocoonHook?.Invoke(__instance);
		}

		[HarmonyPatch(typeof(PlayerData), "SetBool")]
		[HarmonyPostfix]
		private static void OnSetBool(string boolName, bool value)
		{
			ModHooks.OnSetBoolHook?.Invoke(boolName, value);
		}

		[HarmonyPatch(typeof(PlayerData), "SetInt")]
		[HarmonyPostfix]
		private static void OnSetInt(string intName, int value)
		{
			ModHooks.OnSetIntHook?.Invoke(intName, value);
		}

		[HarmonyPatch(typeof(VibrationManager), "PlayVibrationClipOneShot", new Type[]
		{
			typeof(VibrationData),
			typeof(VibrationTarget?),
			typeof(bool),
			typeof(string),
			typeof(bool)
		})]
		[HarmonyPrefix]
		private static void OnPlayVibrationClipOneShot(ref VibrationData vibrationData, ref VibrationTarget? vibrationTarget, ref bool isLooping, ref string tag, ref bool isRealtime)
		{
			ModHooks.OnRumbleHook?.Invoke(tag);
		}

		[HarmonyPatch(typeof(PlayerData), "AddGeo")]
		[HarmonyPrefix]
		private static void OnAddRosaries(PlayerData __instance, ref int amount)
		{
			if (ModHooks.OnAddRosariesHook != null)
			{
				amount = ModHooks.OnAddRosariesHook(__instance, amount);
			}
		}

		[HarmonyPatch(typeof(PlayerData), "TakeGeo")]
		[HarmonyPrefix]
		private static void OnTakeRosaries(PlayerData __instance, ref int amount)
		{
			if (ModHooks.OnTakeRosariesHook != null)
			{
				amount = ModHooks.OnTakeRosariesHook(__instance, amount);
			}
		}

		[HarmonyPatch(typeof(PlayerData), "AddShards")]
		[HarmonyPrefix]
		private static void OnAddShards(PlayerData __instance, ref int amount)
		{
			if (ModHooks.OnAddShardsHook != null)
			{
				amount = ModHooks.OnAddShardsHook(__instance, amount);
			}
		}

		[HarmonyPatch(typeof(PlayerData), "TakeShards")]
		[HarmonyPrefix]
		private static void OnTakeShards(PlayerData __instance, ref int amount)
		{
			if (ModHooks.OnTakeShardsHook != null)
			{
				amount = ModHooks.OnTakeShardsHook(__instance, amount);
			}
		}

		[HarmonyPatch(typeof(HeroController), "DoHardLandingEffectNoHit")]
		[HarmonyPrefix]
		private static void OnHardLanding(HeroController __instance)
		{
			ModHooks.OnHardLandingHook?.Invoke(__instance);
		}

		[HarmonyPatch(typeof(DeliveryQuestItem), "BreakEffect")]
		[HarmonyPrefix]
		private static void CourierBreakItem(DeliveryQuestItem __instance, Vector2 heroPos)
		{
			ModHooks.OnCourierBreakItemHook?.Invoke(__instance);
		}

		[HarmonyPatch(typeof(OnScreenDebugInfo), "Awake")]
		[HarmonyPrefix]
		private static void OnFinishedLoadingMods()
		{
			ModHooks.OnFinishedLoadingModsHook?.Invoke();
		}

		[HarmonyPatch(typeof(PlayerData), "AddToMaxHealth")]
		[HarmonyPostfix]
		private static void OnMaxHealthUp()
		{
			ModHooks.OnMaxHealthUpHook?.Invoke();
		}

		[HarmonyPatch(typeof(HeroController), "AddToMaxSilk")]
		[HarmonyPostfix]
		private static void OnMaxSilkUp()
		{
			ModHooks.OnMaxSilkUpHook?.Invoke();
		}

		[HarmonyPatch(typeof(ToolItem), "Unlock")]
		[HarmonyPostfix]
		private static void OnToolUnlock(ToolItem __instance)
		{
			ModHooks.OnToolUnlockHook?.Invoke(__instance);
		}
	}
}
namespace ButtplugSong.Helper
{
	public static class ExtHelper
	{
		public delegate void DropdownChanged<T>(string newValue, bool isEnum, T type) where T : Enum;

		public static Random rng = new Random();

		public static void RunTask(this Task t)
		{
			Task t2 = t;
			Task.Run(() => t2);
		}

		public static async void FireAndForget(this Task t, Action<string> logging)
		{
			try
			{
				await t;
			}
			catch (Exception ex)
			{
				logging?.Invoke($"FAF Exception: {ex.GetType()}; {ex.Message}");
				if (ex.InnerException != null)
				{
					logging?.Invoke($"    Inner: {ex.InnerException.GetType()}; {ex.InnerException.Message}");
				}
			}
		}

		public static T ChooseRandom<T>() where T : Enum
		{
			Array values = Enum.GetValues(typeof(T));
			return (T)values.GetValue(rng.Next(values.Length));
		}

		public static T ChooseRandom<T>(this IEnumerable<T> collection)
		{
			return collection.ElementAt(rng.Next(collection.Count()));
		}

		public static void SetClassListIf<T>(this T field, string classList, Func<T, bool> predicate) where T : VisualElement
		{
			if (predicate(field))
			{
				if (!((VisualElement)field).ClassListContains(classList))
				{
					((VisualElement)field).AddToClassList(classList);
				}
			}
			else if (((VisualElement)field).ClassListContains(classList))
			{
				((VisualElement)field).RemoveFromClassList(classList);
			}
		}

		public static bool OutsideRange<T>(this T value, T lowerBound, T upperBound, out T inRangeValue) where T : IComparable<T>
		{
			if (value.CompareTo(lowerBound) < 0)
			{
				inRangeValue = lowerBound;
				return true;
			}
			if (value.CompareTo(upperBound) > 0)
			{
				inRangeValue = upperBound;
				return true;
			}
			inRangeValue = value;
			return false;
		}

		public static BaseField<T> SetupValueClamping<T>(this BaseField<T> notifier, T lowerBound, T upperBound, bool delay = true) where T : IComparable<T>
		{
			T lowerBound2 = lowerBound;
			T upperBound2 = upperBound;
			BaseField<T> notifier2 = notifier;
			if (delay && notifier2 is TextInputBaseField<T> val)
			{
				val.isDelayed = true;
			}
			INotifyValueChangedExtensions.RegisterValueChangedCallback<T>((INotifyValueChanged<T>)(object)notifier2, (EventCallback<ChangeEvent<T>>)delegate(ChangeEvent<T> evt)
			{
				if (evt.newValue.OutsideRange(lowerBound2, upperBound2, out var inRangeValue))
				{
					notifier2.value = inRangeValue;
				}
			});
			return notifier2;
		}

		public static BaseField<T> SetupGreyout<T>(this BaseField<T> notifier, Func<T, bool> predicate) where T : IComparable<T>
		{
			BaseField<T> notifier2 = notifier;
			Func<T, bool> predicate2 = predicate;
			INotifyValueChangedExtensions.RegisterValueChangedCallback<T>((INotifyValueChanged<T>)(object)notifier2, (EventCallback<ChangeEvent<T>>)delegate
			{
				notifier2.SetClassListIf<BaseField<T>>("grey-value", (Func<BaseField<T>, bool>)((BaseField<T> n) => predicate2(n.value)));
			});
			return notifier2;
		}

		public static BaseField<string> SetupSaving(this BaseField<string> element, string? defaultValue = null, string? settingName = null)
		{
			string settingName2 = settingName;
			if (settingName2 == null)
			{
				settingName2 = ((VisualElement)element).name;
			}
			Preset.BindElementToSetting((VisualElement)(object)element, settingName2);
			INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)element, (EventCallback<ChangeEvent<string>>)delegate(ChangeEvent<string> evt)
			{
				Preset.Custom.SaveSettingChange(settingName2, evt.newValue.Replace(" ", ""));
			});
			if (defaultValue != null)
			{
				PresetDefault.SaveDefaultSetting(settingName2, defaultValue.Replace(" ", ""));
			}
			return element;
		}

		public static BaseField<T> SetupSaving<T>(this BaseField<T> element, T? defaultValue = null, string? settingName = null) where T : struct
		{
			string settingName2 = settingName;
			if (settingName2 == null)
			{
				settingName2 = ((VisualElement)element).name;
			}
			Preset.BindElementToSetting((VisualElement)(object)element, settingName2);
			INotifyValueChangedExtensions.RegisterValueChangedCallback<T>((INotifyValueChanged<T>)(object)element, (EventCallback<ChangeEvent<T>>)delegate(ChangeEvent<T> evt)
			{
				Preset.Custom.SaveSettingChange(settingName2, evt.newValue);
			});
			if (defaultValue.HasValue)
			{
				PresetDefault.SaveDefaultSetting(settingName2, defaultValue);
			}
			return element;
		}

		public static void Load<T>(this BaseField<T> element, Preset preset) where T : struct, IComparable<T>
		{
			if (Preset.TryGetBoundSetting((VisualElement)(object)element, out string settingName))
			{
				T val = preset.Get<T>(settingName) ?? element.value;
				ChangeEvent<T> pooled = ChangeEvent<T>.GetPooled(element.value, val);
				((EventBase)pooled).target = (IEventHandler)(object)element;
				element.SetValueWithoutNotify(val);
				((CallbackEventHandler)element).SendEvent((EventBase)(object)pooled);
				return;
			}
			throw new ArgumentException("Saving not setup! Couldn't load setting from preset " + preset.Identifier + " for element " + ((VisualElement)element).name + " (" + ((VisualElement)element).typeName + ")");
		}

		public static void Load(this BaseField<string> element, Preset preset, bool friendlyName = true)
		{
			if (Preset.TryGetBoundSetting((VisualElement)(object)element, out string settingName))
			{
				string text = preset.GetString(settingName) ?? element.value;
				if (friendlyName)
				{
					text = text.FriendlyName();
				}
				ChangeEvent<string> pooled = ChangeEvent<string>.GetPooled(element.value, text);
				((EventBase)pooled).target = (IEventHandler)(object)element;
				element.SetValueWithoutNotify(text);
				((CallbackEventHandler)element).SendEvent((EventBase)(object)pooled);
				return;
			}
			throw new ArgumentException("Saving not setup! Couldn't load setting from preset " + preset.Identifier + " for element " + ((VisualElement)element).name + " (" + ((VisualElement)element).typeName + ")");
		}

		public static BaseField<T> DependsOn<T>(this BaseField<T> element, Toggle other, Func<Toggle, bool> predicate)
		{
			BaseField<T> element2 = element;
			Func<Toggle, bool> predicate2 = predicate;
			Toggle other2 = other;
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)other2, (EventCallback<ChangeEvent<bool>>)delegate(ChangeEvent<bool> evt)
			{
				((VisualElement)element2).SetEnabled(evt.newValue && predicate2(other2));
			});
			return element2;
		}

		public static BaseField<TSelf> DependsOn<TSelf, TOther>(this BaseField<TSelf> element, BaseField<TOther> other, Func<BaseField<TOther>, bool> predicate)
		{
			BaseField<TSelf> element2 = element;
			Func<BaseField<TOther>, bool> predicate2 = predicate;
			BaseField<TOther> other2 = other;
			INotifyValueChangedExtensions.RegisterValueChangedCallback<TOther>((INotifyValueChanged<TOther>)(object)other2, (EventCallback<ChangeEvent<TOther>>)delegate
			{
				((VisualElement)element2).SetEnabled(predicate2(other2));
			});
			return element2;
		}

		public static BaseField<T> DependsOn<T>(this BaseField<T> element, params Toggle[] others)
		{
			BaseField<T> element2 = element;
			Toggle[] others2 = others;
			if (others2.Length == 0)
			{
				return element2;
			}
			if (others2.Length == 1)
			{
				INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)others2[0], (EventCallback<ChangeEvent<bool>>)delegate(ChangeEvent<bool> evt)
				{
					((VisualElement)element2).SetEnabled(evt.newValue);
				});
			}
			else
			{
				Toggle[] array = others2;
				for (int i = 0; i < array.Length; i++)
				{
					INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)array[i], (EventCallback<ChangeEvent<bool>>)delegate(ChangeEvent<bool> evt)
					{
						((VisualElement)element2).SetEnabled(evt.newValue && others2.All((Toggle x) => ((BaseField<bool>)(object)x).value));
					});
				}
			}
			return element2;
		}

		public static string FriendlyName(this string s)
		{
			string text = $"{char.ToUpper(s[0])}";
			bool flag = true;
			for (int i = 1; i < s.Length; i++)
			{
				if (char.IsUpper(s[i]))
				{
					if (!char.IsWhiteSpace(s[i - 1]) && (!flag || i + 1 >= s.Length || char.IsLower(s[i + 1])))
					{
						text += " ";
					}
					flag = true;
				}
				else
				{
					flag = false;
				}
				text += s[i];
			}
			return text;
		}

		public static string[] DisplayFriendlyEnumNames<T>() where T : Enum
		{
			return Enum.GetNames(typeof(T)).Select(FriendlyName).ToArray();
		}

		public static DropdownField PopulateDropdown<T>(this DropdownField dropdown, params string[] additionalSettings) where T : Enum
		{
			string[] array = DisplayFriendlyEnumNames<T>();
			int num = 0;
			string[] array2 = new string[array.Length + additionalSettings.Length];
			ReadOnlySpan<string> readOnlySpan = new ReadOnlySpan<string>(array);
			readOnlySpan.CopyTo(new Span<string>(array2).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			ReadOnlySpan<string> readOnlySpan2 = new ReadOnlySpan<string>(additionalSettings);
			readOnlySpan2.CopyTo(new Span<string>(array2).Slice(num, readOnlySpan2.Length));
			num += readOnlySpan2.Length;
			return dropdown.PopulateDropdown(array2);
		}

		public static DropdownField PopulateDropdown(this DropdownField dropdown, params string[] options)
		{
			((BasePopupField<string, string>)(object)dropdown).choices = options.ToList();
			return dropdown;
		}

		public static DropdownField RegisterDropdownChangedCallback<T>(this DropdownField dropdown, DropdownChanged<T> callWhenChanged) where T : struct, Enum
		{
			DropdownChanged<T> callWhenChanged2 = callWhenChanged;
			INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)dropdown, (EventCallback<ChangeEvent<string>>)delegate(ChangeEvent<string> evt)
			{
				if (Enum.TryParse<T>(evt.newValue.Replace(" ", ""), ignoreCase: true, out var result))
				{
					callWhenChanged2(evt.newValue, isEnum: true, result);
				}
				else
				{
					callWhenChanged2(evt.newValue, isEnum: false, default(T));
				}
			});
			return dropdown;
		}

		public static T Next<T>(this T current) where T : Enum
		{
			T[] array = (T[])Enum.GetValues(typeof(T));
			int num = Array.IndexOf(array, current) + 1;
			if (array.Length != num)
			{
				return array[num];
			}
			return array[0];
		}
	}
}
namespace ButtplugSong.GUI
{
	internal class GUIManager : MonoBehaviour
	{
		private static GUIManager? _instance;

		public GameObject GUI_GameObject;

		public UIDocument UIDoc;

		public VisualElement Root;

		internal VisualTreeAsset LogRow;

		internal VisualTreeAsset Device;

		public VibeManager Vibe;

		public VisualTreeAsset TreeAsset;

		public TemplateContainer TreeContainer;

		public StyleSheet Style;

		public PanelSettings Settings;

		private const float _displayUpdateFrequency = 0.0625f;

		private float _timeSinceLastUpdate = 0.1f;

		public WaveDisplay VibeDisplay;

		public VisualElement WaveDisplayHolder;

		public Label DebugInfo;

		public VisualElement SettingsPanel;

		public TabView MainTabView;

		public Label TimerReadout;

		public Label PowerReadout;

		public Label PowerReadoutActual;

		public Label DeathRoll;

		public List<Foldout> SettingsFoldouts;

		public List<VibeSource> Sources;

		public LimitsSettings Limits;

		public WaveSettings Wave;

		public TimerSettings Timer;

		public PresetSettings Presets;

		public StopTheVibes StopVibes;

		public NetworkSettings Network;

		public UISettings UISettings;

		public GroupBox VibeLog;

		private const int MAX_VIBELOG_ENTRIES = 100;

		private Queue<VisualElement> vibeLogEntries = new Queue<VisualElement>();

		private DateTime? _lastLogEntry;

		private float deathRollTimeRemaining;

		private bool _settingsCurrentlyLocked;

		public static GUIManager Instance
		{
			get
			{
				if ((Object)(object)_instance == (Object)null)
				{
					throw new NotImplementedException("Instantiate properly before referencing! >:(");
				}
				return _instance;
			}
			private set
			{
				_instance = value;
			}
		}

		public bool UIHidden { get; private set; }

		public static GUIManager CreateAndInitialize()
		{
			//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_001a: Expected O, but got Unknown
			GameObject val = new GameObject("ButtplugSong GUI Manager");
			Instance = val.AddComponent<GUIManager>();
			Object.DontDestroyOnLoad((Object)val);
			Instance.Vibe = VibeManager.Instance;
			Instance.Vibe.UI = Instance;
			Instance.LoadAssetBundle();
			Instance.CreateGUI();
			Instance.CreateUIHandles();
			Instance.AddHooks();
			return Instance;
		}

		public void LoadAssetBundle()
		{
			AssetBundle val = AssetBundle.LoadFromFile(Path.Combine(ButtplugSongPlugin.ModPath, "buttplugsong.gui"));
			TreeAsset = val.LoadAsset<VisualTreeAsset>("ButtplugSong-UXML");
			Style = val.LoadAsset<StyleSheet>("ButtplugSong-USS");
			Settings = val.LoadAsset<PanelSettings>("ButtplugSong-PanelSettings");
			LogRow = val.LoadAsset<VisualTreeAsset>("ButtplugSong-LogRow");
			Device = val.LoadAsset<VisualTreeAsset>("ButtplugSong-Device");
			val.Unload(false);
		}

		public void CreateGUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			GUI_GameObject = new GameObject("ButtplugSong GUI");
			UIDoc = GUI_GameObject.AddComponent<UIDocument>();
			UIDoc.visualTreeAsset = TreeAsset;
			UIDoc.panelSettings = Settings;
			Root = UIDoc.rootVisualElement;
			CreateWaveDisplay();
			GUI_GameObject.transform.SetParent(((Component)this).transform);
			Root.AddToClassList("hide");
			void CreateWaveDisplay()
			{
				//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_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_00c8: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					WaveDisplayHolder = UQueryExtensions.Q(Root, "WaveDisplayHolder", (string)null);
					VibeDisplay = new WaveDisplay
					{
						LineColor = new Color(1f, 0.72156864f, 82f / 85f, 0.8f),
						GlowColor = new Color(0.59607846f, 0.07450981f, 0.56078434f, 0.5f),
						LineWidth = 1f,
						GlowWidth = 1.2f,
						MinimumValue = 0f,
						MaximumValue = 1f,
						DefaultValue = 0f,
						LineBufferTop = 0.2f,
						LineBufferBottom = 0.8f,
						RecordSteps = 128
					};
					((VisualElement)VibeDisplay).SetSize(new Vector2(320f, 35f));
					((VisualElement)VibeDisplay).AddToClassList("wave-display");
					WaveDisplayHolder.Add((VisualElement)(object)VibeDisplay);
				}
				catch (Exception ex)
				{
					Vibe.Log($"Failed to create WaveDisplay: {ex.Message} - {ex.InnerException} - {ex.StackTrace}");
				}
			}
		}

		private void CreateUIHandles()
		{
			DebugInfo = UQueryExtensions.Q<Label>(Root, "DebugInfo", (string)null);
			SettingsPanel = UQueryExtensions.Q<VisualElement>(Root, "SettingsPanel", (string)null);
			MainTabView = UQueryExtensions.Q<TabView>(Root, "MainTabView", (string)null);
			TimerReadout = UQueryExtensions.Q<Label>(Root, "TimerReadout", (string)null);
			PowerReadout = UQueryExtensions.Q<Label>(Root, "PowerReadout", (string)null);
			PowerReadoutActual = UQueryExtensions.Q<Label>(Root, "PowerReadoutActual", (string)null);
			DeathRoll = UQueryExtensions.Q<Label>(Root, "DeathRoll", (string)null);
			SettingsFoldouts = new List<Foldout>(6)
			{
				UQueryExtensions.Q<Foldout>(Root, "VibeSources", (string)null),
				UQueryExtensions.Q<Foldout>(Root, "LimitsSettings", (string)null),
				UQueryExtensions.Q<Foldout>(Root, "WaveTypeSettings", (string)null),
				UQueryExtensions.Q<Foldout>(Root, "TimerSettings", (string)null),
				UQueryExtensions.Q<Foldout>(Root, "PresetsSettings", (string)null),
				UQueryExtensions.Q<Foldout>(Root, "StopVibesSettings", (string)null)
			};
			Sources = new List<VibeSource>(7)
			{
				new BuzzOnDamage(),
				new BuzzOnHeal(),
				new BuzzOnStrike(),
				new BuzzOnDeath(),
				new BuzzOnPickups(),
				new BuzzOnRumble(),
				new BuzzOnRandom()
			};
			Presets = new PresetSettings();
			Limits = new LimitsSettings();
			Wave = new WaveSettings();
			Timer = new TimerSettings();
			StopVibes = new StopTheVibes();
			Network = new NetworkSettings();
			UISettings = new UISettings();
			VibeLog = UQueryExtensions.Q<GroupBox>(Root, "VibeLog", (string)null);
			LogActivity("Vibe Log Initialized!\nRunning " + ButtplugSongPlugin.Name + " v" + ButtplugSongPlugin.Version + "\nDebug logs are found in \"LogOutput.log\" in your BepInEx folder. This log is just for vibe activity.");
			((VisualElement)DebugInfo).AddToClassList("hide");
		}

		public void FinishedLoading()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			SetToPreset(Preset.Custom);
			Root.RemoveFromClassList("hide");
			if ((Object)(object)ManagerSingleton<InputHandler>.Instance != (Object)null)
			{
				ManagerSingleton<InputHandler>.Instance.OnCursorVisibilityChange += new CursorVisibilityChange(UpdateSettingsPanelVisibility);
			}
		}

		public void SetToPreset(Preset preset)
		{
			Vibe.Log($"Setting to preset: {preset.Identifier} ({preset.Settings.Count})");
			foreach (VibeSource source in Sources)
			{
				source.SetToPreset(preset);
			}
			Limits.SetToPreset(preset);
			Wave.SetToPreset(preset);
			Timer.SetToPreset(preset);
			Presets.SetToPreset(preset);
			StopVibes.SetToPreset(preset);
			Network.SetToPreset(preset);
			UISettings.SetToPreset(preset);
		}

		public void AddHooks()
		{
			Vibe.Logic.PunctuateChanged += UpdatePunctuateGraphic;
			Vibe.Logic.AddActivityLog += LogActivity;
			Vibe.Logic.PowerChanged += UpdateLockSettings;
			Vibe.Logic.VibeSourceActivated += UpdateLockSettings;
		}

		public void UpdatePunctuateGraphic(bool punctuating)
		{
			VibeDisplay.SetClassListIf("punctuating", (WaveDisplay x) => Vibe.Logic.Punctuating);
		}

		public void LogActivity(object generalMessage)
		{
			LogActivity("Debug Message", generalMessage.ToString());
		}

		public void LogActivity(string sourceLine, string vibeLine)
		{
			LogActivity(sourceLine, vibeLine, -1f);
		}

		public void LogActivity(string sourceLine, string vibeLine, float timerSeconds)
		{
			if (string.IsNullOrWhiteSpace(sourceLine) || string.IsNullOrWhiteSpace(vibeLine))
			{
				return;
			}
			VisualElement val = (VisualElement)(object)LogRow.Instantiate();
			Label val2 = UQueryExtensions.Q<Label>(val, "TimeData", (string)null);
			Label val3 = UQueryExtensions.Q<Label>(val, "SourceData", (string)null);
			Label val4 = UQueryExtensions.Q<Label>(val, "VibeData", (string)null);
			DateTime now = DateTime.Now;
			float? num = (_lastLogEntry.HasValue ? new float?((float)(now - _lastLogEntry.Value).TotalSeconds) : null);
			string text = $"[{now.Hour:D2}:{now.Minute:D2}:{now.Second:D2}  :{now.Millisecond:D3}]     ";
			if (num.HasValue)
			{
				text = text + "Passed: " + VibeLogic.DisplayTime(num.Value) + " real";
				if (timerSeconds >= 0f)
				{
					text = text + ", " + VibeLogic.DisplayTime(timerSeconds) + " timer";
				}
			}
			else
			{
				text += "First log";
			}
			((TextElement)val3).text = sourceLine;
			((TextElement)val4).text = vibeLine;
			((TextElement)val2).text = text;
			vibeLogEntries.Enqueue(val);
			((VisualElement)VibeLog).Add(val);
			_lastLogEntry = now;
			while (vibeLogEntries.Count > 100)
			{
				((VisualElement)VibeLog).Remove(vibeLogEntries.Dequeue());
			}
		}

		public void Update()
		{
			float realTime = Time.unscaledDeltaTime;
			float timerCountdown = Timer.GetTimerCountdown(Time.unscaledDeltaTime);
			Vibe.Update(realTime, timerCountdown);
			UpdateWaveDisplay();
			UpdatePowerDisplay();
			UpdateTimeDisplay();
			UpdateDeathRollDisplay();
			UpdateToggleUI();
			void UpdateDeathRollDisplay()
			{
				if (!(deathRollTimeRemaining <= 0f))
				{
					deathRollTimeRemaining -= realTime;
					if (deathRollTimeRemaining <= 0f)
					{
						((VisualElement)DeathRoll).AddToClassList("hide");
						((VisualElement)DeathRoll).opacity = 0f;
						deathRollTimeRemaining = 0f;
					}
					else if (deathRollTimeRemaining <= 5f)
					{
						((VisualElement)DeathRoll).opacity = (deathRollTimeRemaining / 5f).Clamp(0f, 1f);
					}
				}
			}
			void UpdatePowerDisplay()
			{
				((TextElement)PowerReadout).text = $"{Vibe.Logic.TargetPower * 100f:f0}%";
				if (Vibe.Logic.TargetPower != Vibe.Logic.ActualPower)
				{
					((TextElement)PowerReadoutActual).text = $"{Vibe.Logic.ActualPower * 100f:f0}%";
					((VisualElement)PowerReadoutActual).opacity = 0.75f;
				}
				else if (((VisualElement)PowerReadoutActual).opacity > 0f)
				{
					((TextElement)PowerReadoutActual).text = $"{Vibe.Logic.ActualPower * 100f:f0}%";
					Label powerReadoutActual = PowerReadoutActual;
					((VisualElement)powerReadoutActual).opacity = ((VisualElement)powerReadoutActual).opacity - realTime / 3f;
				}
			}
			void UpdateTimeDisplay()
			{
				if (Vibe.Logic.Time >= 60f)
				{
					((TextElement)TimerReadout).text = $"{(int)(Vibe.Logic.Time / 60f)}:{Vibe.Logic.Time % 60f:00}";
				}
				else
				{
					((TextElement)TimerReadout).text = $"{Vibe.Logic.Time:f2}";
				}
			}
			void UpdateToggleUI()
			{
				if (Input.GetKeyDown((KeyCode)287))
				{
					UIHidden = !UIHidden;
					Root.SetClassListIf<VisualElement>("hide", (Func<VisualElement, bool>)((VisualElement x) => UIHidden));
				}
			}
			void UpdateWaveDisplay()
			{
				_timeSinceLastUpdate += realTime;
				while (_timeSinceLastUpdate >= 0.0625f)
				{
					_timeSinceLastUpdate -= 0.0625f;
					VibeDisplay?.PushRecordStep(Vibe.Logic.ActualPower);
				}
			}
		}

		private void UpdateSettingsPanelVisibility(bool isVisible)
		{
			SettingsPanel.SetClassListIf<VisualElement>("hide", (Func<VisualElement, bool>)((VisualElement x) => UISettings.AutoCollapseSettings && !isVisible));
		}

		internal void DisplayDeathDice(int rollAmount)
		{
			((TextElement)DeathRoll).text = $"Death roll result: {rollAmount}";
			((VisualElement)DeathRoll).opacity = 1f;
			((VisualElement)DeathRoll).RemoveFromClassList("hide");
			deathRollTimeRemaining = 20 + Math.Abs(11 - rollAmount);
		}

		internal void UpdateLockSettings()
		{
			LockSettings(!Vibe.Logic.TimerZero && StopVibes != null && StopVibes.LockSettings);
		}

		private void LockSettings(bool disabled = true)
		{
			if (_settingsCurrentlyLocked == disabled)
			{
				return;
			}
			_settingsCurrentlyLocked = disabled;
			foreach (Foldout settingsFoldout in SettingsFoldouts)
			{
				((VisualElement)settingsFoldout).enabledSelf = !disabled;
			}
		}
	}
	public abstract class GUISection
	{
		public string Identifier { get; private set; }

		protected static VibeManager Vibe => VibeManager.Instance;

		protected GUISection(string identifier)
		{
			Identifier = identifier;
			base..ctor();
		}

		protected static void Log(object message)
		{
			Log(message.ToString());
		}

		protected static void Log(string message)
		{
			Vibe.Log(message);
		}

		protected static T Get<T>(string elementName) where T : VisualElement
		{
			return Get<T>(elementName, Vibe.UI.Root);
		}

		protected static T Get<T>(string elementName, VisualElement root) where T : VisualElement
		{
			T val = UQueryExtensions.Q<T>(root, elementName, (string)null);
			if (val == null)
			{
				Log("Searched for " + elementName + " but couldn't find it");
				throw new NullReferenceException("Could not find " + elementName + " under root " + root.name);
			}
			return val;
		}
	}
	internal class UISettings : GUISection, IPresetLoadable
	{
		private static readonly string[] UIScaleOptions = new string[8] { "0.6x", "0.8x", "1x", "1.2x", "1.4x", "1.6x", "1.8x", "2x" };

		private static readonly Dictionary<string, string> UIHeightOptions = new Dictionary<string, string>
		{
			{ "Short", "tab-view-short" },
			{ "Medium", "tab-view-medium" },
			{ "Long", "tab-view-long" }
		};

		protected readonly DropdownField _uiScale;

		protected readonly DropdownField _uiHeight;

		protected readonly Toggle _displayWaveform;

		protected readonly Toggle _autoCollapseSettings;

		public bool AutoCollapseSettings
		{
			get
			{
				if (_autoCollapseSettings != null)
				{
					return ((BaseField<bool>)(object)_autoCollapseSettings).value;
				}
				return false;
			}
			set
			{
				((BaseField<bool>)(object)_autoCollapseSettings).value = value;
			}
		}

		public UISettings()
			: base("UI")
		{
			_uiScale = GUISection.Get<DropdownField>("UIScale");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)((BaseField<string>)(object)_uiScale.PopulateDropdown(UIScaleOptions)).SetupSaving(), (EventCallback<ChangeEvent<string>>)UIScaleChanged);
			_uiHeight = GUISection.Get<DropdownField>("UIHeight");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)((BaseField<string>)(object)_uiHeight.PopulateDropdown(UIHeightOptions.Select<KeyValuePair<string, string>, string>((KeyValuePair<string, string> x) => x.Key).ToArray())).SetupSaving(), (EventCallback<ChangeEvent<string>>)UIHeightChanged);
			_displayWaveform = GUISection.Get<Toggle>("DisplayWaveform");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)_displayWaveform).SetupSaving<bool>(), (EventCallback<ChangeEvent<bool>>)DisplayWaveformChanged);
			_autoCollapseSettings = GUISection.Get<Toggle>("AutoCollapseSettings");
			((BaseField<bool>)(object)_autoCollapseSettings).SetupSaving<bool>();
			((PopupField<string>)(object)_uiScale).SetIndexWithoutNotify(2);
			((PopupField<string>)(object)_uiHeight).SetIndexWithoutNotify(1);
		}

		public void SetToPreset(Preset preset)
		{
			((BaseField<string>)(object)_uiScale).Load(preset);
			((BaseField<string>)(object)_uiHeight).Load(preset);
			((BaseField<bool>)(object)_displayWaveform).Load<bool>(preset);
			((BaseField<bool>)(object)_autoCollapseSettings).Load<bool>(preset);
		}

		private void DisplayWaveformChanged(ChangeEvent<bool> evt)
		{
			ChangeEvent<bool> evt2 = evt;
			GUISection.Vibe.UI.VibeDisplay.SetClassListIf("hide", (WaveDisplay x) => !evt2.newValue);
		}

		private void UIHeightChanged(ChangeEvent<string> evt)
		{
			string value;
			string text = (UIHeightOptions.TryGetValue(evt.newValue, out value) ? value : "tab-view-medium");
			foreach (KeyValuePair<string, string> uIHeightOption in UIHeightOptions)
			{
				((VisualElement)GUISection.Vibe.UI.MainTabView).RemoveFromClassList(uIHeightOption.Value);
			}
			((VisualElement)GUISection.Vibe.UI.MainTabView).AddToClassList(text);
		}

		private void UIScaleChanged(ChangeEvent<string> evt)
		{
			PanelSettings panelSettings = GUISection.Vibe.UI.UIDoc.panelSettings;
			string newValue = evt.newValue;
			if (newValue == null)
			{
				goto IL_013c;
			}
			int length = newValue.Length;
			float scale;
			if (length != 2)
			{
				if (length != 4)
				{
					goto IL_013c;
				}
				switch (newValue[2])
				{
				case '6':
					break;
				case '8':
					goto IL_00a4;
				case '2':
					goto IL_00c0;
				case '4':
					goto IL_00cf;
				default:
					goto IL_013c;
				}
				if (!(newValue == "0.6x"))
				{
					if (!(newValue == "1.6x"))
					{
						goto IL_013c;
					}
					scale = 1.6f;
				}
				else
				{
					scale = 0.6f;
				}
			}
			else
			{
				char c = newValue[0];
				if (c != '1')
				{
					if (c != '2' || !(newValue == "2x"))
					{
						goto IL_013c;
					}
					scale = 2f;
				}
				else
				{
					if (!(newValue == "1x"))
					{
						goto IL_013c;
					}
					scale = 1f;
				}
			}
			goto IL_0142;
			IL_0142:
			panelSettings.scale = scale;
			return;
			IL_013c:
			scale = 1f;
			goto IL_0142;
			IL_00cf:
			if (!(newValue == "1.4x"))
			{
				goto IL_013c;
			}
			scale = 1.4f;
			goto IL_0142;
			IL_00a4:
			if (!(newValue == "0.8x"))
			{
				if (!(newValue == "1.8x"))
				{
					goto IL_013c;
				}
				scale = 1.8f;
			}
			else
			{
				scale = 0.8f;
			}
			goto IL_0142;
			IL_00c0:
			if (!(newValue == "1.2x"))
			{
				goto IL_013c;
			}
			scale = 1.2f;
			goto IL_0142;
		}
	}
}
namespace ButtplugSong.GUI.VibeSettings
{
	internal class StopTheVibes : GUISection, IPresetLoadable
	{
		protected readonly Button _stopTheVibes;

		protected readonly Label _stopTheVibesCostLabel;

		protected readonly Toggle _enabled;

		protected readonly Toggle _buttonCostsResources;

		protected readonly Toggle _buttonCostsRosaries;

		protected readonly Toggle _buttonCostsShards;

		protected readonly FloatField _rosaryCostPercent;

		protected readonly FloatField _shardCostPercent;

		protected readonly IntegerField _rosaryCostFlat;

		protected readonly IntegerField _shardCostFlat;

		protected readonly Toggle _buttonDisablesMinimums;

		protected readonly Toggle _lockSettings;

		public int RosaryCost;

		public int ShardCost;

		public bool LockSettings
		{
			get
			{
				return ((BaseField<bool>)(object)_lockSettings).value;
			}
			set
			{
				((BaseField<bool>)(object)_lockSettings).value = value;
			}
		}

		public StopTheVibes()
			: base("StopVibes")
		{
			_stopTheVibes = GUISection.Get<Button>("StopVibes");
			_stopTheVibes.clicked += StopTheVibesButtonClicked;
			_stopTheVibesCostLabel = GUISection.Get<Label>("StopVibesCostLabel");
			_enabled = GUISection.Get<Toggle>("StopVibesEnabled");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)_enabled).SetupSaving<bool>(true), (EventCallback<ChangeEvent<bool>>)RecalculateCosts<bool>);
			_buttonCostsResources = GUISection.Get<Toggle>("StopCostsResources");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)_buttonCostsResources).SetupSaving<bool>(true).DependsOn<bool>((Toggle[])(object)new Toggle[1] { _enabled }), (EventCallback<ChangeEvent<bool>>)RecalculateCosts<bool>);
			_buttonCostsRosaries = GUISection.Get<Toggle>("StopRosaryCost");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)_buttonCostsRosaries).SetupSaving<bool>(false).DependsOn<bool>((Toggle[])(object)new Toggle[2] { _enabled, _buttonCostsResources }), (EventCallback<ChangeEvent<bool>>)RecalculateCosts<bool>);
			_rosaryCostPercent = GUISection.Get<FloatField>("StopRosaryCostPercent");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<float>((INotifyValueChanged<float>)(object)((BaseField<float>)(object)_rosaryCostPercent).SetupSaving<float>(50f).DependsOn<float>((Toggle[])(object)new Toggle[3] { _enabled, _buttonCostsResources, _buttonCostsRosaries }).SetupValueClamping(0f, 100f)
				.SetupGreyout((float x) => x == 0f), (EventCallback<ChangeEvent<float>>)RecalculateCosts<float>);
			_rosaryCostFlat = GUISection.Get<IntegerField>("StopRosaryCostFlat");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<int>((INotifyValueChanged<int>)(object)((BaseField<int>)(object)_rosaryCostFlat).SetupSaving<int>(0).DependsOn<int>((Toggle[])(object)new Toggle[3] { _enabled, _buttonCostsResources, _buttonCostsRosaries }).SetupValueClamping(0, 9999)
				.SetupGreyout((int x) => x == 0), (EventCallback<ChangeEvent<int>>)RecalculateCosts<int>);
			_buttonCostsShards = GUISection.Get<Toggle>("StopShardCost");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)_buttonCostsShards).SetupSaving<bool>(true).DependsOn<bool>((Toggle[])(object)new Toggle[2] { _enabled, _buttonCostsResources }), (EventCallback<ChangeEvent<bool>>)RecalculateCosts<bool>);
			_shardCostPercent = GUISection.Get<FloatField>("StopShardCostPercent");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<float>((INotifyValueChanged<float>)(object)((BaseField<float>)(object)_shardCostPercent).SetupSaving<float>(0f).DependsOn<float>((Toggle[])(object)new Toggle[3] { _enabled, _buttonCostsResources, _buttonCostsShards }).SetupValueClamping(0f, 100f)
				.SetupGreyout((float x) => x == 0f), (EventCallback<ChangeEvent<float>>)RecalculateCosts<float>);
			_shardCostFlat = GUISection.Get<IntegerField>("StopShardCostFlat");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<int>((INotifyValueChanged<int>)(object)((BaseField<int>)(object)_shardCostFlat).SetupSaving<int>(400).DependsOn<int>((Toggle[])(object)new Toggle[3] { _enabled, _buttonCostsResources, _buttonCostsShards }).SetupValueClamping(0, 800)
				.SetupGreyout((int x) => x == 0), (EventCallback<ChangeEvent<int>>)RecalculateCosts<int>);
			_buttonDisablesMinimums = GUISection.Get<Toggle>("ButtonDisablesMinimums");
			((BaseField<bool>)(object)_buttonDisablesMinimums).SetupSaving<bool>(false).DependsOn<bool>((Toggle[])(object)new Toggle[1] { _enabled });
			_lockSettings = GUISection.Get<Toggle>("LockSettings");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)_lockSettings).SetupSaving<bool>(false), (EventCallback<ChangeEvent<bool>>)LockSettingsChanged);
			ModHooks.OnAddRosariesHook += CurrencyChanged;
			ModHooks.OnTakeRosariesHook += CurrencyChanged;
			ModHooks.OnAddShardsHook += CurrencyChanged;
			ModHooks.OnTakeShardsHook += CurrencyChanged;
		}

		public void SetToPreset(Preset preset)
		{
			((BaseField<bool>)(object)_enabled).Load<bool>(preset);
			((BaseField<bool>)(object)_buttonCostsResources).Load<bool>(preset);
			((BaseField<bool>)(object)_buttonCostsRosaries).Load<bool>(preset);
			((BaseField<float>)(object)_rosaryCostPercent).Load<float>(preset);
			((BaseField<int>)(object)_rosaryCostFlat).Load<int>(preset);
			((BaseField<bool>)(object)_buttonCostsShards).Load<bool>(preset);
			((BaseField<float>)(object)_shardCostPercent).Load<float>(preset);
			((BaseField<int>)(object)_shardCostFlat).Load<int>(preset);
			((BaseField<bool>)(object)_buttonDisablesMinimums).Load<bool>(preset);
			((BaseField<bool>)(object)_lockSettings).Load<bool>(preset);
		}

		private void LockSettingsChanged(ChangeEvent<bool> evt)
		{
			GUISection.Vibe.UI.UpdateLockSettings();
		}

		private int CurrencyChanged(PlayerData data, int amount)
		{
			RecalculateCosts();
			return amount;
		}

		private void RecalculateCosts<T>(ChangeEvent<T> evt)
		{
			RecalculateCosts();
		}

		private void RecalculateCosts()
		{
			if (!((BaseField<bool>)(object)_enabled).value || !((BaseField<bool>)(object)_buttonCostsResources).value)
			{
				((VisualElement)_stopTheVibes).enabledSelf = ((BaseField<bool>)(object)_enabled).value;
				((TextElement)_stopTheVibesCostLabel).text = (((BaseField<bool>)(object)_enabled).value ? "Free!" : "Button disabled");
				return;
			}
			RosaryCost = CalculateCost((CurrencyType)0);
			ShardCost = CalculateCost((CurrencyType)1);
			if (RosaryCost == 0 && ShardCost == 0)
			{
				((TextElement)_stopTheVibesCostLabel).text = "Free!";
			}
			else if (RosaryCost == 0)
			{
				((TextElement)_stopTheVibesCostLabel).text = string.Format("Costs {0} shard{1}", ShardCost, (ShardCost == 1) ? "" : "s");
			}
			else if (ShardCost == 0)
			{
				((TextElement)_stopTheVibesCostLabel).text = string.Format("Costs {0} rosar{1}", RosaryCost, (RosaryCost == 1) ? "y" : "ies");
			}
			else
			{
				((TextElement)_stopTheVibesCostLabel).text = string.Format("Costs {0} rosar{1}, {2} shard{3}", RosaryCost, (RosaryCost == 1) ? "y" : "ies", ShardCost, (ShardCost == 1) ? "" : "s");
			}
			((VisualElement)_stopTheVibes).enabledSelf = CurrencyManager.GetCurrencyAmount((CurrencyType)0) >= RosaryCost && CurrencyManager.GetCurrencyAmount((CurrencyType)1) >= ShardCost;
			int CalculateCost(CurrencyType type)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Invalid comparison between Unknown and I4
				if (!((BaseField<bool>)(object)_enabled).value || !((BaseField<bool>)(object)_buttonCostsResources).value)
				{
					return 0;
				}
				int currencyAmount = CurrencyManager.GetCurrencyAmount(type);
				if ((int)type == 0 && ((BaseField<bool>)(object)_buttonCostsRosaries).value)
				{
					currencyAmount = (int)((float)currencyAmount * ((BaseField<float>)(object)_rosaryCostPercent).value / 100f);
					return currencyAmount + ((BaseField<int>)(object)_rosaryCostFlat).value;
				}
				if ((int)type == 1 && ((BaseField<bool>)(object)_buttonCostsShards).value)
				{
					currencyAmount = (int)((float)currencyAmount * ((BaseField<float>)(object)_shardCostPercent).value / 100f);
					return currencyAmount + ((BaseField<int>)(object)_shardCostFlat).value;
				}
				return 0;
			}
		}

		private void StopTheVibesButtonClicked()
		{
			if (((BaseField<bool>)(object)_buttonCostsResources).value)
			{
				if (((BaseField<bool>)(object)_buttonCostsRosaries).value)
				{
					if (RosaryCost > CurrencyManager.GetCurrencyAmount((CurrencyType)0))
					{
						return;
					}
					CurrencyManager.TakeCurrency(RosaryCost, (CurrencyType)0, true);
				}
				if (((BaseField<bool>)(object)_buttonCostsShards).value)
				{
					if (ShardCost > CurrencyManager.GetCurrencyAmount((CurrencyType)1))
					{
						return;
					}
					CurrencyManager.TakeCurrency(ShardCost, (CurrencyType)1, true);
				}
			}
			if (((BaseField<bool>)(object)_buttonDisablesMinimums).value)
			{
				((BaseField<bool>)(object)GUISection.Vibe.UI.Limits._minimumsEnabled).value = false;
			}
			GUISection.Vibe.Logic.VibeSourceActivation("Stop the Vibes!", 1f, "-", 0f, "+", 0f);
		}
	}
	internal enum CountdownMode
	{
		Always,
		Default,
		InGame,
		Unpaused,
		SuperHot,
		Never
	}
	internal class TimerSettings : GUISection, IPresetLoadable
	{
		private readonly DropdownField _timerCountdownMode;

		private readonly Label _countdownModeDescription;

		private readonly Toggle _timeStacking;

		private readonly FloatField _timeStackingMultiplier;

		private readonly Toggle _vibeWhileTimerPaused;

		private readonly FloatField _afterZeroPunctuate;

		private readonly Label _afterZeroPunctuateLabel;

		private readonly FloatField _afterZeroPower;

		private readonly Label _percentagesReminder;

		private readonly Label _zeroPowerWarning;

		private readonly FloatField _afterZeroTimer;

		private readonly CyclingButton<AfterZeroMode> _afterZeroPowerMode;

		public int TimerCountdownModeIndex
		{
			get
			{
				return ((PopupField<string>)(object)_timerCountdownMode).index;
			}
			set
			{
				((PopupField<string>)(object)_timerCountdownMode).index = value;
			}
		}

		public CountdownMode TimerCountdownMode => (CountdownMode)TimerCountdownModeIndex;

		public TimerSettings()
			: base("Timer")
		{
			_timerCountdownMode = GUISection.Get<DropdownField>("TimerCountdownMode");
			((BaseField<string>)(object)_timerCountdownMode.PopulateDropdown<CountdownMode>(Array.Empty<string>()).RegisterDropdownChangedCallback<CountdownMode>(CountdownModeChanged)).SetupSaving(CountdownMode.Default.ToString());
			_countdownModeDescription = GUISection.Get<Label>("CountdownModeDescription");
			_timeStacking = GUISection.Get<Toggle>("TimeStacking");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)_timeStacking).SetupSaving<bool>(true), (EventCallback<ChangeEvent<bool>>)TimeStackingChanged<bool>);
			_timeStackingMultiplier = GUISection.Get<FloatField>("TimeStackingMultiplier");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<float>((INotifyValueChanged<float>)(object)((BaseField<float>)(object)_timeStackingMultiplier).SetupSaving<float>(1.2f).SetupGreyout((float x) => x == 1f).SetupValueClamping(0f, 999f)
				.DependsOn<float>((Toggle[])(object)new Toggle[1] { _timeStacking }), (EventCallback<ChangeEvent<float>>)TimeStackingChanged<float>);
			_vibeWhileTimerPaused = GUISection.Get<Toggle>("VibeWhileTimerPaused");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)_vibeWhileTimerPaused).SetupSaving<bool>(true), (EventCallback<ChangeEvent<bool>>)VibeWhilePausedChanged);
			_afterZeroPunctuate = GUISection.Get<FloatField>("AfterZeroPunctuate");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<float>((INotifyValueChanged<float>)(object)((BaseField<float>)(object)_afterZeroPunctuate).SetupSaving<float>(0f).SetupValueClamping(0f, 999f).SetupGreyout((float x) => x == 0f), (EventCallback<ChangeEvent<float>>)UpdateAfterZeroPunctuate);
			_afterZeroPunctuateLabel = GUISection.Get<Label>("AfterZeroPunctuateLabel");
			_afterZeroTimer = GUISection.Get<FloatField>("AfterZeroTimer");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<float>((INotifyValueChanged<float>)(object)((BaseField<float>)(object)_afterZeroTimer).SetupSaving<float>(0f).SetupValueClamping(0f, 999f).SetupGreyout((float x) => x == 0f), (EventCallback<ChangeEvent<float>>)AfterZeroTimerChanged);
			_percentagesReminder = GUISection.Get<Label>("PercentagesReminder");
			_zeroPowerWarning = GUISection.Get<Label>("ZeroPowerWarning");
			_afterZeroPower = GUISection.Get<FloatField>("AfterZeroPower");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<float>((INotifyValueChanged<float>)(object)((BaseField<float>)(object)_afterZeroPower).SetupSaving<float>(100f).SetupValueClamping(0f, 100f).SetupGreyout<float>(AfterZeroPowerMeaningless), (EventCallback<ChangeEvent<float>>)AfterZeroPowerChanged);
			_afterZeroPowerMode = new CyclingButton<AfterZeroMode>("AfterZeroPowerMode", AfterZeroMode.Subtract, AfterZeroModeTextSelector);
			_afterZeroPowerMode.SetupSaving(AfterZeroMode.Subtract);
			CyclingButton<AfterZeroMode> afterZeroPowerMode = _afterZeroPowerMode;
			afterZeroPowerMode.clicked = (Action)Delegate.Combine(afterZeroPowerMode.clicked, new Action(AfterZeroPowerModeChanged));
		}

		public void SetToPreset(Preset preset)
		{
			((BaseField<string>)(object)_timerCountdownMode).Load(preset);
			((BaseField<bool>)(object)_timeStacking).Load<bool>(preset);
			((BaseField<float>)(object)_timeStackingMultiplier).Load<float>(preset);
			((BaseField<bool>)(object)_vibeWhileTimerPaused).Load<bool>(preset);
			((BaseField<float>)(object)_afterZeroPunctuate).Load<float>(preset);
			((BaseField<float>)(object)_afterZeroTimer).Load<float>(preset);
			((BaseField<float>)(object)_afterZeroPower).Load<float>(preset);
			_afterZeroPowerMode.Load(preset);
		}

		private void AfterZeroTimerChanged(ChangeEvent<float> evt)
		{
			GUISection.Vibe.Logic.afterZeroTimer = evt.newValue;
		}

		private void AfterZeroPowerModeChanged()
		{
			GUISection.Vibe.Logic.afterZeroMode = _afterZeroPowerMode.currentMode;
			UpdateAfterZeroPowerReminderLabels();
		}

		private void AfterZeroPowerChanged(ChangeEvent<float> evt)
		{
			GUISection.Vibe.Logic.afterZeroPowerChange = evt.newValue / 100f;
			UpdateAfterZeroPowerReminderLabels();
		}

		private void UpdateAfterZeroPowerReminderLabels()
		{
			_percentagesReminder.SetClassListIf<Label>("hide", (Func<Label, bool>)((Label x) => _afterZeroPowerMode.currentMode != AfterZeroMode.Multiply || ((BaseField<float>)(object)_afterZeroPower).value > 1f));
			_zeroPowerWarning.SetClassListIf<Label>("hide", (Func<Label, bool>)((Label x) => !AfterZeroPowerMeaningless(((BaseField<float>)(object)_afterZeroPower).value)));
		}

		private bool AfterZeroPowerMeaningless(float value)
		{
			return _afterZeroPowerMode.currentMode switch
			{
				AfterZeroMode.Subtract => value <= 0f, 
				AfterZeroMode.Multiply => value >= 100f, 
				_ => false, 
			};
		}

		private void VibeWhilePausedChanged(ChangeEvent<bool> evt)
		{
			GUISection.Vibe.Logic.vibeWhileTimerPaused = evt.newValue;
		}

		private void UpdateAfterZeroPunctuate(ChangeEvent<float> evt)
		{
			if (!(evt.newValue < 0f))
			{
				((TextElement)_afterZeroPunctuateLabel).text = $"Punctuate with {evt.newValue}s of max power, then";
				GUISection.Vibe.Logic.afterZeroPunctuate = evt.newValue;
			}
		}

		private void CountdownModeChanged(string newValue, bool isEnum, CountdownMode type)
		{
			if (isEnum)
			{
				((TextElement)_countdownModeDescription).text = CountdownModeExplanation(type);
			}
		}

		private void TimeStackingChanged<T>(ChangeEvent<T> evt)
		{
			GUISection.Vibe.Logic.ComboMultiplier = (((BaseField<bool>)(object)_timeStacking).value ? ((BaseField<float>)(object)_timeStackingMultiplier).value : 1f);
		}

		private static string AfterZeroModeTextSelector(AfterZeroMode mode)
		{
			return mode switch
			{
				AfterZeroMode.Subtract => "-", 
				AfterZeroMode.Multiply => "x", 
				_ => "?", 
			};
		}

		internal float GetTimerCountdown(float unscaledDeltaTime)
		{
			if (!ShouldTimerCountDown(TimerCountdownMode))
			{
				return 0f;
			}
			if (TimerCountdownMode == CountdownMode.SuperHot && (Object)(object)HeroController.instance != (Object)null)
			{
				float magnitude = ((Vector2)(ref HeroController.instance.current_velocity)).magnitude;
				float num = ((magnitude <= float.Epsilon) ? 0.03f : ((!(magnitude > 10f)) ? (((Vector2)(ref HeroController.instance.current_velocity)).magnitude / 10f) : (0.9f + ((Vector2)(ref HeroController.instance.current_velocity)).magnitude / 100f)));
				return unscaledDeltaTime * num;
			}
			return unscaledDeltaTime;
		}

		private static bool ShouldTimerCountDown(CountdownMode mode)
		{
			switch (mode)
			{
			case CountdownMode.Always:
				return true;
			case CountdownMode.Default:
				return Time.timeScale > float.Epsilon;
			case CountdownMode.InGame:
				return (Object)(object)HeroController.instance != (Object)null && HeroController.instance.isGameplayScene;
			case CountdownMode.Unpaused:
			case CountdownMode.SuperHot:
				return (Object)(object)HeroController.instance != (Object)null && HeroController.instance.isGameplayScene && !HeroController.instance.IsPaused();
			case CountdownMode.Never:
				return false;
			default:
				return true;
			}
		}

		private static string CountdownModeExplanation(CountdownMode mode)
		{
			return mode switch
			{
				CountdownMode.Always => "\"Always\": Always counts down (unless the game freezes, i.e. when loading).", 
				CountdownMode.Default => "\"Default\": Counts down when time is simulated (includes main menu, excludes pausing).", 
				CountdownMode.InGame => "\"In Game\": excludes non-gameplay scenes like the main menu, but includes pausing.", 
				CountdownMode.Unpaused => "\"Unpaused\": stops the timer unless the game is playing (i.e. unpaused).", 
				CountdownMode.SuperHot => "\"Super Hot\": the timer only moves when you move.", 
				CountdownMode.Never => "\"Never\": for if you want to control power/time reduction via subtractive vibe sources.", 
				_ => $"DESCRIPTION FOR COUNTDOWN MODE {mode} NOT IMPLEMENTED", 
			};
		}
	}
	internal class WaveSettings : GUISection, IPresetLoadable
	{
		private static float[] WavePeriods = new float[14]
		{
			0.25f, 0.5f, 0.75f, 1f, 1.5f, 2f, 3f, 4f, 6f, 8f,
			12f, 16f, 24f, 32f
		};

		private const string RandomWaveString = "Random Wave";

		private readonly DropdownField _waveTypeSelector;

		private readonly SliderInt _wavePeriod;

		private readonly Label _wavePeriodLabel;

		private readonly Button _testWave;

		public string WaveTypeSelector => ((BaseField<string>)(object)_waveTypeSelector).value;

		public WaveSettings()
			: base("WaveType")
		{
			_waveTypeSelector = GUISection.Get<DropdownField>("WaveTypeSelector");
			_wavePeriod = GUISection.Get<SliderInt>("WavePeriod");
			_wavePeriodLabel = GUISection.Get<Label>("WavePeriodLabel");
			_testWave = GUISection.Get<Button>("TestWave");
			((BaseField<string>)(object)_waveTypeSelector.PopulateDropdown<WaveType>(new string[1] { "Random Wave" }).RegisterDropdownChangedCallback<WaveType>(WaveTypeChanged)).SetupSaving(WaveType.ConstantLinear.ToString(), "WaveType");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<int>((INotifyValueChanged<int>)(object)((BaseField<int>)(object)_wavePeriod).SetupSaving<int>(3, "WavePeriodOptionNumber").DependsOn<int, string>((BaseField<string>)(object)_waveTypeSelector, (BaseField<string> x) => !x.value.StartsWith("Constant")), (EventCallback<ChangeEvent<int>>)WavePeriodChanged);
			_testWave.clicked += TestWaveClicked;
			GUISection.Vibe.Logic.VibeSourceActivated += ReRandomizeWave;
		}

		public void SetToPreset(Preset preset)
		{
			((BaseField<string>)(object)_waveTypeSelector).Load(preset);
			((BaseField<int>)(object)_wavePeriod).Load<int>(preset);
			WavePeriodChanged();
		}

		private void WavePeriodChanged(ChangeEvent<int> evt)
		{
			WavePeriodChanged();
		}

		private void WavePeriodChanged()
		{
			GUISection.Vibe.Logic.wavePeriod = WavePeriods[((BaseField<int>)(object)_wavePeriod).value];
			((TextElement)_wavePeriodLabel).text = WavePeriods[((BaseField<int>)(object)_wavePeriod).value].ToString();
		}

		private void TestWaveClicked()
		{
			GUISection.Vibe.Logic.VibeSourceActivation("Test Button", 0.25f, "+", 2f, "+", 0f);
		}

		private void WaveTypeChanged(string newValue, bool isEnum, WaveType type)
		{
			if (isEnum)
			{
				GUISection.Vibe.Logic.waveType = type;
			}
		}

		internal void ReRandomizeWave()
		{
			if (WaveTypeSelector == "Random Wave")
			{
				GUISection.Vibe.Logic.waveType = ExtHelper.ChooseRandom<WaveType>();
			}
		}
	}
}
namespace ButtplugSong.GUI.VibeSettings.VibeSources
{
	internal class BuzzOnDamage : VibeSourceWithPunctuate
	{
		private readonly Toggle _scaleWithDamage;

		private readonly Toggle _vulnerableVibing;

		private readonly FloatField _vulnerableVibingThreshold;

		public bool ScaleWithDamage
		{
			get
			{
				return ((BaseField<bool>)(object)_scaleWithDamage).value;
			}
			set
			{
				((BaseField<bool>)(object)_scaleWithDamage).value = value;
			}
		}

		public bool VulnerableVibingEnabled
		{
			get
			{
				return ((BaseField<bool>)(object)_vulnerableVibing).value;
			}
			set
			{
				((BaseField<bool>)(object)_vulnerableVibing).value = value;
			}
		}

		public float VulnerableVibingThreshold
		{
			get
			{
				return ((BaseField<float>)(object)_vulnerableVibingThreshold).value / 100f;
			}
			set
			{
				((BaseField<float>)(object)_vulnerableVibingThreshold).value = value * 100f;
			}
		}

		public bool VulnerableVibingActive
		{
			get
			{
				if (VulnerableVibingEnabled)
				{
					return GUISection.Vibe.Logic.TargetPower >= VulnerableVibingThreshold;
				}
				return false;
			}
		}

		protected override string _punctuateReminderDescription => "taking damage";

		public BuzzOnDamage()
			: base("Damage", onByDefault: true, 20f, 5f, defaultPunctuate: true)
		{
			ModHooks.OnTakeDamageHook += PlayerHit;
			_scaleWithDamage = GUISection.Get<Toggle>("ScaleWithDamage");
			((BaseField<bool>)(object)_scaleWithDamage).SetupSaving<bool>(true).DependsOn<bool>((Toggle[])(object)new Toggle[1] { _enabled });
			_vulnerableVibing = GUISection.Get<Toggle>("VulnerableVibing");
			((BaseField<bool>)(object)_vulnerableVibing).SetupSaving<bool>(false);
			_vulnerableVibingThreshold = GUISection.Get<FloatField>("VulnerableVibingThreshold");
			((BaseField<float>)(object)_vulnerableVibingThreshold).SetupSaving<float>(50f).SetupValueClamping(0f, 100f).DependsOn<float>((Toggle[])(object)new Toggle[1] { _vulnerableVibing });
		}

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<bool>)(object)_scaleWithDamage).Load<bool>(preset);
			((BaseField<bool>)(object)_vulnerableVibing).Load<bool>(preset);
			((BaseField<float>)(object)_vulnerableVibingThreshold).Load<float>(preset);
		}

		public int PlayerHit(PlayerData data, int damage)
		{
			if (GUISection.Vibe.Logic.IsVibing && VulnerableVibingActive)
			{
				damage *= 2;
			}
			if (!base.Enabled)
			{
				return damage;
			}
			string subID = ((damage > 1) ? damage.ToString() : string.Empty);
			if (ScaleWithDamage)
			{
				Activate(base.Power * (float)damage, base.Time * (float)damage, subID);
			}
			else
			{
				Activate(subID);
			}
			return damage;
		}
	}
	internal class BuzzOnDeath : VibeSourceWithPunctuate
	{
		private readonly Toggle _includeNonLethal;

		private readonly Toggle _raceTheTimer;

		public bool RaceTheTimerActive;

		private readonly Toggle _corpseRunFail;

		private readonly FloatField _corpseRunFailMultiplier;

		private readonly Toggle _steelSoul;

		private readonly FloatField _steelSoulMultiplier;

		private readonly Toggle _raiseMinimum;

		private readonly FloatField _raiseMinimumAmount;

		private readonly Toggle _deathDice;

		private readonly Label _mostRecentRoll;

		[CompilerGenerated]
		private MinimumDefault? <_minimumDefault>k__BackingField;

		public bool IncludeNonLethal
		{
			get
			{
				return ((BaseField<bool>)(object)_includeNonLethal).value;
			}
			set
			{
				((BaseField<bool>)(object)_includeNonLethal).value = value;
			}
		}

		public bool RaceTheTimer
		{
			get
			{
				return ((BaseField<bool>)(object)_raceTheTimer).value;
			}
			set
			{
				((BaseField<bool>)(object)_raceTheTimer).value = value;
			}
		}

		public bool CorpseRunFail
		{
			get
			{
				return ((BaseField<bool>)(object)_corpseRunFail).value;
			}
			set
			{
				((BaseField<bool>)(object)_corpseRunFail).value = value;
			}
		}

		public float CorpseRunFailMultiplier
		{
			get
			{
				return ((BaseField<float>)(object)_corpseRunFailMultiplier).value;
			}
			set
			{
				((BaseField<float>)(object)_corpseRunFailMultiplier).value = value;
			}
		}

		public bool SteelSoul
		{
			get
			{
				return ((BaseField<bool>)(object)_steelSoul).value;
			}
			set
			{
				((BaseField<bool>)(object)_steelSoul).value = value;
			}
		}

		public float SteelSoulMultiplier
		{
			get
			{
				return ((BaseField<float>)(object)_steelSoulMultiplier).value;
			}
			set
			{
				((BaseField<float>)(object)_steelSoulMultiplier).value = value;
			}
		}

		public bool RaiseMinimum
		{
			get
			{
				return ((BaseField<bool>)(object)_raiseMinimum).value;
			}
			set
			{
				((BaseField<bool>)(object)_raiseMinimum).value = value;
			}
		}

		public float RaiseMinimumAmount
		{
			get
			{
				return ((BaseField<float>)(object)_raiseMinimumAmount).value / 100f;
			}
			set
			{
				((BaseField<float>)(object)_raiseMinimumAmount).value = value * 100f;
			}
		}

		public bool DeathDice
		{
			get
			{
				return ((BaseField<bool>)(object)_deathDice).value;
			}
			set
			{
				((BaseField<bool>)(object)_deathDice).value = value;
			}
		}

		private MinimumDefault? _minimumDefault
		{
			get
			{
				if (<_minimumDefault>k__BackingField == null)
				{
					<_minimumDefault>k__BackingField = (MinimumDefault)GUISection.Vibe.UI.Limits.Minimums.FirstOrDefault((MinimumBase x) => x is MinimumDefault);
				}
				return <_minimumDefault>k__BackingField;
			}
		}

		protected override string _punctuateReminderDescription => "death";

		public BuzzOnDeath()
			: base("Death", onByDefault: true, 100f, 10f, defaultPunctuate: true, 60)
		{
			ModHooks.OnBeforeDeathHook += OnDeathBefore;
			ModHooks.OnAfterDeathHook += OnDeathAfter;
			ModHooks.OnGetCocoonHook += OnGetCocoon;
			GUISection.Vibe.Logic.TimerHitZero += OnTimerZero;
			_includeNonLethal = GUISection.Get<Toggle>("IncludeNonLethal");
			((BaseField<bool>)(object)_includeNonLethal).SetupSaving<bool>(true).DependsOn<bool>((Toggle[])(object)new Toggle[1] { _enabled });
			_raceTheTimer = GUISection.Get<Toggle>("RaceTheTimer");
			((BaseField<bool>)(object)_raceTheTimer).SetupSaving<bool>(false).DependsOn<bool>((Toggle[])(object)new Toggle[1] { _enabled });
			_corpseRunFail = GUISection.Get<Toggle>("CorpseRunFail");
			((BaseField<bool>)(object)_corpseRunFail).SetupSaving<bool>(false);
			_corpseRunFailMultiplier = GUISection.Get<FloatField>("CorpseRunFailMultiplier");
			((BaseField<float>)(object)_corpseRunFailMultiplier).SetupSaving<float>(2f).DependsOn<float>((Toggle[])(object)new Toggle[1] { _corpseRunFail }).SetupValueClamping(0f, 999f)
				.SetupGreyout((float x) => x == 1f);
			_steelSoul = GUISection.Get<Toggle>("SteelSoul");
			((BaseField<bool>)(object)_steelSoul).SetupSaving<bool>(false);
			_steelSoulMultiplier = GUISection.Get<FloatField>("SteelSoulMultiplier");
			((BaseField<float>)(object)_steelSoulMultiplier).SetupSaving<float>(10f).DependsOn<float>((Toggle[])(object)new Toggle[1] { _steelSoul }).SetupValueClamping(0f, 999f)
				.SetupGreyout((float x) => x == 1f);
			_raiseMinimum = GUISection.Get<Toggle>("RaiseMinimum");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)_raiseMinimum).SetupSaving<bool>(false), (EventCallback<ChangeEvent<bool>>)RaiseMinimumChanged<bool>);
			_raiseMinimumAmount = GUISection.Get<FloatField>("RaiseMinimumAmount");
			((BaseField<float>)(object)_raiseMinimumAmount).SetupSaving<float>(5f).DependsOn<float>((Toggle[])(object)new Toggle[1] { _raiseMinimum }).SetupValueClamping(0f, 100f)
				.SetupGreyout((float x) => x == 0f);
			_deathDice = GUISection.Get<Toggle>("DeathDice");
			((BaseField<bool>)(object)_deathDice).SetupSaving<bool>(false);
			_mostRecentRoll = GUISection.Get<Label>("MostRecentRoll");
		}

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<bool>)(object)_includeNonLethal).Load<bool>(preset);
			((BaseField<bool>)(object)_raceTheTimer).Load<bool>(preset);
			((BaseField<bool>)(object)_corpseRunFail).Load<bool>(preset);
			((BaseField<float>)(object)_corpseRunFailMultiplier).Load<float>(preset);
			((BaseField<bool>)(object)_steelSoul).Load<bool>(preset);
			((BaseField<float>)(object)_steelSoulMultiplier).Load<float>(preset);
			((BaseField<bool>)(object)_raiseMinimum).Load<bool>(preset);
			((BaseField<float>)(object)_raiseMinimumAmount).Load<float>(preset);
			((BaseField<bool>)(object)_deathDice).Load<bool>(preset);
		}

		private static bool HasCocoonOut(PlayerData data)
		{
			return !string.IsNullOrEmpty(data.HeroCorpseScene);
		}

		private static bool IsSteelSoulMode(PlayerData data)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			PermadeathModes permadeathMode = data.permadeathMode;
			if (permadeathMode - 1 <= 1)
			{
				return true;
			}
			return false;
		}

		private void RaiseMinimumChanged<T>(ChangeEvent<T> evt)
		{
			_minimumDefault?.UpdateReminderText();
		}

		private void OnDeathBefore(HeroController manager, bool nonLethal, bool frostDeath)
		{
			if (manager.gm.IsMemoryScene())
			{
				nonLethal = true;
			}
			if (base.Enabled && (IncludeNonLethal || !nonLethal))
			{
				Activate();
			}
			PlayerData playerData = manager.playerData;
			if (SteelSoul && IsSteelSoulMode(playerData))
			{
				GUISection.Vibe.Logic.MultiplyTimer(SteelSoulMultiplier, "Steel Soul Death");
			}
			if (CorpseRunFail && HasCocoonOut(playerData) && !IsSteelSoulMode(playerData))
			{
				GUISection.Vibe.Logic.MultiplyTimer(CorpseRunFailMultiplier, "Corpse Run Death");
			}
			if (RaiseMinimum)
			{
				_minimumDefault?.RaiseMinimumDeath(RaiseMinimumAmount);
			}
			if (DeathDice)
			{
				DeathRoll();
			}
		}

		private void DeathRoll()
		{
			int num = ExtHelper.rng.Next(20) + 1;
			((VisualElement)_mostRecentRoll).RemoveFromClassList("hide");
			((TextElement)_mostRecentRoll).text = $"Most recent roll: {num}";
			GUISection.Vibe.UI.DisplayDeathDice(num);
		}

		private void OnDeathAfter(GameManager gm)
		{
			if (((BaseField<bool>)(object)_enabled).value && RaceTheTimer && !IsSteelSoulMode(gm.playerData) && HasCocoonOut(gm.playerData) && !GUISection.Vibe.Logic.TimerZero)
			{
				StartRaceTheTimer();
			}
		}

		private void StartRaceTheTimer()
		{
			RaceTheTimerActive = true;
			UpdateRaceTheTimerGraphic();
		}

		private void OnGetCocoon(HeroController controller)
		{
			if (RaceTheTimerActive)
			{
				EndRaceTheTimer(timerHitZero: false);
			}
		}

		private void OnTimerZero()
		{
			if (RaceTheTimerActive)
			{
				EndRaceTheTimer(timerHitZero: true);
			}
		}

		private void EndRaceTheTimer(bool timerHitZero)
		{
			if (RaceTheTimerActive && timerHitZero && HasCocoonOut(PlayerData.instance))
			{
				int num = DeleteCorpse();
				GUISection.Vibe.UI.LogActivity("Timer Hit Zero : Race the Timer", string.Format("Timer hit 0. Deleting cocoon.\nPlayer lost {0} rosaries.{1}", num, (num > 0) ? " Sorry!" : ""));
			}
			RaceTheTimerActive = false;
			UpdateRaceTheTimerGraphic();
		}

		private static int DeleteCorpse()
		{
			int silk = PlayerData.instance.silk;
			int heroCorpseMoneyPool = PlayerData.instance.HeroCorpseMoneyPool;
			PlayerData.instance.HeroCorpseMoneyPool = 0;
			PlayerData.instance.HeroCorpseScene = string.Empty;
			PlayerData.instance.HeroCorpseMarkerGuid = null;
			EventRegister.SendEvent("BREAK HERO CORPSE", (GameObject)null);
			if (PlayerData.instance.silkMax > 9)
			{
				PlayerData.instance.IsSilkSpoolBroken = false;
				EventRegister.SendEvent(EventRegisterEvents.SpoolUnbroken, (GameObject)null);
			}
			if (PlayerData.instance.silk > silk)
			{
				HeroController.instance.TakeSilk(PlayerData.instance.silk - silk);
			}
			return heroCorpseMoneyPool;
		}

		private void UpdateRaceTheTimerGraphic()
		{
			GUISection.Vibe.UI.TimerReadout.SetClassListIf<Label>("race-the-timer", (Func<Label, bool>)((Label x) => RaceTheTimerActive));
		}
	}
	internal class BuzzOnHeal : VibeSourceWithPunctuate
	{
		private readonly Toggle _noHealingWhileVibing;

		private readonly Toggle _interruption;

		private readonly FloatField _interruptionTime;

		private DateTime _lastHealInterruptionTime = DateTime.MinValue;

		private static TimeSpan _healInterruptionCooldown = TimeSpan.FromSeconds(1.0);

		public bool NoHealingWhileVibing
		{
			get
			{
				return ((BaseField<bool>)(object)_noHealingWhileVibing).value;
			}
			set
			{
				((BaseField<bool>)(object)_noHealingWhileVibing).value = value;
			}
		}

		public bool NoHealing
		{
			get
			{
				if (NoHealingWhileVibing)
				{
					return !GUISection.Vibe.Logic.TimerZero;
				}
				return false;
			}
		}

		public bool Interruption
		{
			get
			{
				return ((BaseField<bool>)(object)_interruption).value;
			}
			set
			{
				((BaseField<bool>)(object)_interruption).value = value;
			}
		}

		public float InterruptionTime
		{
			get
			{
				return ((BaseField<float>)(object)_interruptionTime).value;
			}
			set
			{
				((BaseField<float>)(object)_interruptionTime).value = value;
			}
		}

		protected override string _punctuateReminderDescription => "healing";

		public BuzzOnHeal()
			: base("Heal", onByDefault: true, 10f, 5f)
		{
			ModHooks.OnAddHealthHook += Healed;
			ModHooks.OnBindInterruptedHook += HealInterrupted;
			_noHealingWhileVibing = GUISection.Get<Toggle>("NoHealingWhileVibing");
			((BaseField<bool>)(object)_noHealingWhileVibing).SetupSaving<bool>(false);
			_interruption = GUISection.Get<Toggle>("Interruption");
			((BaseField<bool>)(object)_interruption).SetupSaving<bool>(true);
			_interruptionTime = GUISection.Get<FloatField>("InterruptionTime");
			((BaseField<float>)(object)_interruptionTime).SetupSaving<float>(2f).SetupValueClamping(0f, 999f).SetupGreyout((float x) => x == 0f)
				.DependsOn<float>((Toggle[])(object)new Toggle[1] { _interruption });
		}

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<bool>)(object)_noHealingWhileVibing).Load<bool>(preset);
			((BaseField<bool>)(object)_interruption).Load<bool>(preset);
			((BaseField<float>)(object)_interruptionTime).Load<float>(preset);
		}

		private int Healed(PlayerData data, int amount)
		{
			if (NoHealing)
			{
				amount = 0;
			}
			if (!base.Enabled)
			{
				return amount;
			}
			Activate();
			return amount;
		}

		private void HealInterrupted(HeroController controller)
		{
			if (Interruption && !(DateTime.Now - _lastHealInterruptionTime < _healInterruptionCooldown))
			{
				if (controller.WillDoBellBindHit())
				{
					ActivatePunctuation(InterruptionTime / 2f);
				}
				else
				{
					ActivatePunctuation(InterruptionTime);
				}
				_lastHealInterruptionTime = DateTime.Now;
			}
		}
	}
	internal class BuzzOnPickups : VibeSourceWithPunctuate
	{
		private readonly Toggle _scaleWithWeighting;

		private readonly Dictionary<string, WeightedEvent> KnownItems = new Dictionary<string, WeightedEvent>();

		public bool ScaleWithWeighting
		{
			get
			{
				return ((BaseField<bool>)(object)_scaleWithWeighting).value;
			}
			set
			{
				((BaseField<bool>)(object)_scaleWithWeighting).value = value;
			}
		}

		protected override string _punctuateReminderDescription => "collecting an item";

		public BuzzOnPickups()
			: base("Pickups", onByDefault: false, 50f, 5f, defaultPunctuate: true)
		{
			ModHooks.OnItemPickupHook += ItemPickup;
			ModHooks.OnSetBoolHook += OnSetBool;
			ModHooks.OnSetIntHook += OnSetInt;
			ModHooks.OnMaxHealthUpHook += OnMaxHealthUp;
			ModHooks.OnMaxSilkUpHook += OnMaxSilkUp;
			ModHooks.OnToolUnlockHook += ToolUnlock;
			_scaleWithWeighting = GUISection.Get<Toggle>("PickupsScaleWithWeighting");
			((BaseField<bool>)(object)_scaleWithWeighting).SetupSaving<bool>(true).DependsOn<bool>((Toggle[])(object)new Toggle[1] { _enabled });
			VisualElement parent = ((VisualElement)GUISection.Get<Label>("PickupsItemListLabel")).parent;
			KnownItems["Rosary_Set_Frayed"] = CreateUI("FrayedRosaryString", 0.3f, defaultOn: true, gapBelow: false, "Collectable Items");
			KnownItems["Rosary_Set_Small"] = CreateUI("RosaryString", 0.6f, defaultOn: true);
			KnownItems["Rosary_Set_Medium"] = CreateUI("RosaryNecklace", 1.2f, defaultOn: true);
			KnownItems["Rosary_Set_Large"] = CreateUI("HeavyRosaryNecklace", 2.2f, defaultOn: true);
			KnownItems["Rosary_Set_Huge_White"] = CreateUI("PaleRosaryNecklace", 3.4f, defaultOn: true, gapBelow: true);
			KnownItems["Shard Pouch"] = CreateUI("ShardBundle", 0.5f, defaultOn: true);
			KnownItems["Great Shard"] = CreateUI("BeastShard", 1.4f, defaultOn: true);
			KnownItems["Pristine Core"] = CreateUI("PristineCore", 2.2f, defaultOn: true);
			KnownItems["Fixer Idol"] = CreateUI("HornetStatuette", 3f, defaultOn: true);
			KnownItems["Growstone"] = CreateUI("Growstone", 3f, defaultOn: true, gapBelow: true);
			KnownItems["Silk Grub"] = CreateUI("SilkEater", 0.8f, defaultOn: true);
			KnownItems["Tool Metal"] = CreateUI("Craftmetal", 0.5f, defaultOn: true);
			MapCategory(CreateUI("Relics", 0.6f, defaultOn: true), new string[14]
			{
				"Bone Record Wisp Top", "Bone Record Greymoor_flooded_corridor", "Bone Record Bone_East_14", "Bone Record Understore_Map_Room", "Seal Chit City Merchant", "Seal Chit Silk Siphon", "Seal Chit Ward Corpse", "Seal Chit Aspid_01", "Weaver Record Conductor", "Weaver Record Sprint_Challenge",
				"Weaver Record Weave_08", "Weaver Totem Slab_Bottom", "Weaver Totem Bonetown_upper_room", "Weaver Totem Witch"
			});
			KnownItems["Ancient Egg Abyss Middle"] = CreateUI("ArcaneEgg", 2.4f, defaultOn: true);
			MapCategory(CreateUI("PsalmCylinders", 0.6f, defaultOn: true), new string[5] { "Psalm Cylinder Hang", "Psalm Cylinder Librarian", "Psalm Cylinder Grindle", "Psalm Cylinder Library Roof", "Psalm Cylinder Ward" });
			KnownItems["Librarian Melody Cylinder"] = CreateUI("SacredCylinder", 2f, defaultOn: true, gapBelow: true);
			MapCategory(CreateUI("ShamanSouls", 0.8f, defaultOn: true), new string[3] { "Snare Soul Bell Hermit", "Snare Soul Churchkeeper", "Snare Soul Swamp Bug" });
			MapCategory(CreateUI("OldHearts", 1.5f, defaultOn: true), new string[4] { "Clover Heart", "Coral Heart", "Flower Heart", "Hunter Heart" });
			KnownItems["Pale_Oil"] = CreateUI("PaleOil", 2f, defaultOn: true);
			KnownItems["Wood Witch Item"] = CreateUI("TwistedBud", 6f, defaultOn: true);
			KnownItems["Plasmium Gland"] = CreateUI("PlasmiumGland", 1f, defaultOn: true);
			KnownItems["White Flower"] = CreateUI("Everbloom", 2.5f, defaultOn: true, gapBelow: true);
			MapCategory(CreateUI("OtherQuestItems", 0.2f, defaultOn: true, gapBelow: true), new string[31]
			{
				"Broodmother Remains", "Cog Heart Pieces", "Skull King Fragment", "Coral Ingredient", "Rock Roller Item", "Ant Trapper Item", "Beastfly Remains", "Mossberry", "Mossberry Stew", "Pickled Roach Egg",
				"Shell Flower", "Broken SilkShot", "Extractor Machine Pins", "Vintage Nectar", "Courier Supplies Gourmand", "Courier Supplies", "Courier Supplies Mask Maker", "Courier Supplies Slave", "Song Pilgrim Cloak", "Fine Pin",
				"Pilgrim Rag", "Plasmium Blood", "Plasmium", "Crow Feather", "Roach Corpse Item", "Enemy Morsel Seared", "Enemy Morsel Shredded", "Silver Bellclapper", "Enemy Morsel Speared", "Common Spine",
				"Flintgem"
			});
			MapCategory(CreateUI("Mementos", 1f, defaultOn: true, gapBelow: true), new string[7] { "Crowman Memento", "Grey Memento", "Memento Seth", "Memento Garmond", "Hunter Memento", "Sprintmaster Memento", "Memento Surface" });
			MapCategory(CreateUI("RedTools", 0.8f, defaultOn: true, gapBelow: false, "Equipment / Upgrades"), new string[23]
			{
				"Cogwork Flier", "Cogwork Saw", "Conch Drill", "Curve Claws", "Curve Claws Upgraded", "Screw Attack", "Flea Brew", "Flintstone", "Harpoon", "Extractor",
				"Pimpilo", "Lifeblood Syringe", "Rosary Cannon", "WebShot Forge", "WebShot Weaver", "WebShot Architect", "Silk Snare", "Sting Shard", "Straight Pin", "Tack",
				"Tri Pin", "Shakra Ring", "Lightning Rod"
			});
			MapCategory(CreateUI("BlueTools", 0.7f, defaultOn: true), new string[23]
			{
				"Dazzle Bind", "Dazzle Bind Upgraded", "Mosscreep Tool 1", "Mosscreep Tool 2", "Flea Charm", "Fractured Mask", "Quickbind", "Longneedle", "Lava Charm", "Revenge Crystal",
				"Multibind", "Pinstress Tool", "Poison Pouch", "Quick Sling", "Reserve Bind", "Brolly Spike", "Thief Claw", "Spool Extender", "Zap Imbuement", "Bell Bind",
				"White Ring", "Wisp Lantern", "Maggot Charm"
			});
			MapCategory(CreateUI("YellowTools", 0.6f, defaultOn: true), new string[13]
			{
				"Wallcling", "Barbed Wire", "Compass", "Dead Mans Purse", "Rosary Magnet", "Magnetite Dice", "Scuttlebrace", "Bone Necklace", "Shell Satchel", "Sprintmaster",
				"Musician Charm", "Thief Charm", "Weighted Anklet"
			});
			KnownItems["ToolPouchUpgrades"] = CreateUI("ToolPouch", 0.5f, defaultOn: true);
			KnownItems["Tool Pouch&Kit Inv"] = KnownItems["ToolPouchUpgrades"];
			KnownItems["ToolKitUpgrades"] = CreateUI("CraftingKit", 0.5f, defaultOn: true, gapBelow: true);
			KnownItems["silkRegenMax"] = CreateUI("SilkHeart", 1.2f, defaultOn: true);
			KnownItems["Crest Socket Unlocker"] = CreateUI("MemoryLocket", 0.8f, defaultOn: true);
			KnownItems["heartPieces"] = CreateUI("MaskShard", 0.6f, defaultOn: true);
			KnownItems["fullHeart"] = CreateUI("FullMask", 1f, defaultOn: true);
			KnownItems["silkSpoolParts"] = CreateUI("SpoolFragment", 0.4f, defaultOn: true);
			KnownItems["fullSpool"] = CreateUI("FullSpool", 0.6f, defaultOn: true, gapBelow: true);
			MapCategory(CreateUI("Maps", 0.2f, defaultOn: true, gapBelow: false, "Navigation / World"), new string[28]
			{
				"HasBellhartMap", "HasSwampMap", "HasJudgeStepsMap", "HasHallsMap", "HasCogMap", "HasCradleMap", "HasDocksMap", "HasWildsMap", "HasSongGateMap", "HasGreymoorMap",
				"HasHangMap", "HasHuntersNestMap", "HasArboriumMap", "HasMossGrottoMap", "HasPeakMap", "HasAqueductMap", "HasCoralMap", "HasShellwoodMap", "HasDustpensMap", "HasAbyssMap",
				"HasBoneforestMap", "HasSlabMap", "HasCitadelUnderstoreMap", "HasCloverMap", "HasWeavehomeMap", "HasLibraryMap", "HasWardMap", "HasCrawlMap"
			});
			MapCategory(CreateUI("MapMarkers", 0.1f, defaultOn: true), new string[15]
			{
				"hasMarker_a", "hasMarker_b", "hasMarker_c", "hasMarker_d", "hasMarker_e", "hasPinBench", "hasPinStag", "hasPinShop", "hasPinTube", "hasPinFleaMarrowlands",
				"hasPinFleaMidlands", "hasPinFleaBlastedlands", "hasPinFleaCitadel", "hasPinFleaPeaklands", "hasPinFleaMucklands"
			});
			KnownItems["QuillState"] = CreateUI("Quill", 0.3f, defaultOn: true, gapBelow: true);
			MapCategory(CreateUI("BellwayUnlocks", 0.4f, defaultOn: true), new string[10] { "UnlockedDocksStation", "UnlockedBoneforestEastStation", "UnlockedGreymoorStation", "UnlockedBelltownStation", "UnlockedCoralTowerStation", "UnlockedCityStation", "UnlockedPeakStation", "UnlockedShellwoodStation", "UnlockedShadowStation", "UnlockedAqueductStation" });
			MapCategory(CreateUI("VentricaUnlocks", 0.5f, defaultOn: true, gapBelow: true), new string[6] { "UnlockedSongTube", "UnlockedUnderTube", "UnlockedCityBellwayTube", "UnlockedHangTube", "UnlockedEnclaveTube", "UnlockedArboriumTube" });
			MapCategory(CreateUI("Keys", 0.6f, defaultOn: true, gapBelow: true), new string[8] { "Architect Key", "Belltown House Key", "Craw Summons", "Dock Key", "Slab Key", "Simple Key", "Ward Boss Key", "Ward Key" });
			MapCategory(CreateUI("BellhomeUpgrades", 0.4f, defaultOn: true), new string[7] { "Crawbell", "Farsight", "Materium", "BelltownFurnishingDesk", "BelltownFurnishingFairyLights", "BelltownFurnishingGramaphone", "BelltownFurnishingSpa" });
			MapCategory(CreateUI("MateriumEntries", 0.3f, defaultOn: true, gapBelow: true), new string[4] { "Materium-Flintstone", "Materium-Magnetite", "Materium-Voltridian", "Journal_Entry-Void_Tendrils" });
			MapCategory(CreateUI("SilkSkills", 1f, defaultOn: true, gapBelow: false, "Abilities"), new string[6] { "Parry", "Silk Boss Needle", "Silk Bomb", "Silk Charge", "Silk Spear", "Thread Sphere" });
			KnownItems["hasDash"] = CreateUI("SwiftStep", 0.6f, defaultOn: true);
			KnownItems["hasWalljump"] = CreateUI("ClingGrip", 1.2f, defaultOn: true);
			KnownItems["hasHarpoonDash"] = CreateUI("Clawline", 1f, defaultOn: true);
			KnownItems["hasSuperJump"] = CreateUI("SilkSoar", 2f, defaultOn: true);
			KnownItems["hasChargeSlash"] = CreateUI("NeedleStrike", 0.6f, defaultOn: true, gapBelow: true);
			KnownItems["hasBrolly"] = CreateUI("DriftersCloak", 1f, defaultOn: true);
			KnownItems["hasDoubleJump"] = CreateUI("FaydownCloak", 2f, defaultOn: true, gapBelow: true);
			KnownItems["hasNeedolin"] = CreateUI("Needolin", 1.5f, defaultOn: true);
			KnownItems["hasNeedolinMemoryPowerup"] = CreateUI("ElegyOfTheDeep", 1f, defaultOn: true);
			KnownItems["UnlockedFastTravelTeleport"] = CreateUI("BeastlingCall", 0.5f, defaultOn: true);
			KnownItems["HasMelodyArchitect"] = CreateUI("ArchitectMelody", 1.2f, defaultOn: true);
			KnownItems["HasMelodyConductor"] = CreateUI("ConductorMelody", 1.2f, defaultOn: true);
			KnownItems["HasMelodyLibrarian"] = CreateUI("VaultkeeperMelody", 1.2f, defaultOn: true, gapBelow: true);
			KnownItems["Reaper"] = CreateUI("ReaperCrest", 0.8f, defaultOn: true);
			KnownItems["Wanderer"] = CreateUI("WandererCrest", 0.8f, defaultOn: true);
			KnownItems["Warrior"] = CreateUI("BeastCrest", 0.5f, defaultOn: true);
			KnownItems["Witch"] = CreateUI("WitchCrest", 1f, defaultOn: true);
			KnownItems["Toolmaster"] = CreateUI("ArchitectCrest", 1f, defaultOn: true);
			KnownItems["Spell"] = CreateUI("ShamanCrest", 1f, defaultOn: true, gapBelow: true);
			KnownItems["Cloakless"] = CreateUI("CloaklessCrest", 1.2f, defaultOn: true);
			KnownItems["Cursed"] = CreateUI("CursedWitchCrest", 1.8f, defaultOn: true, gapBelow: true);
			MapCategory(CreateUI("HuntersUpgrade", 0.7f, defaultOn: true), new string[3] { "Hunter", "Hunter_v2", "Hunter_v3" });
			MapCategory(CreateUI("VesticrestUpgrade", 0.8f, defaultOn: true), new string[2] { "UnlockedExtraBlueSlot", "UnlockedExtraYellowSlot" });
			KnownItems["HasBoundCrestUpgrader"] = CreateUI("Sylphsong", 1f, defaultOn: true, gapBelow: true);
			WeightedEvent CreateUI(string identifier, float defaultWeight, bool defaultOn, bool gapBelow = false, string? categoryLabel = null)
			{
				return WeightedEvent.CreateWithUI(identifier, defaultWeight, defaultOn, parent, this, _enabled, _scaleWithWeighting, !gapBelow, categoryLabel);
			}
			void MapCategory(WeightedEvent evt, params string[] ids)
			{
				foreach (string key in ids)
				{
					KnownItems[key] = evt;
				}
			}
		}

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<bool>)(object)_scaleWithWeighting).Load<bool>(preset);
			foreach (WeightedEvent value in KnownItems.Values)
			{
				value.Load(preset);
			}
		}

		private void OnSetInt(string intName, int value)
		{
			GUISection.Log(string.Format("[DIAG] SetInt: {0} = {1}{2}", intName, value, KnownItems.ContainsKey(intName) ? " *** MATCH ***" : ""));
			TryActivate(intName);
		}

		private void OnSetBool(string boolName, bool value)
		{
			if (value)
			{
				GUISection.Log("[DIAG] SetBool: " + boolName + " = true" + (KnownItems.ContainsKey(boolName) ? " *** MATCH ***" : ""));
			}
			if (value)
			{
				TryActivate(boolName);
			}
		}

		private void ItemPickup(SavedItem item)
		{
			GUISection.Log($"GOT ITEM: {((object)item).GetType().Name} - {((Object)item).name} (unique: {item.IsUnique})");
			TryActivate(((Object)item).name);
		}

		private void ToolUnlock(ToolItem tool)
		{
			GUISection.Log("GOT TOOL: " + ((object)tool).GetType().Name + " - " + tool.name);
			TryActivate(tool.name);
		}

		private void TryActivate(string name)
		{
			if (base.Enabled && KnownItems.TryGetValue(name, out WeightedEvent value))
			{
				Activate(value);
			}
		}

		private void Activate(WeightedEvent weightedEvent)
		{
			if (weightedEvent.Enabled)
			{
				if (!ScaleWithWeighting)
				{
					Activate(weightedEvent.EnabledText);
				}
				else
				{
					Activate(weightedEvent.Weight, weightedEvent.EnabledText);
				}
			}
		}

		private void OnMaxHealthUp()
		{
			TryActivate("fullHeart");
		}

		private void OnMaxSilkUp()
		{
			TryActivate("fullSpool");
		}
	}
	internal class BuzzOnRandom : VibeSourceWithPunctuate
	{
		private readonly IntegerField _randomOdds;

		private float _timeSinceLastRoll;

		public int RandomOdds
		{
			get
			{
				return ((BaseField<int>)(object)_randomOdds).value;
			}
			set
			{
				((BaseField<int>)(object)_randomOdds).value = value;
			}
		}

		protected override string _punctuateReminderDescription => "getting unlucky";

		public BuzzOnRandom()
			: base("Random", onByDefault: true, 100f, 10f)
		{
			_randomOdds = GUISection.Get<IntegerField>("RandomOdds");
			((BaseField<int>)(object)_randomOdds).SetupSaving<int>(7200).SetupValueClamping(1, 99999).DependsOn<int>((Toggle[])(object)new Toggle[1] { _enabled });
			GUISection.Vibe.NeedsUpdate += Update;
		}

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<int>)(object)_randomOdds).Load<int>(preset);
		}

		private void Update(float realTime, float timerTime)
		{
			if (base.Enabled && !(timerTime <= float.Epsilon))
			{
				_timeSinceLastRoll += timerTime;
				if (_timeSinceLastRoll > 1f)
				{
					_timeSinceLastRoll -= 1f;
					RollForVibes();
				}
			}
		}

		private void RollForVibes()
		{
			int num = ExtHelper.rng.Next(RandomOdds);
			if (num == 0)
			{
				Activate();
			}
			if (num == 1 && ((ToolBase)Gameplay.LuckyDiceTool).IsEquipped)
			{
				Activate();
			}
		}
	}
	internal class BuzzOnRumble : VibeSourceWithPunctuate
	{
		public const string UncategorisedRumbleEventName = "UncategorisedRumble";

		private readonly Toggle _scaleWithWeighting;

		private readonly Dictionary<string, WeightedEvent> RumbleEvents = new Dictionary<string, WeightedEvent>();

		private static readonly HashSet<string> meaninglessRumbleNames = new HashSet<string>
		{
			"Play", "PlaySound", "PlayVibration", "PlayVibrationClipOneShot", "PlayRandomVibration", "PlayDelayedVibrationRoutine", "SpawnAndPlayOneShot", "SpawnAndPlayOneShotInternal", "StartVibration", "StartEmission",
			"StartSyncedEmission", "StartRumble", "GetDuration", "OnEnter", "OnEnable", "DoShake", "ActivateActions", "DoTransition", "EnterState", "SwitchState",
			"UpdateState", "heroAction", "UpdateStateChanges", "SetActive_Injected", "ProcessEvent", "Event", "SendEvent", "SetActive"
		};

		private HashSet<WeightedEvent> _seenThisFrame = new HashSet<WeightedEvent>();

		public bool ScaleWithWeighting
		{
			get
			{
				return ((BaseField<bool>)(object)_scaleWithWeighting).value;
			}
			set
			{
				((BaseField<bool>)(object)_scaleWithWeighting).value = value;
			}
		}

		protected override string _punctuateReminderDescription => "a rumble";

		public BuzzOnRumble()
			: base("Rumble", onByDefault: true, 10f, 1f, defaultPunctuate: false, 10)
		{
			_scaleWithWeighting = GUISection.Get<Toggle>("RumbleScaleWithWeighting");
			((BaseField<bool>)(object)_scaleWithWeighting).SetupSaving<bool>(true).DependsOn<bool>((Toggle[])(object)new Toggle[1] { _enabled });
			ModHooks.OnRumbleHook += OnRumble;
			GUISection.Vibe.NeedsUpdate += Update;
			VisualElement parent = ((VisualElement)GUISection.Get<Label>("RumbleEventsListLabel")).parent;
			RumbleEvents["UncategorisedRumble"] = new WeightedEvent("UncategorisedRumble", 1f, _enabled, _scaleWithWeighting, defaultOn: false);
			RumbleEvents["PlaySoftLand"] = CreateUI("Landing", 0.5f, defaultOn: false, gapBelow: false, "Movement");
			RumbleEvents["DoHardLandingEffectNoHit"] = CreateUI("HardLanding", 3f, defaultOn: true, gapBelow: true);
			RumbleEvents["HeroDash"] = CreateUI("Dashing", 0.6f, defaultOn: false);
			RumbleEvents["PlayDash"] = RumbleEvents["HeroDash"];
			RumbleEvents["PlayAirDash"] = RumbleEvents["HeroDash"];
			RumbleEvents["PlayFootStep"] = CreateUI("Sprinting", 0.2f, defaultOn: false);
			RumbleEvents["StartShuttlecock"] = CreateUI("SprintJump", 0.8f, defaultOn: false, gapBelow: true);
			RumbleEvents["PlayWallJump"] = CreateUI("WallJump", 0.3f, defaultOn: false);
			RumbleEvents["StartWallSlide"] = CreateUI("WallSlide", 0.2f, defaultOn: false, gapBelow: true);
			RumbleEvents["PlayDoubleJump"] = CreateUI("DoubleJump", 0.5f, defaultOn: false, gapBelow: true);
			RumbleEvents["PlaySwimEnter"] = CreateUI("StartSwimming", 0.5f, defaultOn: false);
			RumbleEvents["PlaySwimExit"] = CreateUI("StopSwimming", 0.5f, defaultOn: false, gapBelow: true);
			RumbleEvents["StartSlash"] = CreateUI("DownSlash", 0.3f, defaultOn: false, gapBelow: false, "Combat");
			RumbleEvents["OnSlashStarting"] = CreateUI("AnySlash", 0.2f, defaultOn: false, gapBelow: true);
			RumbleEvents["PlayToolThrow"] = CreateUI("UseTool", 1f, defaultOn: true);
			RumbleEvents["Camera Shake"] = CreateUI("CameraShake", 0.5f, defaultOn: false, gapBelow: false, "Environment");
			RumbleEvents["DoBobInternal"] = CreateUI("CameraBob", 0.3f, defaultOn: false, gapBelow: true);
			RumbleEvents["PlayHeroHazardDeath"] = CreateUI("HazardDamage", 2f, defaultOn: false, gapBelow: true);
			RumbleEvents["PlaySubmitSound"] = CreateUI("MenuSubmitSound", 0.5f, defaultOn: false, gapBelow: true, "Interface");
			RumbleEvents["PressCancel"] = RumbleEvents["PlaySubmitSound"];
			RumbleEvents["PressSubmit"] = RumbleEvents["PlaySubmitSound"];
			RumbleEvents["PlayConsumeFinalShake"] = CreateUI("UseConsumable", 1f, defaultOn: true);
			RumbleEvents["PlayFinalShake"] = CreateUI("UseMemoryLocket", 2f, defaultOn: true, gapBelow: true);
			RumbleEvents["PlaceMarker"] = CreateUI("UseMapMarker", 0.5f, defaultOn: false);
			RumbleEvents["RemoveMarker"] = RumbleEvents["PlaceMarker"];
			WeightedEvent CreateUI(string identifier, float defaultWeight, bool defaultOn, bool gapBelow = false, string? categoryLabel = null)
			{
				return WeightedEvent.CreateWithUI(identifier, defaultWeight, defaultOn, parent, this, _enabled, _scaleWithWeighting, !gapBelow, categoryLabel);
			}
		}

		private void Update(float realTime, float timerTime)
		{
			if (_seenThisFrame.Count > 0)
			{
				_seenThisFrame.Clear();
			}
		}

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<bool>)(object)_scaleWithWeighting).Load<bool>(preset);
			foreach (KeyValuePair<string, WeightedEvent> rumbleEvent in RumbleEvents)
			{
				rumbleEvent.Value.Load(preset);
			}
		}

		private void OnRumble(string? rumbleName)
		{
			if (base.Enabled)
			{
				if (string.IsNullOrWhiteSpace(rumbleName) || meaninglessRumbleNames.Contains(rumbleName))
				{
					rumbleName = FigureOutRumbleName();
				}
				if (RumbleEvents.TryGetValue(rumbleName, out WeightedEvent value))
				{
					ActivateRumble(value);
					return;
				}
				ActivateRumble(RumbleEvents["UncategorisedRumble"], "Uncategorised (" + rumbleName + ")");
				GUISection.Log("Uncategorised rumble event: " + rumbleName);
			}
			static string FigureOutRumbleName()
			{
				string text = "unknown";
				for (int i = 3; i <= 8; i++)
				{
					try
					{
						text = new StackFrame(i).GetMethod().Name;
					}
					catch
					{
						break;
					}
					if (text.Contains(':'))
					{
						string text2 = text;
						int num = text.IndexOf(':');
						text = text2.Substring(num, text2.Length - num).Trim(':', '>', '<');
					}
					if (!meaninglessRumbleNames.Contains(text))
					{
						return text;
					}
				}
				return "UncategorisedRumble";
			}
		}

		private void ActivateRumble(WeightedEvent rumbleEvent, string? subID = null)
		{
			if (rumbleEvent.Enabled && !_seenThisFrame.Contains(rumbleEvent))
			{
				_seenThisFrame.Add(rumbleEvent);
				if (!ScaleWithWeighting)
				{
					Activate(subID ?? rumbleEvent.EnabledText);
				}
				else
				{
					Activate(rumbleEvent.Weight, subID ?? rumbleEvent.EnabledText);
				}
			}
		}
	}
	internal class BuzzOnStrike : VibeSourceWithPunctuate
	{
		private readonly Toggle _scaleWithDamageDealt;

		private readonly Toggle _dealBonusDamage;

		public bool ScaleWithDamageDealt
		{
			get
			{
				return ((BaseField<bool>)(object)_scaleWithDamageDealt).value;
			}
			set
			{
				((BaseField<bool>)(object)_scaleWithDamageDealt).value = value;
			}
		}

		public bool DealBonusDamage
		{
			get
			{
				return ((BaseField<bool>)(object)_dealBonusDamage).value;
			}
			set
			{
				((BaseField<bool>)(object)_dealBonusDamage).value = value;
			}
		}

		protected override string _punctuateReminderDescription => "dealing damage";

		public BuzzOnStrike()
			: base("Strike", onByDefault: false, 2.4f, 1f, defaultPunctuate: false, 10)
		{
			ModHooks.OnDealDamageHook += DealtDamage;
			_scaleWithDamageDealt = GUISection.Get<Toggle>("ScaleWithDamageDealt");
			((BaseField<bool>)(object)_scaleWithDamageDealt).SetupSaving<bool>(true).DependsOn<bool>((Toggle[])(object)new Toggle[1] { _enabled });
			_dealBonusDamage = GUISection.Get<Toggle>("DealBonusDamage");
			((BaseField<bool>)(object)_dealBonusDamage).SetupSaving<bool>(false);
		}

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<bool>)(object)_scaleWithDamageDealt).Load<bool>(preset);
			((BaseField<bool>)(object)_dealBonusDamage).Load<bool>(preset);
		}

		private int DealtDamage(HealthManager manager, HitInstance instance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!instance.IsHeroDamage || !((HitInstance)(ref instance)).IsNailDamage)
			{
				return instance.DamageDealt;
			}
			float num = (DealBonusDamage ? (1f + GUISection.Vibe.Logic.TargetPower) : 1f);
			if (base.Enabled)
			{
				if (ScaleWithDamageDealt)
				{
					Activate(base.Power * (float)instance.DamageDealt / 10f, base.Time);
				}
				else
				{
					Activate();
				}
			}
			return (int)((float)instance.DamageDealt * num);
		}
	}
	public enum VibeSourceMode
	{
		Add,
		Subtract,
		Set,
		Raise,
		Lower
	}
	public abstract class VibeSource : GUISection, IPresetLoadable
	{
		protected readonly Toggle _enabled;

		protected readonly FloatField _power;

		protected readonly CyclingButton<VibeSourceMode> _powerMode;

		protected readonly FloatField _time;

		protected readonly CyclingButton<VibeSourceMode> _timeMode;

		public bool Enabled
		{
			get
			{
				return ((BaseField<bool>)(object)_enabled).value;
			}
			set
			{
				((BaseField<bool>)(object)_enabled).value = value;
			}
		}

		public float Power
		{
			get
			{
				return ((BaseField<float>)(object)_power).value / 100f;
			}
			set
			{
				((BaseField<float>)(object)_power).value = value * 100f;
			}
		}

		public VibeSourceMode PowerMode
		{
			get
			{
				return _powerMode.currentMode;
			}
			set
			{
				_powerMode.SetToMode(value);
			}
		}

		public float Time
		{
			get
			{
				return ((BaseField<float>)(object)_time).value;
			}
			set
			{
				((BaseField<float>)(object)_time).value = value;
			}
		}

		public VibeSourceMode TimeMode
		{
			get
			{
				return _timeMode.currentMode;
			}
			set
			{
				_timeMode.SetToMode(value);
			}
		}

		protected VibeSource(string identifier, bool onByDefault, float defaultPower, float defaultTime, VibeSourceMode defaultPowerMode = VibeSourceMode.Add, VibeSourceMode defaultTimeMode = VibeSourceMode.Add)
			: base(identifier)
		{
			_enabled = GUISection.Get<Toggle>("BuzzOn" + base.Identifier);
			((BaseField<bool>)(object)_enabled).SetupSaving<bool>(onByDefault, base.Identifier + "VibeSource");
			_power = GUISection.Get<FloatField>(base.Identifier + "Power");
			((BaseField<float>)(object)_power).SetupSaving<float>(defaultPower).SetupValueClamping(0f, 100f).SetupGreyout<float>(PowerFieldMeaningless);
			_powerMode = new CyclingButton<VibeSourceMode>(base.Identifier + "PowerMode", VibeSourceMode.Add, VibeSourceModeToString);
			_powerMode.SetupSaving(defaultPowerMode);
			_time = GUISection.Get<FloatField>(base.Identifier + "Time");
			((BaseField<float>)(object)_time).SetupSaving<float>(defaultTime).SetupValueClamping(0f, 999f).SetupGreyout<float>(TimeFieldMeaningless);
			_timeMode = new CyclingButton<VibeSourceMode>(base.Identifier + "TimeMode", VibeSourceMode.Add, VibeSourceModeToString);
			_timeMode.SetupSaving(defaultTimeMode);
			CyclingButton<VibeSourceMode> powerMode = _powerMode;
			powerMode.clicked = (Action)Delegate.Combine(powerMode.clicked, new Action(UpdatePowerGreyness));
			CyclingButton<VibeSourceMode> timeMode = _timeMode;
			timeMode.clicked = (Action)Delegate.Combine(timeMode.clicked, new Action(UpdateTimeGreyness));
		}

		public virtual void SetToPreset(Preset preset)
		{
			((BaseField<bool>)(object)_enabled).Load<bool>(preset);
			((BaseField<float>)(object)_power).Load<float>(preset);
			_powerMode.Load(preset);
			((BaseField<float>)(object)_time).Load<float>(preset);
			_timeMode.Load(preset);
		}

		private bool PowerFieldMeaningless(float uiPower)
		{
			return VibeLogic.PowerFieldMeaningless(uiPower / 100f, VibeSourceModeToString(PowerMode));
		}

		private bool TimeFieldMeaningless(float time)
		{
			return VibeLogic.TimeFieldMeaningless(time, VibeSourceModeToString(TimeMode));
		}

		private void UpdatePowerGreyness()
		{
			_power.SetClassListIf<FloatField>("grey-value", (Func<FloatField, bool>)((FloatField x) => PowerFieldMeaningless(((BaseField<float>)(object)x).value)));
		}

		private void UpdateTimeGreyness()
		{
			_time.SetClassListIf<FloatField>("grey-value", (Func<FloatField, bool>)((FloatField x) => TimeFieldMeaningless(((BaseField<float>)(object)x).value)));
		}

		public void ActivatePunctuation(float punctuateTime, string? subID = null)
		{
			Activate(0f, VibeSourceMode.Add, 0f, VibeSourceMode.Add, punctuateTime, subID ?? "Punctuation");
		}

		public void Activate(string? subID = null)
		{
			Activate(Power, Time, subID);
		}

		public void Activate(float multiplier, string? subID = null)
		{
			Activate(Power * multiplier, Time * multiplier, subID);
		}

		public virtual void Activate(float power, float time, string? subID = null)
		{
			Activate(power, time, 0f, subID);
		}

		public void Activate(float power, float time, float punctuateTime, string? subID = null)
		{
			Activate(power, PowerMode, time, TimeMode, punctuateTime, subID);
		}

		public virtual void Activate(float power, VibeSourceMode powerMode, float time, VibeSourceMode timeMode, string? subID = null)
		{
			Activate(power, powerMode, time, timeMode, 0f, subID);
		}

		public void Activate(float power, VibeSourceMode powerMode, float time, VibeSourceMode timeMode, float punctuateTime, string? subID = null)
		{
			string text = base.Identifier + " Source";
			if (!string.IsNullOrWhiteSpace(subID))
			{
				text = text + " : " + subID;
			}
			GUISection.Vibe.Logic.VibeSourceActivation(text, power, VibeSourceModeToString(powerMode), time, VibeSourceModeToString(timeMode), punctuateTime, Power, Time);
		}

		public static VibeSourceMode StringToVibeSourceMode(string text)
		{
			return text[0] switch
			{
				'+' => VibeSourceMode.Add, 
				'-' => VibeSourceMode.Subtract, 
				'=' => VibeSourceMode.Set, 
				'≥' => VibeSourceMode.Raise, 
				'≤' => VibeSourceMode.Lower, 
				_ => throw new NotImplementedException(), 
			};
		}

		public static string VibeSourceModeToString(VibeSourceMode mode)
		{
			return mode switch
			{
				VibeSourceMode.Add => "+", 
				VibeSourceMode.Subtract => "-", 
				VibeSourceMode.Set => "=", 
				VibeSourceMode.Raise => "≥", 
				VibeSourceMode.Lower => "≤", 
				_ => throw new NotImplementedException(), 
			};
		}
	}
	public abstract class VibeSourceWithPunctuate : VibeSource
	{
		protected readonly Toggle _punctuate;

		protected readonly SliderInt _punctuateTime;

		protected readonly Label _punctuateReminder;

		public bool Punctuate
		{
			get
			{
				return ((BaseField<bool>)(object)_punctuate).value;
			}
			set
			{
				((BaseField<bool>)(object)_punctuate).value = value;
			}
		}

		public float PunctuateTime
		{
			get
			{
				return (float)((BaseField<int>)(object)_punctuateTime).value / 100f;
			}
			set
			{
				((BaseField<int>)(object)_punctuateTime).value = (int)(value * 100f);
			}
		}

		protected abstract string _punctuateReminderDescription { get; }

		protected VibeSourceWithPunctuate(string identifier, bool onByDefault, float defaultPower, float defaultTime, bool defaultPunctuate = false, int defaultPunctuateTime = 30, VibeSourceMode defaultPowerMode = VibeSourceMode.Add, VibeSourceMode defaultTimeMode = VibeSourceMode.Add)
			: base(identifier, onByDefault, defaultPower, defaultTime, defaultPowerMode, defaultTimeMode)
		{
			_punctuate = GUISection.Get<Toggle>("Punctuate" + base.Identifier);
			((BaseField<bool>)(object)_punctuate).SetupSaving<bool>(defaultPunctuate, base.Identifier + "Punctuate").DependsOn<bool>((Toggle[])(object)new Toggle[1] { _enabled });
			_punctuateTime = GUISection.Get<SliderInt>("Punctuate" + base.Identifier + "-Slider");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<int>((INotifyValueChanged<int>)(object)((BaseField<int>)(object)_punctuateTime).SetupSaving<int>(defaultPunctuateTime).DependsOn<int>((Toggle[])(object)new Toggle[2] { _punctuate, _enabled }), (EventCallback<ChangeEvent<int>>)PunctuateSliderChangedEvent);
			_punctuateReminder = GUISection.Get<Label>("Punctuate" + base.Identifier + "-Reminder");
		}

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<bool>)(object)_punctuate).Load<bool>(preset);
			((BaseField<int>)(object)_punctuateTime).Load<int>(preset);
		}

		private void PunctuateSliderChangedEvent(ChangeEvent<int> evt)
		{
			((TextElement)_punctuateReminder).text = "Adds " + ((evt.newValue == 0) ? "no" : "some") + " punch. The first " + ((evt.newValue == 100) ? "1 second" : $"{(float)evt.newValue / 100f} seconds") + " after " + _punctuateReminderDescription + " " + ((evt.newValue == 100) ? "is" : "are") + " at max power.";
		}

		public void ActivatePunctuation(string? subID = null)
		{
			ActivatePunctuation(PunctuateTime, subID);
		}

		public override void Activate(float power, float time, string? subID = null)
		{
			Activate(power, time, Punctuate ? PunctuateTime : 0f, subID);
		}

		public override void Activate(float power, VibeSourceMode powerMode, float time, VibeSourceMode timeMode, string? subID = null)
		{
			Activate(power, powerMode, time, timeMode, Punctuate ? PunctuateTime : 0f, subID);
		}
	}
	internal class WeightedEvent : GUISection
	{
		protected readonly Toggle _enabled;

		protected readonly FloatField _weight;

		public bool Enabled
		{
			get
			{
				return ((BaseField<bool>)(object)_enabled).value;
			}
			set
			{
				((BaseField<bool>)(object)_enabled).value = value;
			}
		}

		public string EnabledText
		{
			get
			{
				return ((BaseBoolField)_enabled).text;
			}
			set
			{
				((BaseBoolField)_enabled).text = value;
			}
		}

		public float Weight
		{
			get
			{
				return ((BaseField<float>)(object)_weight).value;
			}
			set
			{
				((BaseField<float>)(object)_weight).value = value;
			}
		}

		public WeightedEvent(string identifier, float defaultWeight, Toggle enabledDependsOn, Toggle weightDependsOn, bool defaultOn = true)
			: this(identifier, defaultWeight, UQueryExtensions.Q<Toggle>((VisualElement)(object)GUISection.Get<GroupBox>(identifier), "Enabled", (string)null), UQueryExtensions.Q<FloatField>((VisualElement)(object)GUISection.Get<GroupBox>(identifier), "Weight", (string)null), enabledDependsOn, weightDependsOn, defaultOn)
		{
		}

		public WeightedEvent(string identifier, float defaultWeight, Toggle enabled, FloatField weight, Toggle enabledDependsOn, Toggle weightDependsOn, bool defaultOn)
			: base(identifier)
		{
			_enabled = enabled;
			_weight = weight;
			((BaseField<bool>)(object)_enabled).DependsOn<bool>((Toggle[])(object)new Toggle[1] { enabledDependsOn });
			((BaseField<float>)(object)_weight).DependsOn<float>((Toggle[])(object)new Toggle[3] { _enabled, weightDependsOn, enabledDependsOn });
			((BaseField<bool>)(object)_enabled).SetupSaving<bool>(defaultOn, base.Identifier);
			((BaseField<float>)(object)_weight).SetupSaving<float>(defaultWeight, base.Identifier + "Weight").SetupValueClamping(0f, 999f).SetupGreyout((float x) => x == 0f);
		}

		public void Load(Preset preset)
		{
			((BaseField<bool>)(object)_enabled).value = preset.Get<bool>(base.Identifier) ?? ((BaseField<bool>)(object)_enabled).value;
			((BaseField<float>)(object)_weight).value = preset.Get<float>(base.Identifier + "Weight") ?? ((BaseField<float>)(object)_weight).value;
		}

		public static WeightedEvent CreateWithUI(string identifier, float defaultWeight, bool defaultOn, VisualElement parent, VibeSource source, Toggle enabledDependsOn, Toggle weightDependsOn, bool cosyWithBelow = false, string? newCategoryLabel = null)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0090: 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_009c: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			if (newCategoryLabel != null)
			{
				Label val = new Label(newCategoryLabel);
				((VisualElement)val).AddToClassList("weighted-event-category");
				parent.Add((VisualElement)(object)val);
			}
			GroupBox val2 = new GroupBox(string.Empty);
			((VisualElement)val2).name = source.Identifier + identifier;
			((VisualElement)val2).AddToClassList("weighted-event");
			Toggle val3 = new Toggle(string.Empty)
			{
				text = identifier.FriendlyName()
			};
			((BaseField<bool>)val3).value = defaultOn;
			((VisualElement)val3).enabledSelf = false;
			Toggle val4 = val3;
			((VisualElement)val4).AddToClassList("h3");
			if (cosyWithBelow)
			{
				((VisualElement)val4).AddToClassList("weighted-event-cosy");
			}
			FloatField val5 = new FloatField(string.Empty, 1000);
			((TextInputBaseField<float>)val5).maxLength = 3;
			((BaseField<float>)val5).value = defaultWeight;
			((VisualElement)val5).enabledSelf = false;
			FloatField val6 = val5;
			((VisualElement)val6).AddToClassList("hEntry");
			((VisualElement)val6).AddToClassList("weighted-event-weight");
			((VisualElement)val2).Add((VisualElement)(object)val4);
			((VisualElement)val2).Add((VisualElement)(object)val6);
			parent.Add((VisualElement)(object)val2);
			return new WeightedEvent(identifier, defaultWeight, val4, val6, enabledDependsOn, weightDependsOn, defaultOn);
		}
	}
}
namespace ButtplugSong.GUI.VibeSettings.Presets
{
	internal interface IPresetLoadable
	{
		void SetToPreset(Preset preset);
	}
	public abstract class Preset
	{
		internal const string BasePresetString = "BasePreset";

		public static Dictionary<string, Preset> All = new Dictionary<string, Preset>();

		public string Identifier;

		public Dictionary<string, object> Settings;

		private static Dictionary<VisualElement, string> _settingsUIElements = new Dictionary<VisualElement, string>();

		private static HashSet<string> _seenSettingNames = new HashSet<string>();

		public static PresetDefault Default => PresetDefault.Instance;

		public static PresetCustom Custom => PresetCustom.Instance;

		public Preset? BasePreset
		{
			get
			{
				if (Settings.TryGetValue("BasePreset", out object value))
				{
					return PresetFromString(value.ToString());
				}
				return null;
			}
		}

		protected Preset(string identifier)
		{
			Identifier = identifier;
			Settings = GetSettings();
			All.Add(Identifier, this);
		}

		public void SetBasePreset(Preset other)
		{
			if (other == this)
			{
				Settings.Remove("BasePreset");
			}
			else
			{
				Settings["BasePreset"] = other.Identifier;
			}
		}

		protected abstract Dictionary<string, object> GetSettings();

		public virtual object? GetSettingObject(string settingName)
		{
			if (Settings.TryGetValue(settingName, out object value))
			{
				return value;
			}
			if (BasePreset != null)
			{
				return BasePreset.GetSettingObject(settingName);
			}
			return null;
		}

		public virtual bool TryGetSettingObject(string settingName, [NotNullWhen(true)] out object setting)
		{
			object settingObject = GetSettingObject(settingName);
			if (settingObject != null)
			{
				setting = settingObject;
				return true;
			}
			setting = null;
			return false;
		}

		public string? Get(string settingName)
		{
			if (TryGetSettingObject(settingName, out object setting))
			{
				return setting.ToString();
			}
			return null;
		}

		public virtual string? GetString(string settingName)
		{
			if (!TryGetSettingObject(settingName, out object setting))
			{
				return null;
			}
			return setting.ToString();
		}

		public bool TryGetString(string settingName, out string setting)
		{
			if (TryGetSettingObject(settingName, out object setting2))
			{
				setting = setting2.ToString();
				return true;
			}
			setting = string.Empty;
			return false;
		}

		public virtual T? Get<T>(string settingName) where T : struct
		{
			if (TryGetSettingObject(settingName, out object setting))
			{
				if (typeof(T).IsEnum)
				{
					return Enum.Parse<T>(setting.ToString());
				}
				return (T)Convert.ChangeType(setting, typeof(T));
			}
			return null;
		}

		public virtual bool TryGet<T>(string settingName, out T setting) where T : struct
		{
			if (TryGetSettingObject(settingName, out object setting2))
			{
				if (typeof(T).IsEnum)
				{
					setting = Enum.Parse<T>(setting2.ToString());
				}
				else
				{
					setting = (T)Convert.ChangeType(setting2, typeof(T));
				}
				return true;
			}
			setting = default(T);
			return false;
		}

		public static Preset? PresetFromString(string? presetName)
		{
			if (presetName == null)
			{
				return null;
			}
			if (All.TryGetValue(presetName, out Preset value))
			{
				return value;
			}
			if (presetName.Contains(' '))
			{
				return PresetFromString(presetName.Replace(" ", ""));
			}
			return null;
		}

		public static void BindElementToSetting(VisualElement element, string settingName)
		{
			if (_seenSettingNames.Contains(settingName))
			{
				throw new ArgumentException("Could not assign setting name " + settingName + " to " + element.name + " (" + element.typeName + ") as it is already assigned.");
			}
			_settingsUIElements[element] = settingName;
			_seenSettingNames.Add(settingName);
		}

		public static bool TryGetBoundSetting(VisualElement element, out string settingName)
		{
			return _settingsUIElements.TryGetValue(element, out settingName);
		}
	}
	internal class PresetComboMeter : Preset
	{
		public PresetComboMeter()
			: base("ComboMeter")
		{
		}

		protected override Dictionary<string, object> GetSettings()
		{
			return new Dictionary<string, object>();
		}
	}
	public class PresetCustom : Preset
	{
		private enum SavingStatus
		{
			Ready,
			Queued,
			Saving
		}

		private static PresetCustom? _instance;

		private bool saveQueued;

		private bool savingInProgress;

		public static PresetCustom Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new PresetCustom();
				}
				return _instance;
			}
		}

		private static string UserSettingsPath => Path.Combine(ButtplugSongPlugin.ModPath, "SavedSettings.txt");

		public PresetCustom()
			: base("Custom")
		{
			_instance = this;
			VibeManager.Instance.NeedsUpdate += Update;
		}

		protected override Dictionary<string, object> GetSettings()
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			if (File.Exists(UserSettingsPath))
			{
				string[] array = File.ReadAllLines(UserSettingsPath);
				for (int i = 0; i < array.Length; i++)
				{
					string[] array2 = array[i].Split('=');
					if (array2.Length >= 2)
					{
						dictionary.Add(array2[0], array2[1]);
					}
				}
			}
			if (!dictionary.ContainsKey("BasePreset"))
			{
				dictionary["BasePreset"] = Preset.Default.Identifier;
			}
			return dictionary;
		}

		internal void SaveSettingChange<T>(string settingName, T newValue) where T : struct
		{
			object value;
			object obj = (Settings.TryGetValue(settingName, out value) ? value : null);
			Settings[settingName] = newValue;
			if (base.BasePreset != null && base.BasePreset.TryGet<T>(settingName, out var setting) && setting.Equals(newValue))
			{
				Settings.Remove(settingName);
				if (obj != null)
				{
					saveQueued = true;
				}
			}
			else if (obj == null || !newValue.Equals(obj))
			{
				saveQueued = true;
			}
		}

		internal void SaveSettingChange(string settingName, string newValue)
		{
			object value;
			object obj = (Settings.TryGetValue(settingName, out value) ? value : null);
			Settings[settingName] = newValue;
			if (base.BasePreset != null && base.BasePreset.TryGetString(settingName, out string setting) && setting.Equals(newValue))
			{
				Settings.Remove(settingName);
				if (obj != null)
				{
					saveQueued = true;
				}
			}
			else if (obj == null || !newValue.Equals(obj))
			{
				saveQueued = true;
			}
		}

		internal void Update(float realTime, float timerTime)
		{
			if (!savingInProgress && saveQueued)
			{
				savingInProgress = true;
				Task.Run(delegate
				{
					SaveUserFile(Settings);
				});
			}
		}

		internal async void SaveUserFile(Dictionary<string, object> settings)
		{
			File.WriteAllLines(UserSettingsPath, settings.Select<KeyValuePair<string, object>, string>((KeyValuePair<string, object> x) => $"{x.Key}={x.Value}"));
			saveQueued = false;
			savingInProgress = false;
		}
	}
	public class PresetDefault : Preset
	{
		private static PresetDefault? _instance;

		public static PresetDefault Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new PresetDefault();
				}
				return _instance;
			}
		}

		public static void SaveDefaultSetting(string settingName, object value)
		{
			Instance.Settings.Add(settingName, value);
		}

		public PresetDefault()
			: base("DefaultSettings")
		{
			_instance = this;
		}

		protected override Dictionary<string, object> GetSettings()
		{
			return new Dictionary<string, object>();
		}
	}
	internal class PresetSettings : GUISection, IPresetLoadable
	{
		public Preset[] Presets;

		private readonly DropdownField _presetSelector;

		private readonly Label _presetDescription;

		private readonly Button _setToPreset;

		public PresetSettings()
			: base("Presets")
		{
			Presets = new Preset[1] { Preset.Default };
			_presetSelector = GUISection.Get<DropdownField>("PresetSelector");
			_presetDescription = GUISection.Get<Label>("PresetDescription");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)_presetSelector.PopulateDropdown(Presets.Select((Preset x) => x.Identifier.FriendlyName()).ToArray()), (EventCallback<ChangeEvent<string>>)DropdownChanged);
			_setToPreset = GUISection.Get<Button>("SetToPreset");
			_setToPreset.clicked += SetToPreset;
			((VisualElement)_presetDescription).RemoveFromClassList("h1");
			((VisualElement)_presetDescription).RemoveFromClassList("red-text");
		}

		private void SetToPreset()
		{
			Preset preset = Preset.PresetFromString(((BaseField<string>)(object)_presetSelector).value);
			if (preset != null)
			{
				Preset.Custom.SetBasePreset(preset);
				GUISection.Vibe.UI.SetToPreset(preset);
			}
		}

		public void SetToPreset(Preset preset)
		{
			if (preset == Preset.Custom)
			{
				((BaseField<string>)(object)_presetSelector).value = preset.BasePreset?.Identifier.FriendlyName() ?? "Custom";
			}
			else
			{
				((BaseField<string>)(object)_presetSelector).value = preset.Identifier.FriendlyName();
			}
		}

		private void DropdownChanged(ChangeEvent<string> evt)
		{
			Label presetDescription = _presetDescription;
			string text = ((!(evt.newValue == "Default Settings")) ? ("Description for preset " + evt.newValue + " not defined") : "The default experience. Vibes as a punishment for making mistakes, such as taking damage.");
			((TextElement)presetDescription).text = text;
		}
	}
}
namespace ButtplugSong.GUI.VibeSettings.LimitSettings
{
	internal class MinimumBelowFullHealth : MinimumWithScale
	{
		private static PlayerData playerData => PlayerData.instance;

		public MinimumBelowFullHealth()
			: base("BelowFullHealth", enabledByDefault: false, 4f, scalesByDefault: true)
		{
		}

		public override bool IsRelevant()
		{
			if (playerData != null)
			{
				return GetScale() > 0f;
			}
			return false;
		}

		protected override float GetScale()
		{
			return playerData.maxHealth - playerData.health;
		}
	}
	internal class MinimumCursed : MinimumBase
	{
		public MinimumCursed()
			: base("Cursed", enabledByDefault: false, 30f)
		{
		}

		public override bool IsRelevant()
		{
			return ((ToolBase)Gameplay.CursedCrest).IsEquipped;
		}
	}
	internal class MinimumFreezing : MinimumWithScale
	{
		public MinimumFreezing()
			: base("Freezing", enabledByDefault: false, 25f, scalesByDefault: true)
		{
		}

		public override bool IsRelevant()
		{
			if ((Object)(object)MinimumBase.hero != (Object)null && MinimumBase.hero.isInFrostRegion && PlayerData.HasInstance)
			{
				return !PlayerData.instance.hasDoubleJump;
			}
			return false;
		}

		protected override float GetScale()
		{
			return MinimumBase.hero.frostAmount;
		}
	}
	internal class MinimumMaggoted : MinimumBase
	{
		public MinimumMaggoted()
			: base("Maggoted", enabledByDefault: true, 20f)
		{
		}

		public override bool IsRelevant()
		{
			if ((Object)(object)MinimumBase.hero != (Object)null)
			{
				return MinimumBase.hero.cState.isMaggoted;
			}
			return false;
		}
	}
	internal class MinimumNaked : MinimumBase
	{
		public MinimumNaked()
			: base("Naked", enabledByDefault: true, 10f)
		{
		}

		public override bool IsRelevant()
		{
			if ((Object)(object)MinimumBase.hero != (Object)null)
			{
				return MinimumBase.hero.Config.ForceBareInventory;
			}
			return false;
		}
	}
	internal class MinimumSwimming : MinimumBase
	{
		public MinimumSwimming()
			: base("Swimming", enabledByDefault: false, 5f)
		{
		}

		public override bool IsRelevant()
		{
			if ((Object)(object)MinimumBase.hero != (Object)null)
			{
				return MinimumBase.hero.cState.swimming;
			}
			return false;
		}
	}
	internal class MinimumTouchingGround : MinimumBase
	{
		public MinimumTouchingGround()
			: base("TouchingGround", enabledByDefault: false, 5f)
		{
		}

		public override bool IsRelevant()
		{
			if ((Object)(object)MinimumBase.hero != (Object)null && MinimumBase.hero.isGameplayScene)
			{
				return MinimumBase.hero.CheckTouchingGround();
			}
			return false;
		}
	}
	internal class MinimumSprinting : MinimumBase
	{
		public MinimumSprinting()
			: base("Sprinting", enabledByDefault: false, 5f)
		{
		}

		public override bool IsRelevant()
		{
			if ((Object)(object)MinimumBase.hero != (Object)null)
			{
				if (!MinimumBase.hero.cState.isSprinting && !MinimumBase.hero.cState.isBackSprinting && !MinimumBase.hero.cState.isBackScuttling)
				{
					return MinimumBase.hero.cState.dashing;
				}
				return true;
			}
			return false;
		}
	}
	internal class MinimumSittingAtBench : MinimumBase
	{
		public MinimumSittingAtBench()
			: base("SittingAtBench", enabledByDefault: false, 10f)
		{
		}

		public override bool IsRelevant()
		{
			if (PlayerData.HasInstance)
			{
				return PlayerData.instance.atBench;
			}
			return false;
		}
	}
	internal class MinimumSoaring : MinimumBase
	{
		public MinimumSoaring()
			: base("Soaring", enabledByDefault: true, 10f)
		{
		}

		public override bool IsRelevant()
		{
			if ((Object)(object)MinimumBase.hero != (Object)null)
			{
				return MinimumBase.hero.cState.superDashing;
			}
			return false;
		}
	}
	internal class LimitsSettings : GUISection, IPresetLoadable
	{
		protected readonly FloatField _masterMaxPower;

		protected readonly FloatField _masterMaxTimer;

		internal readonly List<MinimumBase> Minimums;

		internal readonly Toggle _minimumsEnabled;

		protected readonly Toggle _minimumsStack;

		protected readonly Label _minimumsStackLabel;

		public float MasterMaxPower
		{
			get
			{
				return ((BaseField<float>)(object)_masterMaxPower).value / 100f;
			}
			set
			{
				((BaseField<float>)(object)_masterMaxPower).value = value * 100f;
			}
		}

		public float MasterMaxTimer
		{
			get
			{
				return ((BaseField<float>)(object)_masterMaxTimer).value;
			}
			set
			{
				((BaseField<float>)(object)_masterMaxTimer).value = value;
			}
		}

		public LimitsSettings()
			: base("Limits")
		{
			MinimumBase.limitsSettings = this;
			_masterMaxPower = GUISection.Get<FloatField>("MasterMaxPower");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<float>((INotifyValueChanged<float>)(object)((BaseField<float>)(object)_masterMaxPower).SetupSaving<float>(100f).SetupValueClamping(0f, 100f).SetupGreyout((float x) => x == 100f), (EventCallback<ChangeEvent<float>>)MasterMaxPowerChanged);
			_masterMaxTimer = GUISection.Get<FloatField>("MasterMaxTimer");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<float>((INotifyValueChanged<float>)(object)((BaseField<float>)(object)_masterMaxTimer).SetupSaving<float>(300f).SetupValueClamping(0f, 5999f), (EventCallback<ChangeEvent<float>>)MasterMaxTimerChanged);
			_minimumsEnabled = GUISection.Get<Toggle>("EnableMinimums");
			((BaseField<bool>)(object)_minimumsEnabled).SetupSaving<bool>(true, "MinimumsEnabled");
			_minimumsStack = GUISection.Get<Toggle>("MinimumsStack");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)_minimumsStack).SetupSaving<bool>(false).DependsOn<bool>((Toggle[])(object)new Toggle[1] { _minimumsEnabled }), (EventCallback<ChangeEvent<bool>>)MinimumsStackChanged);
			_minimumsStackLabel = GUISection.Get<Label>("MinimumsStackLabel");
			Minimums = new List<MinimumBase>(13)
			{
				new MinimumDefault(),
				new MinimumBelowFullHealth(),
				new MinimumTouchingGround(),
				new MinimumNotMoving(),
				new MinimumSwimming(),
				new MinimumSprinting(),
				new MinimumSittingAtBench(),
				new MinimumSoaring(),
				new MinimumNaked(),
				new MinimumCourier(),
				new MinimumMaggoted(),
				new MinimumFreezing(),
				new MinimumCursed()
			};
			GUISection.Vibe.NeedsUpdate += Update;
		}

		public void SetToPreset(Preset preset)
		{
			((BaseField<float>)(object)_masterMaxPower).Load<float>(preset);
			((BaseField<float>)(object)_masterMaxTimer).Load<float>(preset);
			((BaseField<bool>)(object)_minimumsEnabled).Load<bool>(preset);
			((BaseField<bool>)(object)_minimumsStack).Load<bool>(preset);
			foreach (MinimumBase minimum in Minimums)
			{
				minimum.SetToPreset(preset);
			}
		}

		private void MinimumsStackChanged(ChangeEvent<bool> evt)
		{
			((TextElement)_minimumsStackLabel).text = (evt.newValue ? "While multiple minimums are active, their minimum values are combined additively." : "While multiple minimums are active, the greatest minimum among them is used.");
		}

		private void Update(float realTime, float timerTime)
		{
			float minPower = GetMinPower();
			if (minPower != GUISection.Vibe.Logic.MinPower)
			{
				GUISection.Vibe.Logic.MinPower = minPower;
			}
		}

		private float GetMinPower()
		{
			return (((BaseField<bool>)(object)_minimumsStack).value ? Minimums.Sum((MinimumBase x) => x.Minimum) : Minimums.Max((MinimumBase x) => x.Minimum)).Clamp(0f, GUISection.Vibe.Logic.MaxPower);
		}

		private void MasterMaxPowerChanged(ChangeEvent<float> evt)
		{
			GUISection.Vibe.Logic.MaxPower = MasterMaxPower;
		}

		private void MasterMaxTimerChanged(ChangeEvent<float> evt)
		{
			GUISection.Vibe.Logic.MaxTimer = MasterMaxTimer;
		}
	}
	internal abstract class MinimumBase : GUISection, IPresetLoadable
	{
		internal static LimitsSettings? limitsSettings;

		protected readonly Toggle _enabled;

		protected readonly FloatField _minAmount;

		protected VisualElement LocalRoot;

		protected static HeroController hero => HeroController.instance;

		internal static Toggle _minimumsEnabled => limitsSettings?._minimumsEnabled ?? throw new NullReferenceException("Set limitsSettings first!");

		public float MinAmount
		{
			get
			{
				return ((BaseField<float>)(object)_minAmount).value / 100f;
			}
			set
			{
				((BaseField<float>)(object)_minAmount).value = value.Clamp(0f, 1f) * 100f;
			}
		}

		public float MinimumWhenActive => Mathf.Min(GUISection.Vibe.Logic.MaxPower, MinAmount * _GetScaleEnabled());

		public bool Active
		{
			get
			{
				if (((BaseField<bool>)(object)_enabled).value)
				{
					return IsRelevant();
				}
				return false;
			}
		}

		public float Minimum
		{
			get
			{
				if (!Active)
				{
					return 0f;
				}
				return MinimumWhenActive;
			}
		}

		public MinimumBase(string identifier, bool enabledByDefault, float defaultAmount)
			: base(identifier)
		{
			LocalRoot = (VisualElement)(object)GUISection.Get<GroupBox>("Minimum" + base.Identifier);
			_enabled = UQueryExtensions.Q<Toggle>(LocalRoot, "EnableToggle", (string)null);
			((BaseField<bool>)(object)_enabled).SetupSaving<bool>(enabledByDefault, "Min" + base.Identifier).DependsOn<bool>((Toggle[])(object)new Toggle[1] { _minimumsEnabled });
			_minAmount = UQueryExtensions.Q<FloatField>(LocalRoot, "Amount", (string)null);
			((BaseField<float>)(object)_minAmount).SetupSaving<float>(defaultAmount, "Min" + base.Identifier + "Amount").DependsOn<float>((Toggle[])(object)new Toggle[2] { _minimumsEnabled, _enabled }).SetupValueClamping(0f, 100f)
				.SetupGreyout((float x) => x == 0f);
		}

		public abstract bool IsRelevant();

		protected virtual float _GetScaleEnabled()
		{
			return 1f;
		}

		public virtual void SetToPreset(Preset preset)
		{
			((BaseField<bool>)(object)_enabled).Load<bool>(preset);
			((BaseField<float>)(object)_minAmount).Load<float>(preset);
		}
	}
	internal abstract class MinimumWithScale : MinimumBase
	{
		protected readonly Toggle _scales;

		public MinimumWithScale(string identifier, bool enabledByDefault, float defaultAmount, bool scalesByDefault)
			: base(identifier, enabledByDefault, defaultAmount)
		{
			_scales = UQueryExtensions.Q<Toggle>(LocalRoot, "Scale", (string)null);
			((BaseField<bool>)(object)_scales).SetupSaving<bool>(scalesByDefault, "Min" + base.Identifier + "Scales").DependsOn<bool>((Toggle[])(object)new Toggle[1] { _enabled });
		}

		protected override float _GetScaleEnabled()
		{
			if (!((BaseField<bool>)(object)_scales).value)
			{
				return 1f;
			}
			return GetScale();
		}

		protected abstract float GetScale();

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<bool>)(object)_scales).Load<bool>(preset);
		}
	}
	internal class MinimumCourier : MinimumBase
	{
		private readonly Toggle _minCourierPunctuate;

		private readonly FloatField _minCourierPunctuateTime;

		public MinimumCourier()
			: base("Courier", enabledByDefault: true, 15f)
		{
			ModHooks.OnCourierBreakItemHook += ItemBroken;
			_minCourierPunctuate = GUISection.Get<Toggle>("MinCourierPunctuate");
			_minCourierPunctuateTime = GUISection.Get<FloatField>("MinCourierPunctuateTime");
			((BaseField<bool>)(object)_minCourierPunctuate).SetupSaving<bool>(true).DependsOn<bool>((Toggle[])(object)new Toggle[2]
			{
				_enabled,
				MinimumBase._minimumsEnabled
			});
			((BaseField<float>)(object)_minCourierPunctuateTime).SetupSaving<float>(1.7f).SetupValueClamping(0f, 999f).SetupGreyout((float x) => x == 0f)
				.DependsOn<float>((Toggle[])(object)new Toggle[3]
				{
					_enabled,
					_minCourierPunctuate,
					MinimumBase._minimumsEnabled
				});
		}

		public override bool IsRelevant()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			foreach (FullQuestBase activeQuest in QuestManager.GetActiveQuests())
			{
				foreach (var targetsAndCounter in activeQuest.TargetsAndCounters)
				{
					if (targetsAndCounter.Item1.Counter is DeliveryQuestItem)
					{
						return true;
					}
				}
			}
			return false;
		}

		private void ItemBroken(DeliveryQuestItem item)
		{
			if (((BaseField<bool>)(object)_enabled).value && ((BaseField<bool>)(object)_minCourierPunctuate).value && ((BaseField<float>)(object)_minCourierPunctuateTime).value > 0f)
			{
				GUISection.Vibe.Logic.VibeSourceActivation("Courier Broken Source", 0f, "+", 0f, "+", ((BaseField<float>)(object)_minCourierPunctuateTime).value);
			}
		}

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<bool>)(object)_minCourierPunctuate).Load<bool>(preset);
			((BaseField<float>)(object)_minCourierPunctuateTime).Load<float>(preset);
		}
	}
	internal class MinimumDefault : MinimumBase
	{
		public Label _reminderText;

		[CompilerGenerated]
		private BuzzOnDeath? <_buzzOnDeath>k__BackingField;

		private BuzzOnDeath? _buzzOnDeath
		{
			get
			{
				if (<_buzzOnDeath>k__BackingField == null)
				{
					<_buzzOnDeath>k__BackingField = (BuzzOnDeath)GUISection.Vibe.UI.Sources.FirstOrDefault((VibeSource x) => x is BuzzOnDeath);
				}
				return <_buzzOnDeath>k__BackingField;
			}
		}

		public MinimumDefault()
			: base("Default", enabledByDefault: false, 0f)
		{
			_reminderText = GUISection.Get<Label>("MinimumDefaultReminder");
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)_enabled, (EventCallback<ChangeEvent<bool>>)UpdateReminderText<bool>);
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)MinimumBase._minimumsEnabled, (EventCallback<ChangeEvent<bool>>)UpdateReminderText<bool>);
		}

		public override bool IsRelevant()
		{
			return true;
		}

		public void UpdateReminderText<T>(ChangeEvent<T> evt)
		{
			UpdateReminderText();
		}

		public void UpdateReminderText()
		{
			_reminderText.SetClassListIf<Label>("hide", (Func<Label, bool>)((Label x) => _buzzOnDeath == null || !_buzzOnDeath.RaiseMinimum || (((BaseField<bool>)(object)MinimumBase._minimumsEnabled).value && ((BaseField<bool>)(object)_enabled).value)));
		}

		internal void RaiseMinimumDeath(float raiseAmount)
		{
			((BaseField<bool>)(object)MinimumBase._minimumsEnabled).value = true;
			((BaseField<bool>)(object)_enabled).value = true;
			base.MinAmount += raiseAmount;
			UpdateReminderText();
		}
	}
	internal class MinimumNotMoving : MinimumBase
	{
		private readonly FloatField _minNotMovingDelay;

		public float NotMovingTime;

		public float MinNotMovingDelay
		{
			get
			{
				return ((BaseField<float>)(object)_minNotMovingDelay).value;
			}
			set
			{
				((BaseField<float>)(object)_minNotMovingDelay).value = value;
			}
		}

		public MinimumNotMoving()
			: base("NotMoving", enabledByDefault: false, 10f)
		{
			GUISection.Vibe.NeedsUpdate += Update;
			_minNotMovingDelay = GUISection.Get<FloatField>("MinNotMovingDelay");
			((BaseField<float>)(object)_minNotMovingDelay).SetupSaving<float>(1f).SetupValueClamping(0f, 999f).SetupGreyout((float x) => x == 0f)
				.DependsOn<float>((Toggle[])(object)new Toggle[2]
				{
					_enabled,
					MinimumBase._minimumsEnabled
				});
		}

		private void Update(float realTime, float timerTime)
		{
			if (Moving())
			{
				NotMovingTime = 0f;
			}
			else
			{
				NotMovingTime += realTime;
			}
		}

		public override bool IsRelevant()
		{
			return NotMovingTime > MinNotMovingDelay;
		}

		public static bool Moving()
		{
			if ((Object)(object)MinimumBase.hero != (Object)null)
			{
				return ((Vector2)(ref MinimumBase.hero.current_velocity)).magnitude > float.Epsilon;
			}
			return false;
		}

		public override void SetToPreset(Preset preset)
		{
			base.SetToPreset(preset);
			((BaseField<float>)(object)_minNotMovingDelay).Load<float>(preset);
		}
	}
}
namespace ButtplugSong.GUI.Network
{
	internal class DeviceUI : GUISection
	{
		private VisualElement root;

		private readonly NetworkSettings _networkSettings;

		internal readonly DeviceInfo DeviceInfo;

		internal readonly Toggle _enabled;

		private readonly Label _batteryLabel;

		private readonly Dictionary<FeatureType, FeatureUI> _features;

		private readonly Button _testButton;

		private readonly List<string> batteryColourStyles = new List<string>(5) { "red-text", "orange-text", "yellow-text", "grellow-text", "green-text" };

		private int workingBatterySensor = 5;

		private float timeSinceLastBatteryUpdate = 55f;

		public DeviceUI(ButtplugDevice device, NetworkSettings parent)
			: base("Device")
		{
			DeviceInfo = new DeviceInfo(device, GUISection.Log);
			_networkSettings = parent;
			root = (VisualElement)(object)GUISection.Vibe.UI.Device.Instantiate();
			_enabled = UQueryExtensions.Q<Toggle>(root, "DeviceEnabled", (string)null);
			((BaseBoolField)_enabled).text = DeviceInfo.Name;
			((BaseField<bool>)(object)_enabled).value = true;
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)_enabled, (EventCallback<ChangeEvent<bool>>)EnabledToggleChanged);
			Label obj = UQueryExtensions.Q<Label>(root, "FullNameLabel", (string)null);
			((TextElement)obj).text = "Full name: " + DeviceInfo.Name;
			obj.SetClassListIf<Label>("hide", (Func<Label, bool>)((Label x) => DeviceInfo.Name.Length <= 20));
			_batteryLabel = UQueryExtensions.Q<Label>(root, "BatteryPercentage", (string)null);
			((TextElement)UQueryExtensions.Q<Label>(root, "IDLabel", (string)null)).text = $"ID: {DeviceInfo.Id}";
			_features = new Dictionary<FeatureType, FeatureUI>();
			foreach (KeyValuePair<FeatureType, DeviceFeature> feature in DeviceInfo.Features)
			{
				_features.Add(feature.Key, GetFeatureUI(feature.Key, feature.Value));
				FeatureUI GetFeatureUI(FeatureType key, DeviceFeature feature)
				{
					return key switch
					{
						FeatureType.Rotate => new RotateFeatureUI(this, root, feature), 
						FeatureType.Temperature => new TemperatureFeatureUI(this, root, feature), 
						FeatureType.Position => new PositionFeatureUI(this, root, feature), 
						_ => new FeatureUI(this, root, key, feature), 
					};
				}
			}
			_testButton = UQueryExtensions.Q<Button>(root, "TestDeviceButton", (string)null);
			_testButton.clicked += TestButtonClicked;
			parent.AddToListView(root);
		}

		private void TestButtonClicked()
		{
			DeviceInfo.Test(0.25f, 0.5f);
		}

		private void EnabledToggleChanged(ChangeEvent<bool> evt)
		{
			DeviceInfo.IsEnabled = evt.newValue;
			((VisualElement)_testButton).enabledSelf = evt.newValue;
			if (!evt.newValue)
			{
				DeviceInfo.Device.SendStopCmd();
			}
		}

		public void Update(float realTime)
		{
			DeviceInfo.Update(realTime);
			timeSinceLastBatteryUpdate += realTime;
			if (timeSinceLastBatteryUpdate > 60f)
			{
				timeSinceLastBatteryUpdate -= 60f;
				Task.Run((Func<Task?>)UpdateBatteryDisplay);
			}
		}

		private async Task UpdateBatteryDisplay()
		{
			if (workingBatterySensor > 0)
			{
				workingBatterySensor--;
				if (await DeviceInfo.TryRefreshBattery() && DeviceInfo.Battery.HasValue)
				{
					workingBatterySensor = 10;
					((TextElement)_batteryLabel).text = $"Battery: {DeviceInfo.Battery:0}%";
					SetBatteryColour(DeviceInfo.Battery.Value);
				}
				else
				{
					((TextElement)_batteryLabel).text = "Battery unknown";
					SetBatteryColour(0.0);
					timeSinceLastBatteryUpdate = 50f;
				}
			}
			void SetBatteryColour(double battery)
			{
				foreach (string batteryColourStyle in batteryColourStyles)
				{
					((VisualElement)_batteryLabel).RemoveFromClassList(batteryColourStyle);
				}
				string text = ((battery > 85.0) ? "green-text" : ((battery > 50.0) ? "grellow-text" : ((battery > 15.0) ? "yellow-text" : ((!(battery > 0.0)) ? "red-text" : "orange-text"))));
				string text2 = text;
				((VisualElement)_batteryLabel).AddToClassList(text2);
			}
		}

		internal void Unload()
		{
			DeviceInfo.Unload();
			root.parent.Remove(root);
		}
	}
	internal class FeatureUI : GUISection
	{
		protected readonly Toggle featureToggle;

		protected DeviceUI parent;

		protected bool FeatureHidden;

		public FeatureUI(DeviceUI deviceUI, VisualElement localRoot, FeatureType featureType, DeviceFeature feature)
		{
			DeviceFeature feature2 = feature;
			base..ctor(featureType.ToString());
			parent = deviceUI;
			featureToggle = UQueryExtensions.Q<Toggle>(localRoot, base.Identifier + "Feature", (string)null);
			FeatureHidden = featureToggle == null || !feature2.IsSupported || !DeviceFeature.Implemented.Contains(featureType);
			if (FeatureHidden)
			{
				feature2.IsEnabled = false;
				Toggle obj = featureToggle;
				if (obj != null)
				{
					((VisualElement)obj).AddToClassList("hide");
				}
				return;
			}
			Label val = UQueryExtensions.Q<Label>(localRoot, base.Identifier + "StepCount", (string)null);
			if (!feature2.StepCount.HasValue)
			{
				if (val != null)
				{
					((VisualElement)val).AddToClassList("hide");
				}
			}
			else if (val != null)
			{
				if (feature2.StepCount < 1000)
				{
					((TextElement)val).text = feature2.StepCount.Value.ToString();
				}
				else
				{
					((TextElement)val).text = $"{feature2.StepCount.Value / 1000:f1}K";
				}
			}
			feature2.IsEnabled = ((BaseField<bool>)(object)featureToggle).value;
			INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)((BaseField<bool>)(object)featureToggle).DependsOn<bool>((Toggle[])(object)new Toggle[1] { parent._enabled }), (EventCallback<ChangeEvent<bool>>)delegate(ChangeEvent<bool> evt)
			{
				feature2.IsEnabled = evt.newValue;
			});
		}
	}
	internal class RotateFeatureUI : FeatureUI
	{
		protected readonly DropdownField dropdown;

		public RotateFeatureUI(DeviceUI deviceUI, VisualElement localRoot, DeviceFeature feature)
			: base(deviceUI, localRoot, FeatureType.Rotate, feature)
		{
			dropdown = UQueryExtensions.Q<DropdownField>(localRoot, "RotateFeatureDirection", (string)null);
			if (FeatureHidden)
			{
				DropdownField obj = dropdown;
				if (obj != null)
				{
					((VisualElement)obj).AddToClassList("hide");
				}
			}
			else
			{
				INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)((BaseField<string>)(object)dropdown).DependsOn<string>((Toggle[])(object)new Toggle[2] { parent._enabled, featureToggle }), (EventCallback<ChangeEvent<string>>)DropdownChanged);
			}
		}

		private void DropdownChanged(ChangeEvent<string> evt)
		{
			parent.DeviceInfo.AlternateRotation = evt.newValue == "Alternate";
			parent.DeviceInfo.RotateClockwise = evt.newValue == "Clockwise";
		}
	}
	internal class TemperatureFeatureUI : FeatureUI
	{
		protected readonly FloatField neutralTemp;

		public TemperatureFeatureUI(DeviceUI deviceUI, VisualElement localRoot, DeviceFeature feature)
			: base(deviceUI, localRoot, FeatureType.Temperature, feature)
		{
			neutralTemp = UQueryExtensions.Q<FloatField>(localRoot, "TemperatureFeatureNeutral", (string)null);
			if (FeatureHidden)
			{
				FloatField obj = neutralTemp;
				if (obj != null)
				{
					((VisualElement)obj).AddToClassList("hide");
				}
			}
			else
			{
				INotifyValueChangedExtensions.RegisterValueChangedCallback<float>((INotifyValueChanged<float>)(object)((BaseField<float>)(object)neutralTemp).DependsOn<float>((Toggle[])(object)new Toggle[2] { parent._enabled, featureToggle }).SetupValueClamping(0f, 100f), (EventCallback<ChangeEvent<float>>)NeutralTempChanged);
			}
		}

		private void NeutralTempChanged(ChangeEvent<float> evt)
		{
			parent.DeviceInfo.NeutralTemperature = evt.newValue / 100f;
		}
	}
	internal class PositionFeatureUI : FeatureUI
	{
		protected readonly FloatField moveDuration;

		public PositionFeatureUI(DeviceUI deviceUI, VisualElement localRoot, DeviceFeature feature)
			: base(deviceUI, localRoot, FeatureType.Position, feature)
		{
			moveDuration = UQueryExtensions.Q<FloatField>(localRoot, "PositionFeatureDuration", (string)null);
			if (FeatureHidden)
			{
				FloatField obj = moveDuration;
				if (obj != null)
				{
					((VisualElement)obj).AddToClassList("hide");
				}
			}
			else
			{
				INotifyValueChangedExtensions.RegisterValueChangedCallback<float>((INotifyValueChanged<float>)(object)((BaseField<float>)(object)moveDuration).DependsOn<float>((Toggle[])(object)new Toggle[2] { parent._enabled, featureToggle }).SetupValueClamping(0.05f, 60f), (EventCallback<ChangeEvent<float>>)PositionMoveDurationChanged);
			}
		}

		private void PositionMoveDurationChanged(ChangeEvent<float> evt)
		{
			parent.DeviceInfo.MoveDuration = evt.newValue;
		}
	}
	internal class NetworkSettings : GUISection, IPresetLoadable
	{
		private static NetworkSettings? instance = null;

		private static string defaultServerAddress = "localhost";

		private static int defaultPort = 12345;

		private static int defaultRetryAttempts = 5;

		private static float defaultUpdateFrequency = 0.125f;

		protected readonly Button _reconnectButton;

		protected readonly TextField _serverAddress;

		protected readonly IntegerField _port;

		protected readonly IntegerField _retryAttempts;

		protected readonly FloatField _updateFrequency;

		protected readonly Label _debuggingHelpLabel;

		private Dictionary<ButtplugDevice, DeviceUI> Devices = new Dictionary<ButtplugDevice, DeviceUI>();

		protected static PlugManager Plug => GUISection.Vibe.plug;

		public static string ServerAddress
		{
			get
			{
				if (instance == null || instance._serverAddress == null || string.IsNullOrWhiteSpace(((TextInputBaseField<string>)(object)instance._serverAddress).text))
				{
					return defaultServerAddress;
				}
				return ((TextInputBaseField<string>)(object)instance._serverAddress).text;
			}
		}

		public static int Port
		{
			get
			{
				if (instance == null || instance._port == null)
				{
					return defaultPort;
				}
				return ((BaseField<int>)(object)instance._port).value;
			}
		}

		public static int RetryAttempts
		{
			get
			{
				if (instance == null || instance._retryAttempts == null)
				{
					return defaultRetryAttempts;
				}
				return ((BaseField<int>)(object)instance._retryAttempts).value;
			}
		}

		public static float UpdateFrequency
		{
			get
			{
				if (instance == null || instance._updateFrequency == null)
				{
					return defaultUpdateFrequency;
				}
				return ((BaseField<float>)(object)instance._updateFrequency).value;
			}
		}

		public NetworkSettings()
			: base("Network")
		{
			instance = this;
			_reconnectButton = GUISection.Get<Button>("ReconnectButton");
			_serverAddress = GUISection.Get<TextField>("ServerAddress");
			((BaseField<string>)(object)_serverAddress).SetupSaving();
			_port = GUISection.Get<IntegerField>("ServerPort");
			((BaseField<int>)(object)_port).SetupSaving<int>().SetupValueClamping(0, 65535);
			_retryAttempts = GUISection.Get<IntegerField>("RetryAttempts");
			((BaseField<int>)(object)_retryAttempts).SetupSaving<int>().SetupValueClamping(1, 999);
			_updateFrequency = GUISection.Get<FloatField>("UpdateFrequency");
			((BaseField<float>)(object)_updateFrequency).SetupSaving<float>().SetupValueClamping(0.017f, 60f);
			_debuggingHelpLabel = GUISection.Get<Label>("DebuggingHelp");
			_reconnectButton.clicked += GUISection.Vibe.ReconnectPlug;
			GUISection.Vibe.PlugReconnectEstablished += RefreshDeviceList;
			PlugManager.DeviceConnected += AddDevice;
			PlugManager.DeviceDisconnected += RemoveDevice;
			PlugManager.DisconnectedFromServer += RemoveAllDevices;
			GUISection.Vibe.NeedsUpdate += Update;
		}

		public void SetToPreset(Preset preset)
		{
			((BaseField<string>)(object)_serverAddress).Load(preset, friendlyName: false);
			((BaseField<int>)(object)_port).Load<int>(preset);
			((BaseField<int>)(object)_retryAttempts).Load<int>(preset);
		}

		private void Update(float realTime, float timerTime)
		{
			DeviceUI[] array = Devices.Values.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				array[i].Update(realTime);
			}
		}

		public void AddDevice(ButtplugDevice device)
		{
			if (device != null && !Devices.ContainsKey(device))
			{
				Devices[device] = new DeviceUI(device, this);
				((VisualElement)_debuggingHelpLabel).AddToClassList("hide");
			}
		}

		public void RemoveDevice(ButtplugDevice device)
		{
			if (device != null && Devices.TryGetValue(device, out DeviceUI value))
			{
				value.Unload();
				Devices.Remove(device);
				if (Devices.Count == 0)
				{
					((VisualElement)_debuggingHelpLabel).RemoveFromClassList("hide");
				}
			}
		}

		public void RemoveAllDevices()
		{
			foreach (DeviceUI value in Devices.Values)
			{
				value.Unload();
			}
			Devices.Clear();
			((VisualElement)_debuggingHelpLabel).RemoveFromClassList("hide");
		}

		public void RefreshDeviceList()
		{
			RemoveAllDevices();
			if (Plug == null)
			{
				return;
			}
			foreach (ButtplugDevice device in Plug.GetDevices())
			{
				AddDevice(device);
			}
		}

		internal void AddToListView(VisualElement element)
		{
			((VisualElement)_debuggingHelpLabel).parent.Add(element);
		}
	}
}
namespace ButtplugSong.GUI.CustomUI
{
	public class CyclingButton<T> : GUISection where T : struct, Enum
	{
		public readonly Button button;

		public Func<T, string> ModeString;

		public Action? clicked;

		public T currentMode { get; private set; }

		public T defaultMode { get; private set; }

		public CyclingButton(string buttonIdentifier, T defaultMode)
			: this(buttonIdentifier, defaultMode, (Func<T, string>)((T x) => x.ToString()))
		{
		}

		public CyclingButton(string buttonIdentifier, T defaultMode, Func<T, string> textSelector)
			: base(buttonIdentifier)
		{
			ModeString = textSelector;
			button = GUISection.Get<Button>(base.Identifier);
			button.clicked += ButtonClicked;
			SetDefault(defaultMode);
			ResetToDefault();
		}

		public void ResetToDefault()
		{
			currentMode = defaultMode;
		}

		private void SetDefault(T defaultMode)
		{
			this.defaultMode = defaultMode;
		}

		private void ButtonClicked()
		{
			CycleMode();
			clicked?.Invoke();
		}

		public void CycleMode()
		{
			SetToMode(NextMode());
		}

		public void SetToMode(T mode)
		{
			currentMode = mode;
			((TextElement)button).text = ModeString(currentMode);
		}

		private T NextMode()
		{
			return currentMode.Next();
		}

		internal void SetupSaving(T? defaultValue = null)
		{
			clicked = (Action)Delegate.Combine(clicked, (Action)delegate
			{
				Preset.Custom.SaveSettingChange(base.Identifier, currentMode);
			});
			if (defaultValue.HasValue)
			{
				PresetDefault.SaveDefaultSetting(base.Identifier, defaultValue);
			}
		}

		internal void Load(Preset preset)
		{
			SetToMode(preset.Get<T>(base.Identifier) ?? currentMode);
			Preset.Custom.SaveSettingChange(base.Identifier, currentMode);
		}
	}
	[UxmlElement]
	[Preserve]
	public class WaveDisplay : VisualElement
	{
		private LinkedList<float> dataPoints = new LinkedList<float>();

		[UxmlAttribute]
		public Color LineColor = Color.white;

		[UxmlAttribute]
		public float LineWidth = 2f;

		[UxmlAttribute]
		public Color GlowColor = Color.white;

		[UxmlAttribute]
		public float GlowWidth = 2f;

		private float _minValue;

		private float _maxValue = 100f;

		private float _defaultValue;

		[UxmlAttribute]
		public int RecordSteps = 100;

		[UxmlAttribute]
		public float LineBufferTop;

		[UxmlAttribute]
		public float LineBufferBottom;

		[UxmlAttribute]
		public float MinimumValue
		{
			get
			{
				return _minValue;
			}
			set
			{
				_minValue = value;
				((VisualElement)this).MarkDirtyRepaint();
			}
		}

		[UxmlAttribute]
		public float MaximumValue
		{
			get
			{
				return _maxValue;
			}
			set
			{
				_maxValue = value;
				((VisualElement)this).MarkDirtyRepaint();
			}
		}

		[UxmlAttribute]
		public float DefaultValue
		{
			get
			{
				return _defaultValue;
			}
			set
			{
				_defaultValue = value;
				((VisualElement)this).MarkDirtyRepaint();
			}
		}

		public WaveDisplay()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (MinimumValue >= MaximumValue)
			{
				throw new ArgumentException("Minimum value must be less than maximum value");
			}
			ClearRecord();
			((VisualElement)this).generateVisualContent = (Action<MeshGenerationContext>)Delegate.Combine(((VisualElement)this).generateVisualContent, new Action<MeshGenerationContext>(GenerateVisualContent));
		}

		public void ClearRecord()
		{
			for (int i = 0; i < RecordSteps; i++)
			{
				PushRecordStep();
			}
		}

		public void PushRecordStep(float? record = null)
		{
			dataPoints.AddFirst(record ?? DefaultValue);
			while (dataPoints.Count > RecordSteps)
			{
				dataPoints.RemoveLast();
			}
			((VisualElement)this).MarkDirtyRepaint();
		}

		private void GenerateVisualContent(MeshGenerationContext mesh)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			Rect contentRect = ((VisualElement)this).contentRect;
			float height = ((Rect)(ref contentRect)).height - LineBufferBottom - LineBufferTop;
			float num;
			if (RecordSteps >= 2)
			{
				contentRect = ((VisualElement)this).contentRect;
				num = ((Rect)(ref contentRect)).width / (float)(RecordSteps - 1);
			}
			else
			{
				contentRect = ((VisualElement)this).contentRect;
				num = ((Rect)(ref contentRect)).width;
			}
			float num2 = num;
			Painter2D painter2D = mesh.painter2D;
			painter2D.lineWidth = GlowWidth + LineWidth;
			LinkedListNode<float> linkedListNode = dataPoints.First;
			painter2D.BeginPath();
			painter2D.MoveTo(new Vector2(0f, RecordToHeight(linkedListNode.Value)));
			painter2D.strokeColor = GlowColor;
			for (int i = 1; i < RecordSteps; i++)
			{
				if (linkedListNode.Next != null)
				{
					linkedListNode = linkedListNode.Next;
				}
				painter2D.LineTo(new Vector2((float)i * num2, RecordToHeight(linkedListNode.Value)));
			}
			painter2D.Stroke();
			painter2D.strokeColor = LineColor;
			painter2D.lineWidth = LineWidth;
			painter2D.Stroke();
			float RecordToHeight(float record)
			{
				if (record >= MaximumValue)
				{
					return LineBufferTop;
				}
				if (record <= MinimumValue)
				{
					return LineBufferTop + height;
				}
				return height * (1f - (record - MinimumValue) / (MaximumValue - MinimumValue)) + LineBufferTop;
			}
		}
	}
}
namespace ButtplugSong.Network
{
	public class ButtplugDevice
	{
		private readonly ButtplugRawClient _client;

		public string Name { get; }

		public uint Index { get; }

		public List<DeviceFeature> Features { get; }

		public bool HasBattery { get; }

		public ButtplugDevice(string name, uint index, List<DeviceFeature> features, bool hasBattery, ButtplugRawClient client)
		{
			Name = name ?? "Unknown";
			Index = index;
			Features = features ?? new List<DeviceFeature>();
			HasBattery = hasBattery;
			_client = client;
		}

		public void SendScalarSingle(double value, string actuatorType, int actuatorIndex)
		{
			_client.SendScalar(Index, value, actuatorType, actuatorIndex);
		}

		public void SendVibrateCmd(double speed)
		{
			IEnumerable<(int, string)> actuators = from f in Features
				where f.CommandType == "ScalarCmd" && f.ActuatorType == "Vibrate"
				select (f.ActuatorIndex, f.ActuatorType);
			_client.SendScalarAll(Index, speed, actuators);
		}

		public void SendRotateCmd(double speed, bool clockwise, int actuatorIndex = 0)
		{
			_client.SendRotate(Index, speed, clockwise, actuatorIndex);
		}

		public void SendLinearCmd(uint durationMs, double position, int actuatorIndex = 0)
		{
			_client.SendLinear(Index, durationMs, position, actuatorIndex);
		}

		public void SendStopCmd()
		{
			_client.SendStop(Index);
		}

		public Task<double?> ReadBatteryAsync()
		{
			if (!HasBattery)
			{
				return Task.FromResult<double?>(null);
			}
			return _client.ReadBatteryAsync(Index);
		}

		public bool SupportsFeature(string actuatorType)
		{
			foreach (DeviceFeature feature in Features)
			{
				if (feature.ActuatorType == actuatorType)
				{
					return true;
				}
			}
			return false;
		}

		public int GetStepCount(string actuatorType)
		{
			foreach (DeviceFeature feature in Features)
			{
				if (feature.ActuatorType == actuatorType)
				{
					return (int)feature.StepCount.GetValueOrDefault();
				}
			}
			return 0;
		}

		public int GetActuatorCount(string actuatorType)
		{
			int num = 0;
			foreach (DeviceFeature feature in Features)
			{
				if (feature.ActuatorType == actuatorType)
				{
					num++;
				}
			}
			return num;
		}
	}
	public class ButtplugRawClient
	{
		private ClientWebSocket _ws;

		private int _msgIdCounter;

		private readonly ConcurrentDictionary<int, TaskCompletionSource<JToken>> _pending = new ConcurrentDictionary<int, TaskCompletionSource<JToken>>();

		private readonly Action<string> _log;

		private CancellationTokenSource _cts;

		public bool Connected
		{
			get
			{
				if (_ws != null)
				{
					return _ws.State == WebSocketState.Open;
				}
				return false;
			}
		}

		public List<ButtplugDevice> Devices { get; } = new List<ButtplugDevice>();


		public event Action<ButtplugDevice> DeviceAdded;

		public event Action<ButtplugDevice> DeviceRemoved;

		public event Action ServerDisconnect;

		public event Action<string> ErrorReceived;

		public ButtplugRawClient(Action<string> log)
		{
			_log = log;
		}

		public async Task ConnectAsync(string address, int port)
		{
			_ws = new ClientWebSocket();
			_cts = new CancellationTokenSource();
			Uri uri = new Uri($"ws://{address}:{port}/buttplug");
			await _ws.ConnectAsync(uri, _cts.Token);
			StartReceiveLoop();
			int num = NextId();
			TaskCompletionSource<JToken> tcs = RegisterPending(num);
			await SendAsync($"[{{\"RequestServerInfo\":{{\"Id\":{num},\"ClientName\":\"ButtplugSong\",\"MessageVersion\":3}}}}]");
			Task timeoutTask = Task.Delay(5000);
			if (await Task.WhenAny(new Task[2] { tcs.Task, timeoutTask }) == timeoutTask)
			{
				throw new TimeoutException("Handshake timeout");
			}
		}

		public void Disconnect()
		{
			try
			{
				_cts?.Cancel();
			}
			catch
			{
			}
			try
			{
				if (_ws != null && _ws.State == WebSocketState.Open)
				{
					_ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).Wait(1000);
				}
			}
			catch
			{
			}
			_ws = null;
			_cts = null;
			Devices.Clear();
			_pending.Clear();
		}

		public void StartScanning()
		{
			int num = NextId();
			SendAsync($"[{{\"StartScanning\":{{\"Id\":{num}}}}}]");
		}

		public void StopScanning()
		{
			int num = NextId();
			SendAsync($"[{{\"StopScanning\":{{\"Id\":{num}}}}}]");
		}

		public void RequestDeviceList()
		{
			int num = NextId();
			SendAsync($"[{{\"RequestDeviceList\":{{\"Id\":{num}}}}}]");
		}

		public void SendScalar(uint deviceIndex, double value, string actuatorType, int actuatorIndex = 0)
		{
			int num = NextId();
			string text = value.ToString("F4", CultureInfo.InvariantCulture);
			SendAsync($"[{{\"ScalarCmd\":{{\"Id\":{num},\"DeviceIndex\":{deviceIndex},\"Scalars\":[{{\"Index\":{actuatorIndex},\"Scalar\":{text},\"ActuatorType\":\"{actuatorType}\"}}]}}}}]");
		}

		public void SendScalarAll(uint deviceIndex, double value, IEnumerable<(int index, string actuatorType)> actuators)
		{
			int num = NextId();
			string val = value.ToString("F4", CultureInfo.InvariantCulture);
			IEnumerable<string> values = actuators.Select<(int, string), string>(((int index, string actuatorType) a) => $"{{\"Index\":{a.index},\"Scalar\":{val},\"ActuatorType\":\"{a.actuatorType}\"}}");
			string text = string.Join(",", values);
			if (!string.IsNullOrEmpty(text))
			{
				SendAsync($"[{{\"ScalarCmd\":{{\"Id\":{num},\"DeviceIndex\":{deviceIndex},\"Scalars\":[{text}]}}}}]");
			}
		}

		public void SendRotate(uint deviceIndex, double speed, bool clockwise, int actuatorIndex = 0)
		{
			int num = NextId();
			string text = speed.ToString("F4", CultureInfo.InvariantCulture);
			string text2 = (clockwise ? "true" : "false");
			SendAsync($"[{{\"RotateCmd\":{{\"Id\":{num},\"DeviceIndex\":{deviceIndex},\"Rotations\":[{{\"Index\":{actuatorIndex},\"Speed\":{text},\"Clockwise\":{text2}}}]}}}}]");
		}

		public void SendLinear(uint deviceIndex, uint durationMs, double position, int actuatorIndex = 0)
		{
			int num = NextId();
			string text = position.ToString("F4", CultureInfo.InvariantCulture);
			SendAsync($"[{{\"LinearCmd\":{{\"Id\":{num},\"DeviceIndex\":{deviceIndex},\"Vectors\":[{{\"Index\":{actuatorIndex},\"Duration\":{durationMs},\"Position\":{text}}}]}}}}]");
		}

		public void SendStop(uint deviceIndex)
		{
			int num = NextId();
			SendAsync($"[{{\"StopDeviceCmd\":{{\"Id\":{num},\"DeviceIndex\":{deviceIndex}}}}}]");
		}

		public Task<double?> ReadBatteryAsync(uint deviceIndex)
		{
			int id = NextId();
			TaskCompletionSource<JToken> tcs = RegisterPending(id);
			SendAsync($"[{{\"SensorReadCmd\":{{\"Id\":{id},\"DeviceIndex\":{deviceIndex},\"SensorIndex\":0,\"SensorType\":\"Battery\"}}}}]");
			Task.Delay(3000).ContinueWith(delegate
			{
				_pending.TryRemove(id, out TaskCompletionSource<JToken> _);
				tcs.TrySetResult(null);
			});
			return tcs.Task.ContinueWith((Func<Task<JToken>, double?>)delegate(Task<JToken> t)
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Invalid comparison between Unknown and I4
				if (t.IsFaulted || t.Result == null)
				{
					return null;
				}
				try
				{
					JToken val = t.Result[(object)"Data"];
					if (val != null && val.HasValues)
					{
						JToken val2 = val[(object)0];
						double num = (((int)val2.Type != 2) ? Extensions.Value<double>((IEnumerable<JToken>)val2) : Extensions.Value<double>((IEnumerable<JToken>)val2[(object)0]));
						if (num <= 1.0)
						{
							num *= 100.0;
						}
						_log($"Battery read: {num}%");
						return num;
					}
				}
				catch (Exception ex)
				{
					_log("Battery parse error: " + ex.Message);
				}
				return null;
			});
		}

		private async void StartReceiveLoop()
		{
			byte[] buffer = new byte[8192];
			StringBuilder messageBuffer = new StringBuilder();
			try
			{
				while (_ws != null && _ws.State == WebSocketState.Open && _cts != null && !_cts.IsCancellationRequested)
				{
					WebSocketReceiveResult webSocketReceiveResult;
					try
					{
						webSocketReceiveResult = await _ws.ReceiveAsync(new ArraySegment<byte>(buffer), _cts.Token);
					}
					catch (OperationCanceledException)
					{
						break;
					}
					catch (Exception ex2)
					{
						_log("WS receive error: " + ex2.Message);
						break;
					}
					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Close)
					{
						break;
					}
					messageBuffer.Append(Encoding.UTF8.GetString(buffer, 0, webSocketReceiveResult.Count));
					if (webSocketReceiveResult.EndOfMessage)
					{
						string raw = messageBuffer.ToString();
						messageBuffer.Clear();
						try
						{
							HandleMessage(raw);
						}
						catch (Exception ex3)
						{
							_log("Message handle error: " + ex3.Message);
						}
					}
				}
			}
			catch (Exception ex4)
			{
				_log("Receive loop ended: " + ex4.Message);
			}
			Devices.Clear();
			this.ServerDisconnect?.Invoke();
		}

		private async Task SendAsync(string msg)
		{
			if (_ws == null || _ws.State != WebSocketState.Open)
			{
				return;
			}
			byte[] bytes = Encoding.UTF8.GetBytes(msg);
			try
			{
				await _ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, endOfMessage: true, _cts?.Token ?? CancellationToken.None);
			}
			catch (Exception ex)
			{
				_log("WS send error: " + ex.Message);
			}
		}

		private void HandleMessage(string raw)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			JArray val;
			try
			{
				val = JArray.Parse(raw);
			}
			catch (Exception ex)
			{
				_log("JSON parse error: " + ex.Message);
				return;
			}
			foreach (JObject item in val)
			{
				JProperty val2 = item.Properties().FirstOrDefault();
				if (val2 == null)
				{
					continue;
				}
				string name = val2.Name;
				JToken value = val2.Value;
				JObject val3 = (JObject)(object)((value is JObject) ? value : null);
				if (val3 != null)
				{
					int valueOrDefault = ((JToken)val3).Value<int?>((object)"Id").GetValueOrDefault(-1);
					switch (name)
					{
					case "ServerInfo":
						ResolvePending(valueOrDefault, (JToken)(object)val3);
						break;
					case "Ok":
						ResolvePending(valueOrDefault, (JToken)(object)val3);
						break;
					case "Error":
					{
						string obj = ((JToken)val3).Value<string>((object)"ErrorMessage") ?? "Unknown error";
						ResolvePending(valueOrDefault, null);
						this.ErrorReceived?.Invoke(obj);
						break;
					}
					case "DeviceAdded":
						HandleDeviceAdded(val3);
						break;
					case "DeviceRemoved":
						HandleDeviceRemoved(val3);
						break;
					case "DeviceList":
						HandleDeviceList(val3);
						break;
					case "SensorReading":
						ResolvePending(valueOrDefault, (JToken)(object)val3);
						break;
					case "ScanningFinished":
						StartScanning();
						break;
					}
				}
			}
		}

		private void HandleDeviceAdded(JObject body)
		{
			ButtplugDevice device = ParseDevice(body);
			if (device != null)
			{
				Devices.RemoveAll((ButtplugDevice d) => d.Index == device.Index);
				Devices.Add(device);
				this.DeviceAdded?.Invoke(device);
			}
		}

		private void HandleDeviceRemoved(JObject body)
		{
			uint devIdx = ((JToken)body).Value<uint>((object)"DeviceIndex");
			ButtplugDevice buttplugDevice = Devices.FirstOrDefault((ButtplugDevice d) => d.Index == devIdx);
			if (buttplugDevice != null)
			{
				Devices.Remove(buttplugDevice);
				this.DeviceRemoved?.Invoke(buttplugDevice);
				StartScanning();
			}
		}

		private void HandleDeviceList(JObject body)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			JToken obj = body["Devices"];
			JArray val = (JArray)(object)((obj is JArray) ? obj : null);
			if (val == null)
			{
				return;
			}
			foreach (JObject item in val)
			{
				JObject body2 = item;
				ButtplugDevice device = ParseDevice(body2);
				if (device != null)
				{
					Devices.RemoveAll((ButtplugDevice d) => d.Index == device.Index);
					Devices.Add(device);
					this.DeviceAdded?.Invoke(device);
				}
			}
		}

		private ButtplugDevice ParseDevice(JObject body)
		{
			try
			{
				uint index = ((JToken)body).Value<uint>((object)"DeviceIndex");
				string text = ((JToken)body).Value<string>((object)"DeviceName") ?? "Unknown";
				List<DeviceFeature> list = new List<DeviceFeature>();
				JToken obj = body["DeviceMessages"];
				JObject val = (JObject)(object)((obj is JObject) ? obj : null);
				if (val != null)
				{
					JToken obj2 = val["ScalarCmd"];
					JArray val2 = (JArray)(object)((obj2 is JArray) ? obj2 : null);
					if (val2 != null)
					{
						for (int i = 0; i < ((JContainer)val2).Count; i++)
						{
							JToken obj3 = val2[i];
							JToken obj4 = ((obj3 is JObject) ? obj3 : null);
							string actuatorType = ((obj4 != null) ? obj4.Value<string>((object)"ActuatorType") : null) ?? "Vibrate";
							int valueOrDefault = ((obj4 != null) ? obj4.Value<int?>((object)"StepCount") : null).GetValueOrDefault(20);
							list.Add(new DeviceFeature("ScalarCmd", actuatorType, i, valueOrDefault));
						}
					}
					JToken obj5 = val["RotateCmd"];
					JArray val3 = (JArray)(object)((obj5 is JArray) ? obj5 : null);
					if (val3 != null)
					{
						for (int j = 0; j < ((JContainer)val3).Count; j++)
						{
							JToken obj6 = val3[j];
							JToken obj7 = ((obj6 is JObject) ? obj6 : null);
							int valueOrDefault2 = ((obj7 != null) ? obj7.Value<int?>((object)"StepCount") : null).GetValueOrDefault(20);
							list.Add(new DeviceFeature("RotateCmd", "Rotate", j, valueOrDefault2));
						}
					}
					JToken obj8 = val["LinearCmd"];
					JArray val4 = (JArray)(object)((obj8 is JArray) ? obj8 : null);
					if (val4 != null)
					{
						for (int k = 0; k < ((JContainer)val4).Count; k++)
						{
							JToken obj9 = val4[k];
							JToken obj10 = ((obj9 is JObject) ? obj9 : null);
							int valueOrDefault3 = ((obj10 != null) ? obj10.Value<int?>((object)"StepCount") : null).GetValueOrDefault(100);
							list.Add(new DeviceFeature("LinearCmd", "Position", k, valueOrDefault3));
						}
					}
				}
				bool flag = HasBatteryCapability(val);
				_log($"Device {text}: features={list.Count}, hasBattery={flag}");
				return new ButtplugDevice(text, index, list, flag, this);
			}
			catch (Exception ex)
			{
				_log("Failed to parse device: " + ex.Message);
				return null;
			}
		}

		private bool HasBatteryCapability(JObject msgs)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (msgs == null)
			{
				return false;
			}
			JToken val = msgs["SensorReadCmd"];
			if (val == null)
			{
				return false;
			}
			JArray val2 = (JArray)(object)((val is JArray) ? val : null);
			if (val2 != null)
			{
				foreach (JObject item in val2)
				{
					if (((JToken)item).Value<string>((object)"SensorType") == "Battery")
					{
						return true;
					}
				}
			}
			return false;
		}

		private void ResolvePending(int msgId, JToken body)
		{
			if (msgId >= 0 && _pending.TryRemove(msgId, out TaskCompletionSource<JToken> value))
			{
				value.TrySetResult(body);
			}
		}

		private int NextId()
		{
			return Interlocked.Increment(ref _msgIdCounter);
		}

		private TaskCompletionSource<JToken> RegisterPending(int id)
		{
			TaskCompletionSource<JToken> taskCompletionSource = new TaskCompletionSource<JToken>();
			_pending[id] = taskCompletionSource;
			return taskCompletionSource;
		}
	}
	public enum FeatureType
	{
		Vibrate,
		Rotate,
		Oscillate,
		Constrict,
		Spray,
		Temperature,
		Led,
		Position,
		Shock
	}
	public class DeviceFeature
	{
		public static HashSet<FeatureType> Implemented = new HashSet<FeatureType>
		{
			FeatureType.Vibrate,
			FeatureType.Rotate,
			FeatureType.Position
		};

		internal static readonly string[] AllCommandKeys = new string[9] { "VibrateCmd", "RotateCmd", "OscillateCmd", "ConstrictionCmd", "SprayCmd", "TemperatureCmd", "LedCmd", "LinearCmd", "ShockCmd" };

		public FeatureType Type { get; }

		public bool IsSupported { get; internal set; }

		public uint? StepCount { get; }

		public DeviceInfo DeviceInfo { get; internal set; }

		public bool IsEnabled { get; set; }

		public string CommandType { get; }

		public string ActuatorType { get; }

		public int ActuatorIndex { get; }

		public DeviceFeature(DeviceInfo device, FeatureType type, bool isSupported, uint? stepCount)
		{
			DeviceInfo = device;
			Type = type;
			IsSupported = isSupported;
			StepCount = stepCount;
			IsEnabled = isSupported;
		}

		public DeviceFeature(string commandType, string actuatorType, int actuatorIndex, int stepCount)
		{
			CommandType = commandType;
			ActuatorType = actuatorType;
			ActuatorIndex = actuatorIndex;
			StepCount = (uint)stepCount;
			IsSupported = true;
			IsEnabled = false;
		}

		internal static FeatureType CommandKeyToType(string key)
		{
			return key switch
			{
				"VibrateCmd" => FeatureType.Vibrate, 
				"RotateCmd" => FeatureType.Rotate, 
				"OscillateCmd" => FeatureType.Oscillate, 
				"ConstrictionCmd" => FeatureType.Constrict, 
				"SprayCmd" => FeatureType.Spray, 
				"TemperatureCmd" => FeatureType.Temperature, 
				"LedCmd" => FeatureType.Led, 
				"LinearCmd" => FeatureType.Position, 
				"ShockCmd" => FeatureType.Shock, 
				_ => throw new ArgumentException("Unknown command key: " + key), 
			};
		}

		internal static string TypeToCommandKey(FeatureType type)
		{
			return type switch
			{
				FeatureType.Vibrate => "VibrateCmd", 
				FeatureType.Rotate => "RotateCmd", 
				FeatureType.Oscillate => "OscillateCmd", 
				FeatureType.Constrict => "ConstrictionCmd", 
				FeatureType.Spray => "SprayCmd", 
				FeatureType.Temperature => "TemperatureCmd", 
				FeatureType.Led => "LedCmd", 
				FeatureType.Position => "LinearCmd", 
				FeatureType.Shock => "ShockCmd", 
				_ => throw new ArgumentException($"Unknown feature type: {type}"), 
			};
		}
	}
	public class DeviceInfo
	{
		internal readonly ButtplugDevice Device;

		private readonly Action<string> Log;

		private float _testTimeRemaining;

		private bool _isTesting;

		public string Name => Device.Name;

		public uint Id => Device.Index;

		public double? Battery { get; private set; }

		public bool IsEnabled { get; set; } = true;


		public bool AlternateRotation { get; internal set; } = true;


		public bool RotateClockwise { get; set; } = true;


		public float NeutralTemperature { get; set; }

		public float MoveDuration { get; set; } = 1.5f;


		public Dictionary<FeatureType, DeviceFeature> Features { get; } = new Dictionary<FeatureType, DeviceFeature>();


		public DeviceInfo(ButtplugDevice device, Action<string> log)
		{
			Device = device;
			Log = log;
			PopulateFeatures();
			PlugManager.UpdateDevicePower += ActivateFeatures;
		}

		private void PopulateFeatures()
		{
			Dictionary<FeatureType, uint> dictionary = new Dictionary<FeatureType, uint>();
			foreach (DeviceFeature feature in Device.Features)
			{
				FeatureType key = ActuatorTypeToFeatureType(feature.ActuatorType);
				if (!dictionary.ContainsKey(key))
				{
					dictionary[key] = feature.StepCount.GetValueOrDefault();
				}
			}
			foreach (FeatureType value2 in Enum.GetValues(typeof(FeatureType)))
			{
				uint value;
				bool flag = dictionary.TryGetValue(value2, out value);
				Features[value2] = new DeviceFeature(this, value2, flag, flag ? new uint?(value) : null);
			}
		}

		private static FeatureType ActuatorTypeToFeatureType(string actuatorType)
		{
			return actuatorType switch
			{
				"Vibrate" => FeatureType.Vibrate, 
				"Rotate" => FeatureType.Rotate, 
				"Oscillate" => FeatureType.Oscillate, 
				"Constrict" => FeatureType.Constrict, 
				"Spray" => FeatureType.Spray, 
				"Position" => FeatureType.Position, 
				_ => FeatureType.Vibrate, 
			};
		}

		public async Task<bool> TryRefreshBattery()
		{
			try
			{
				double? num = await Device.ReadBatteryAsync();
				if (num.HasValue)
				{
					Battery = num.Value;
					return true;
				}
				return false;
			}
			catch
			{
				return false;
			}
		}

		public void Test(float power, float duration)
		{
			if (IsEnabled)
			{
				_testTimeRemaining = duration;
				_isTesting = true;
				ActivateFeatures(Math.Max(0f, Math.Min(1f, power)), routineUpdate: false);
			}
		}

		public void Update(float deltaTime)
		{
			if (_isTesting)
			{
				_testTimeRemaining -= deltaTime;
				if (!(_testTimeRemaining > 0f))
				{
					_isTesting = false;
					_testTimeRemaining = 0f;
					Device.SendStopCmd();
				}
			}
		}

		private void ActivateFeatures(float power, bool routineUpdate)
		{
			if (!IsEnabled)
			{
				return;
			}
			foreach (FeatureType item in DeviceFeature.Implemented)
			{
				if (!Features.TryGetValue(item, out DeviceFeature value) || !value.IsSupported || !value.IsEnabled)
				{
					continue;
				}
				switch (value.Type)
				{
				case FeatureType.Vibrate:
					Device.SendVibrateCmd(power);
					break;
				case FeatureType.Rotate:
					if (AlternateRotation)
					{
						RotateClockwise = !RotateClockwise;
					}
					Device.SendRotateCmd(power, RotateClockwise);
					break;
				case FeatureType.Position:
				{
					uint durationMs = (uint)(MoveDuration * 1000f);
					Device.SendLinearCmd(durationMs, power);
					break;
				}
				}
			}
		}

		public void Unload()
		{
			PlugManager.UpdateDevicePower -= ActivateFeatures;
		}
	}
	public class PlugManager
	{
		public enum PlugManagerStatus
		{
			Uninitialized = 0,
			ClientSetUp = 1,
			ConnectedToServer = 2,
			ScannedNoDevices = 3,
			DeviceConnected = 4,
			Initializing = 10,
			SettingUpClient = 11,
			ConnectingToServer = 12,
			ScanningForDevices = 13,
			ShutDown = 100
		}

		[CompilerGenerated]
		private sealed class <GetDevices>d__55 : IEnumerable<ButtplugDevice>, IEnumerable, IEnumerator<ButtplugDevice>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private ButtplugDevice <>2__current;

			private int <>l__initialThreadId;

			public PlugManager <>4__this;

			private List<ButtplugDevice>.Enumerator <>7__wrap1;

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

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

			[DebuggerHidden]
			public <GetDevices>d__55(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = default(List<ButtplugDevice>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					PlugManager plugManager = <>4__this;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
					}
					else
					{
						<>1__state = -1;
						if (plugManager.Client == null || plugManager.Client.Devices == null)
						{
							goto IL_00a0;
						}
						<>7__wrap1 = plugManager.Client.Devices.GetEnumerator();
						<>1__state = -3;
					}
					while (<>7__wrap1.MoveNext())
					{
						ButtplugDevice current = <>7__wrap1.Current;
						if (current != null)
						{
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = default(List<ButtplugDevice>.Enumerator);
					goto IL_00a0;
					IL_00a0:
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap1).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<ButtplugDevice> IEnumerable<ButtplugDevice>.GetEnumerator()
			{
				<GetDevices>d__55 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetDevices>d__55(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<ButtplugDevice>)this).GetEnumerator();
			}
		}

		private PlugManagerStatus _status;

		private int tryConnectAttempts;

		internal float currentPower;

		internal bool rotationEnabled;

		internal bool rotateClockwise = true;

		private Action<string> _logger;

		internal bool allowedToInitialize = true;

		private DateTime? _scanStartTime;

		private bool _tryingToReconnect;

		private int _duplicateUpdates;

		private PlugManagerStatus Status
		{
			get
			{
				return _status;
			}
			set
			{
				_status = value;
			}
		}

		public ButtplugRawClient Client { get; private set; }

		public string ServerAddress { get; private set; }

		public int Port { get; private set; }

		public int RetryAttempts { get; private set; }

		public static event Action<ButtplugDevice>? DeviceConnected;

		public static event Action<ButtplugDevice>? DeviceDisconnected;

		public static event Action? DisconnectedFromServer;

		public static event Action<float, bool>? UpdateDevicePower;

		public PlugManager(Action<string> logger = null, string serverAddress = "localhost", int port = 12345, int retryAttempts = 5)
		{
			_logger = logger;
			ServerAddress = serverAddress;
			Port = port;
			RetryAttempts = retryAttempts;
		}

		private void Log(string s)
		{
			_logger?.Invoke(s);
		}

		public async Task<bool> Initialize()
		{
			if (Status == PlugManagerStatus.ShutDown || !allowedToInitialize)
			{
				return false;
			}
			allowedToInitialize = false;
			Status = PlugManagerStatus.Initializing;
			SetupClient();
			if (!(await TryConnect()))
			{
				Log("Could not connect to the server.");
				return false;
			}
			return true;
		}

		internal void ShutDown()
		{
			Status = PlugManagerStatus.ShutDown;
			Disconnect();
		}

		internal void Disconnect()
		{
			if (Client != null)
			{
				Log("Disconnecting old client.");
				Client.DeviceAdded -= OnDeviceAdded;
				Client.DeviceRemoved -= OnDeviceRemoved;
				Client.ServerDisconnect -= ClientOnServerDisconnect;
				Client.ErrorReceived -= ClientOnErrorReceived;
				try
				{
					Client.Disconnect();
				}
				catch
				{
				}
				Client = null;
			}
		}

		private void SetupClient()
		{
			if (Status != PlugManagerStatus.ShutDown)
			{
				Status = PlugManagerStatus.SettingUpClient;
				if (Client != null)
				{
					Log("Existing client detected.");
					Disconnect();
				}
				Client = new ButtplugRawClient(Log);
				Client.DeviceAdded += OnDeviceAdded;
				Client.DeviceRemoved += OnDeviceRemoved;
				Client.ServerDisconnect += ClientOnServerDisconnect;
				Client.ErrorReceived += ClientOnErrorReceived;
				Log("Client setup complete.");
				allowedToInitialize = true;
				Status = PlugManagerStatus.ClientSetUp;
			}
		}

		private async Task<bool> TryConnect()
		{
			if (Status == PlugManagerStatus.ShutDown)
			{
				return false;
			}
			if (Status == PlugManagerStatus.Uninitialized)
			{
				SetupClient();
			}
			if (tryConnectAttempts >= RetryAttempts)
			{
				return false;
			}
			tryConnectAttempts++;
			Status = PlugManagerStatus.ConnectingToServer;
			try
			{
				Log("Connecting to the server...");
				await Client.ConnectAsync(ServerAddress, Port);
				if (Status != PlugManagerStatus.DeviceConnected)
				{
					Status = PlugManagerStatus.ConnectedToServer;
				}
				Log("Connected to server.");
				_tryingToReconnect = false;
				tryConnectAttempts = 0;
				allowedToInitialize = true;
				return await TryScanning();
			}
			catch (TimeoutException)
			{
				Log("Connection timed out.");
			}
			catch (Exception ex2)
			{
				Log("Could not connect to the server: " + ex2.Message);
			}
			Status = PlugManagerStatus.ClientSetUp;
			return false;
		}

		private async Task<bool> TryScanning()
		{
			if (Status == PlugManagerStatus.ShutDown)
			{
				return false;
			}
			if (Status != PlugManagerStatus.DeviceConnected)
			{
				Status = PlugManagerStatus.ScanningForDevices;
			}
			Log("Starting to scan for devices.");
			try
			{
				Client.StartScanning();
				Client.RequestDeviceList();
				allowedToInitialize = true;
				_scanStartTime = DateTime.UtcNow;
			}
			catch (Exception ex)
			{
				Log("Failed to start scanning for devices: " + ex.Message);
				Status = PlugManagerStatus.ConnectedToServer;
				return false;
			}
			return true;
		}

		private void OnDeviceAdded(ButtplugDevice device)
		{
			Log("Device Connected: " + device.Name);
			Status = PlugManagerStatus.DeviceConnected;
			PlugManager.DeviceConnected?.Invoke(device);
		}

		private void OnDeviceRemoved(ButtplugDevice device)
		{
			Log("Device Disconnected: " + device.Name);
			if (!GetDevices().Any())
			{
				Status = PlugManagerStatus.ConnectedToServer;
			}
			PlugManager.DeviceDisconnected?.Invoke(device);
		}

		private void ClientOnErrorReceived(string error)
		{
			Log("Received an error: " + error);
		}

		private async void ClientOnServerDisconnect()
		{
			if (Status == PlugManagerStatus.ShutDown || _tryingToReconnect)
			{
				return;
			}
			Log("Disconnected from server.");
			PlugManager.DisconnectedFromServer?.Invoke();
			_tryingToReconnect = true;
			SetupClient();
			while (tryConnectAttempts < RetryAttempts)
			{
				Log("Reconnecting after disconnect...");
				if (await TryConnect())
				{
					return;
				}
				Log("Trying again in 5 seconds.");
				await Task.Delay(TimeSpan.FromSeconds(5.0));
			}
			_tryingToReconnect = false;
			Log("Could not reconnect to server.");
		}

		private async Task EnsureClientExists()
		{
			if (Status >= PlugManagerStatus.Initializing)
			{
				if (Status == PlugManagerStatus.ShutDown)
				{
					return;
				}
				if (Status == PlugManagerStatus.ScanningForDevices && _scanStartTime.HasValue && DateTime.UtcNow - _scanStartTime.Value > TimeSpan.FromSeconds(10.0))
				{
					await Initialize();
				}
				await Task.Delay(TimeSpan.FromMilliseconds(250.0));
				if (Status >= PlugManagerStatus.Initializing)
				{
					return;
				}
			}
			if (Client == null)
			{
				Log("Intiface Client is null. Trying to setup.");
				if (!allowedToInitialize)
				{
					SetupClient();
				}
				if (!(await Initialize()))
				{
					return;
				}
			}
			if (!Client.Connected)
			{
				Log("Intiface Client is disconnected - Is the server running?");
				if (!(await TryConnect()))
				{
					Log("Failed to connect. Resetting client to reinitialize");
					SetupClient();
					if (await Initialize())
					{
						Log("Reinitialized!");
					}
				}
				else
				{
					Log("Reconnected!");
				}
			}
			else if (!Client.Devices.Any())
			{
				Log("Intiface Client connected, but no devices are connected.");
				if (Status == PlugManagerStatus.ConnectedToServer)
				{
					await TryScanning();
				}
			}
		}

		private async Task UpdatePowerLevels(bool routineUpdate)
		{
			await EnsureClientExists();
			if (PlugManager.UpdateDevicePower != null)
			{
				PlugManager.UpdateDevicePower(currentPower, routineUpdate);
				return;
			}
			foreach (ButtplugDevice device in GetDevices())
			{
				device.SendVibrateCmd(currentPower);
				if (rotationEnabled)
				{
					if (!routineUpdate)
					{
						rotateClockwise = !rotateClockwise;
					}
					try
					{
						device.SendRotateCmd(currentPower, rotateClockwise);
					}
					catch
					{
					}
				}
			}
		}

		[IteratorStateMachine(typeof(<GetDevices>d__55))]
		public IEnumerable<ButtplugDevice> GetDevices()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetDevices>d__55(-2)
			{
				<>4__this = this
			};
		}

		public void SetPowerLevel(float level, bool routineUpdate)
		{
			if (level == currentPower)
			{
				_duplicateUpdates++;
			}
			else
			{
				_duplicateUpdates = 0;
			}
			if (_duplicateUpdates < 3)
			{
				currentPower = level.Clamp(0f, 1f);
				Task.Factory.StartNew(delegate
				{
					UpdatePowerLevels(routineUpdate).FireAndForget(Log);
				});
			}
		}

		public void SetRotationEnabled(bool enabled)
		{
			rotationEnabled = enabled;
		}
	}
}