Decompiled source of Tanuki Atlyss FluffUtilities v1.0.15

BepInEx/plugins/Tanuki.Atlyss.FluffUtilities.dll

Decompiled a day ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using Microsoft.CodeAnalysis;
using Mirror;
using Nessie.ATLYSS.EasySettings;
using Steamworks;
using Tanuki.Atlyss.API.Commands;
using Tanuki.Atlyss.Core.Plugins;
using Tanuki.Atlyss.FluffUtilities.Components;
using Tanuki.Atlyss.FluffUtilities.Managers;
using Tanuki.Atlyss.FluffUtilities.Models.Configuration;
using Tanuki.Atlyss.Game;
using Tanuki.Atlyss.Game.Events.AtlyssNetworkManager;
using Tanuki.Atlyss.Game.Events.GameManager;
using Tanuki.Atlyss.Game.Events.ItemObject;
using Tanuki.Atlyss.Game.Events.LoadSceneManager;
using Tanuki.Atlyss.Game.Events.Player;
using Tanuki.Atlyss.Game.Events.PlayerCasting;
using Tanuki.Atlyss.Game.Events.PlayerMove;
using Tanuki.Atlyss.Game.Events.PlayerVisual;
using Tanuki.Atlyss.Game.Events.ScriptablePlayerRace;
using Tanuki.Atlyss.Game.Events.StatusEntity;
using Tanuki.Atlyss.Game.Extensions;
using Tanuki.Atlyss.Game.Fields;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Tanuki.Atlyss.FluffUtilities")]
[assembly: AssemblyDescription("Multifunctional plugin for Atlyss.")]
[assembly: AssemblyCompany("Tanuki")]
[assembly: AssemblyProduct("Tanuki.Atlyss.FluffUtilities")]
[assembly: AssemblyCopyright("Copyright © Tanuki 2025")]
[assembly: ComVisible(false)]
[assembly: Guid("cc8615a7-47a4-4321-be79-11e36887b64a")]
[assembly: AssemblyFileVersion("1.0.15")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyVersion("1.0.15.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Tanuki.Atlyss.FluffUtilities
{
	internal class Configuration
	{
		public static Configuration Instance;

		public Tanuki.Atlyss.FluffUtilities.Models.Configuration.Commands Commands;

		public Tanuki.Atlyss.FluffUtilities.Models.Configuration.PlayerAppearance PlayerAppearance;

		public Tanuki.Atlyss.FluffUtilities.Models.Configuration.GlobalRaceDisplayParameters GlobalRaceDisplayParameters;

		public Tanuki.Atlyss.FluffUtilities.Models.Configuration.FreeCamera FreeCamera;

		public Tanuki.Atlyss.FluffUtilities.Models.Configuration.NoClip NoClip;

		public Hotkeys Hotkeys;

		public General General;

		private Configuration()
		{
		}

		public static void Initialize()
		{
			if (Instance == null)
			{
				Instance = new Configuration();
			}
		}

		public void Load(ConfigFile ConfigFile)
		{
			Commands = new Tanuki.Atlyss.FluffUtilities.Models.Configuration.Commands(ref ConfigFile);
			PlayerAppearance = new Tanuki.Atlyss.FluffUtilities.Models.Configuration.PlayerAppearance(ref ConfigFile);
			GlobalRaceDisplayParameters = new Tanuki.Atlyss.FluffUtilities.Models.Configuration.GlobalRaceDisplayParameters(ref ConfigFile);
			FreeCamera = new Tanuki.Atlyss.FluffUtilities.Models.Configuration.FreeCamera(ref ConfigFile);
			NoClip = new Tanuki.Atlyss.FluffUtilities.Models.Configuration.NoClip(ref ConfigFile);
			Hotkeys = new Hotkeys(ref ConfigFile);
			General = new General(ref ConfigFile);
		}
	}
	[BepInPlugin("cc8615a7-47a4-4321-be79-11e36887b64a", "Tanuki.Atlyss.FluffUtilities", "1.0.15")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Main : Plugin
	{
		[CompilerGenerated]
		private sealed class <Plugin_ShowUsagePresenceOnJoinLobby_Effects>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Player._mainPlayer._pVisual.Cmd_PoofSmokeEffect();
					<>2__current = (object)new WaitForSeconds(0.3f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					Player._mainPlayer._pVisual.Cmd_PoofSmokeEffect();
					<>2__current = (object)new WaitForSeconds(0.3f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					Player._mainPlayer._pVisual.Cmd_VanitySparkleEffect();
					return false;
				}
			}

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

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

		internal static Main Instance;

		private bool Reloaded;

		private bool UsageAnnounced = true;

		internal void Awake()
		{
			Instance = this;
			Configuration.Initialize();
			Configuration.Instance.Load(((BaseUnityPlugin)this).Config);
			Lobby.Initialize();
			Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Initialize();
			Tanuki.Atlyss.FluffUtilities.Managers.GlobalRaceDisplayParameters.Initialize();
			Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Initialize();
			Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Initialize();
			Hotkey.Initialize();
			NessieEasySettings.Initialize();
		}

		protected override void Load()
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Tanuki.Atlyss.FluffUtilities by Timofey Tanuki / tanu.su");
			if (Reloaded)
			{
				((BaseUnityPlugin)this).Config.Reload();
				Configuration.Instance.Load(((BaseUnityPlugin)this).Config);
			}
			Main.Instance.Patch(new Type[5]
			{
				typeof(Enable_GroundCheckToVelocityZero_Postfix),
				typeof(Init_LoadScreenDisable_Postfix),
				typeof(OnStopClient_Prefix),
				typeof(OnStartAuthority_Postfix),
				typeof(Client_LocalPlayerControl_Prefix)
			});
			Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.Load();
			Tanuki.Atlyss.FluffUtilities.Managers.GlobalRaceDisplayParameters.Instance.Load();
			Lobby.Instance.Load();
			Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Reload();
			Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Reload();
			OnStartAuthority_Postfix.OnInvoke += new EventHandler(OnStartAuthority_Postfix_OnInvoke);
			Init_LoadScreenDisable_Postfix.OnInvoke += new EventHandler(Init_LoadScreenDisable_Postfix_OnInvoke);
			ReloadHotkeys();
		}

		internal void ReloadHotkeys()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0509: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			Hotkey.Instance.Reset();
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeadWidth.Increase.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyHeadWidth(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeadWidth.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeadWidth.Decrease.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyHeadWidth(0f - Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeadWidth.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyMuzzleLength.Increase.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyMuzzleLength(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyMuzzleLength.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyMuzzleLength.Decrease.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyMuzzleLength(0f - Configuration.Instance.Hotkeys.PlayerAppearance_ModifyMuzzleLength.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeight.Increase.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyHeight(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeight.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeight.Decrease.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyHeight(0f - Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeight.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyWidth.Increase.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyWidth(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyWidth.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyWidth.Decrease.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyWidth(0f - Configuration.Instance.Hotkeys.PlayerAppearance_ModifyWidth.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyTorsoSize.Increase.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyTorsoSize(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyTorsoSize.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyTorsoSize.Decrease.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyTorsoSize(0f - Configuration.Instance.Hotkeys.PlayerAppearance_ModifyTorsoSize.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBreastSize.Increase.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyBreastSize(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBreastSize.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBreastSize.Decrease.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyBreastSize(0f - Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBreastSize.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyArmsSize.Increase.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyArmsSize(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyArmsSize.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyArmsSize.Decrease.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyArmsSize(0f - Configuration.Instance.Hotkeys.PlayerAppearance_ModifyArmsSize.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBellySize.Increase.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyBellySize(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBellySize.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBellySize.Decrease.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyBellySize(0f - Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBellySize.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBottomSize.Increase.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyBottomSize(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBottomSize.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBottomSize.Decrease.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyBottomSize(0f - Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBottomSize.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyVoicePitch.Increase.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyVoicePitch(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyVoicePitch.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.PlayerAppearance_ModifyVoicePitch.Decrease.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.ModifyVoicePitch(0f - Configuration.Instance.Hotkeys.PlayerAppearance_ModifyVoicePitch.Step.Value, Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave.Value);
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.FreeCamera.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					if (Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Status)
					{
						Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Disable();
					}
					else
					{
						Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Enable(Configuration.Instance.FreeCamera.LockCharacterControls.Value, Configuration.Instance.FreeCamera.SmoothLookMode.Value);
					}
				}
			});
			Hotkey.Instance.BindAction(Configuration.Instance.Hotkeys.NoClip_Toggle.Value, delegate
			{
				if (Object.op_Implicit((Object)(object)Player._mainPlayer))
				{
					if (Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Status)
					{
						Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Disable();
					}
					else
					{
						Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Enable();
					}
				}
			});
		}

		private void Init_LoadScreenDisable_Postfix_OnInvoke()
		{
			if (!UsageAnnounced && !Player._mainPlayer._isHostPlayer)
			{
				UsageAnnounced = true;
				if (Configuration.Instance.General.Plugin_ShowUsagePresenceOnJoin.Value)
				{
					((MonoBehaviour)this).StartCoroutine(Plugin_ShowUsagePresenceOnJoinLobby_Effects());
				}
			}
		}

		private void OnStartAuthority_Postfix_OnInvoke()
		{
			UsageAnnounced = false;
		}

		[IteratorStateMachine(typeof(<Plugin_ShowUsagePresenceOnJoinLobby_Effects>d__8))]
		private IEnumerator Plugin_ShowUsagePresenceOnJoinLobby_Effects()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Plugin_ShowUsagePresenceOnJoinLobby_Effects>d__8(0);
		}

		protected override void Unload()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			Reloaded = true;
			OnStartAuthority_Postfix.OnInvoke -= new EventHandler(OnStartAuthority_Postfix_OnInvoke);
			Init_LoadScreenDisable_Postfix.OnInvoke -= new EventHandler(Init_LoadScreenDisable_Postfix_OnInvoke);
			((MonoBehaviour)this).StopAllCoroutines();
			Lobby.Instance.Unload();
			Tanuki.Atlyss.FluffUtilities.Managers.PlayerAppearance.Instance.Unload();
			Tanuki.Atlyss.FluffUtilities.Managers.GlobalRaceDisplayParameters.Instance.Unload();
			Hotkey.Instance.Reset();
		}
	}
	internal static class PluginInfo
	{
		public const string ID = "cc8615a747a44321be7911e36887b64a";

		public const string Version = "1.0.15";
	}
}
namespace Tanuki.Atlyss.FluffUtilities.Models.Configuration
{
	internal class NoClip
	{
		private const string Section = "NoClip";

		public ConfigEntry<float> Speed = ConfigFile.Bind<float>("NoClip", "Speed", 50f, (ConfigDescription)null);

		public ConfigEntry<float> AlternativeSpeed = ConfigFile.Bind<float>("NoClip", "AlternativeSpeed", 150f, (ConfigDescription)null);

		public NoClip(ref ConfigFile ConfigFile)
		{
		}
	}
	internal class General
	{
		private const string Section = "General";

		public ConfigEntry<bool> Plugin_ShowUsagePresenceOnJoin = ConfigFile.Bind<bool>("General", "Plugin_ShowUsagePresenceOnJoin", true, (ConfigDescription)null);

		public ConfigEntry<bool> Plugin_ShowOtherPluginUserMessageOnJoin = ConfigFile.Bind<bool>("General", "Plugin_ShowOtherPluginUserMessageOnJoin", true, (ConfigDescription)null);

		public General(ref ConfigFile ConfigFile)
		{
		}
	}
	internal class Commands
	{
		private const string Section = "Commands";

		public ConfigEntry<string> SteamProfile_LinkTemplate = ConfigFile.Bind<string>("Commands", "SteamProfile_LinkTemplate", "https://steamcommunity.com/profiles/{0}", (ConfigDescription)null);

		public Commands(ref ConfigFile ConfigFile)
		{
		}
	}
	internal class FreeCamera
	{
		private const string Section = "FreeCamera";

		public ConfigEntry<float> Speed = ConfigFile.Bind<float>("FreeCamera", "Speed", 20f, (ConfigDescription)null);

		public ConfigEntry<float> ScrollSpeedAdjustmentStep = ConfigFile.Bind<float>("FreeCamera", "ScrollSpeedAdjustmentStep", 5f, (ConfigDescription)null);

		public ConfigEntry<bool> LockCharacterControls = ConfigFile.Bind<bool>("FreeCamera", "LockCharacterControls", true, (ConfigDescription)null);

		public ConfigEntry<bool> SmoothLookMode = ConfigFile.Bind<bool>("FreeCamera", "SmoothLookMode", false, (ConfigDescription)null);

		public ConfigEntry<float> SmoothLookModeInterpolation = ConfigFile.Bind<float>("FreeCamera", "SmoothLookModeInterpolation", 5f, (ConfigDescription)null);

		public FreeCamera(ref ConfigFile ConfigFile)
		{
		}
	}
	internal class Hotkeys
	{
		public class PlayerAppearanceHotkey
		{
			public ConfigEntry<float> Step = ConfigFile.Bind<float>("Hotkeys", Name + "_Step", Step, (ConfigDescription)null);

			public ConfigEntry<KeyCode> Increase = ConfigFile.Bind<KeyCode>("Hotkeys", Name + "_Increase", Increase, (ConfigDescription)null);

			public ConfigEntry<KeyCode> Decrease = ConfigFile.Bind<KeyCode>("Hotkeys", Name + "_Decrease", Decrease, (ConfigDescription)null);

			public PlayerAppearanceHotkey(ref ConfigFile ConfigFile, string Name, float Step, KeyCode Decrease, KeyCode Increase)
			{
			}//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)

		}

		private const string Section = "Hotkeys";

		public PlayerAppearanceHotkey PlayerAppearance_ModifyHeadWidth = new PlayerAppearanceHotkey(ref ConfigFile, "HeadWidth", 0.25f, (KeyCode)263, (KeyCode)265);

		public PlayerAppearanceHotkey PlayerAppearance_ModifyMuzzleLength = new PlayerAppearanceHotkey(ref ConfigFile, "MuzzleLength", 25f, (KeyCode)0, (KeyCode)0);

		public PlayerAppearanceHotkey PlayerAppearance_ModifyHeight = new PlayerAppearanceHotkey(ref ConfigFile, "Height", 0.1f, (KeyCode)0, (KeyCode)0);

		public PlayerAppearanceHotkey PlayerAppearance_ModifyWidth = new PlayerAppearanceHotkey(ref ConfigFile, "Width", 0.1f, (KeyCode)0, (KeyCode)0);

		public PlayerAppearanceHotkey PlayerAppearance_ModifyTorsoSize = new PlayerAppearanceHotkey(ref ConfigFile, "TorsoSize", 25f, (KeyCode)0, (KeyCode)0);

		public PlayerAppearanceHotkey PlayerAppearance_ModifyBreastSize = new PlayerAppearanceHotkey(ref ConfigFile, "BreastSize", 25f, (KeyCode)260, (KeyCode)262);

		public PlayerAppearanceHotkey PlayerAppearance_ModifyArmsSize = new PlayerAppearanceHotkey(ref ConfigFile, "ArmsSize", 25f, (KeyCode)0, (KeyCode)0);

		public PlayerAppearanceHotkey PlayerAppearance_ModifyBellySize = new PlayerAppearanceHotkey(ref ConfigFile, "BellySize", 25f, (KeyCode)258, (KeyCode)261);

		public PlayerAppearanceHotkey PlayerAppearance_ModifyBottomSize = new PlayerAppearanceHotkey(ref ConfigFile, "BottomSize", 25f, (KeyCode)257, (KeyCode)259);

		public PlayerAppearanceHotkey PlayerAppearance_ModifyVoicePitch = new PlayerAppearanceHotkey(ref ConfigFile, "VoicePitch", 0.01f, (KeyCode)0, (KeyCode)0);

		public ConfigEntry<KeyCode> FreeCamera = ConfigFile.Bind<KeyCode>("Hotkeys", "FreeCamera", (KeyCode)279, (ConfigDescription)null);

		public ConfigEntry<KeyCode> FreeCamera_Forward = ConfigFile.Bind<KeyCode>("Hotkeys", "FreeCamera_Forward", (KeyCode)119, (ConfigDescription)null);

		public ConfigEntry<KeyCode> FreeCamera_Right = ConfigFile.Bind<KeyCode>("Hotkeys", "FreeCamera_Right", (KeyCode)100, (ConfigDescription)null);

		public ConfigEntry<KeyCode> FreeCamera_Backward = ConfigFile.Bind<KeyCode>("Hotkeys", "FreeCamera_Backward", (KeyCode)115, (ConfigDescription)null);

		public ConfigEntry<KeyCode> FreeCamera_Left = ConfigFile.Bind<KeyCode>("Hotkeys", "FreeCamera_Left", (KeyCode)97, (ConfigDescription)null);

		public ConfigEntry<KeyCode> FreeCamera_Up = ConfigFile.Bind<KeyCode>("Hotkeys", "FreeCamera_Up", (KeyCode)32, (ConfigDescription)null);

		public ConfigEntry<KeyCode> FreeCamera_Down = ConfigFile.Bind<KeyCode>("Hotkeys", "FreeCamera_Down", (KeyCode)304, (ConfigDescription)null);

		public ConfigEntry<KeyCode> NoClip_Toggle = ConfigFile.Bind<KeyCode>("Hotkeys", "NoClip_Toggle", (KeyCode)127, (ConfigDescription)null);

		public ConfigEntry<KeyCode> NoClip_AlternativeSpeedKey = ConfigFile.Bind<KeyCode>("Hotkeys", "NoClip_AlternativeSpeedKey", (KeyCode)304, (ConfigDescription)null);

		public ConfigEntry<KeyCode> NoClip_Forward = ConfigFile.Bind<KeyCode>("Hotkeys", "NoClip_Forward", (KeyCode)119, (ConfigDescription)null);

		public ConfigEntry<KeyCode> NoClip_Right = ConfigFile.Bind<KeyCode>("Hotkeys", "NoClip_Right", (KeyCode)100, (ConfigDescription)null);

		public ConfigEntry<KeyCode> NoClip_Backward = ConfigFile.Bind<KeyCode>("Hotkeys", "NoClip_Backward", (KeyCode)115, (ConfigDescription)null);

		public ConfigEntry<KeyCode> NoClip_Left = ConfigFile.Bind<KeyCode>("Hotkeys", "NoClip_Left", (KeyCode)97, (ConfigDescription)null);

		public ConfigEntry<KeyCode> NoClip_Up = ConfigFile.Bind<KeyCode>("Hotkeys", "NoClip_Up", (KeyCode)32, (ConfigDescription)null);

		public ConfigEntry<KeyCode> NoClip_Down = ConfigFile.Bind<KeyCode>("Hotkeys", "NoClip_Down", (KeyCode)306, (ConfigDescription)null);

		public Hotkeys(ref ConfigFile ConfigFile)
		{
		}
	}
	internal class PlayerAppearance
	{
		private const string Section = "PlayerAppearance";

		public ConfigEntry<bool> AllowParametersBeyondLimits = ConfigFile.Bind<bool>("PlayerAppearance", "AllowParametersBeyondLimits", true, (ConfigDescription)null);

		public ConfigEntry<bool> HotkeysUpdateCharacterSave = ConfigFile.Bind<bool>("PlayerAppearance", "HotkeysUpdateCharacterSave", true, (ConfigDescription)null);

		public PlayerAppearance(ref ConfigFile ConfigFile)
		{
		}
	}
	internal class GlobalRaceDisplayParameters
	{
		public class RangeParameter
		{
			public ConfigEntry<float> Minimum = ConfigFile.Bind<float>("GlobalRaceDisplayParameters", Name + "_Minimum", Minimum, (ConfigDescription)null);

			public ConfigEntry<float> Maximum = ConfigFile.Bind<float>("GlobalRaceDisplayParameters", Name + "_Maximum", Maximum, (ConfigDescription)null);

			public Vector2 AsVector2 => new Vector2(Minimum.Value, Maximum.Value);

			public RangeParameter(ref ConfigFile ConfigFile, string Name, float Minimum, float Maximum)
			{
			}
		}

		private const string Section = "GlobalRaceDisplayParameters";

		public ConfigEntry<bool> Override = ConfigFile.Bind<bool>("GlobalRaceDisplayParameters", "Enabled", true, (ConfigDescription)null);

		public RangeParameter HeadWidth = new RangeParameter(ref ConfigFile, "HeadWidth", 0f, 4f);

		public RangeParameter MuzzleLength = new RangeParameter(ref ConfigFile, "MuzzleLength", -500f, 1000f);

		public RangeParameter Height = new RangeParameter(ref ConfigFile, "Height", 0f, 5f);

		public RangeParameter Width = new RangeParameter(ref ConfigFile, "Width", 0f, 5f);

		public RangeParameter TorsoSize = new RangeParameter(ref ConfigFile, "TorsoSize", -100f, 1000f);

		public RangeParameter BreastSize = new RangeParameter(ref ConfigFile, "BreastSize", -100f, 1000f);

		public RangeParameter ArmsSize = new RangeParameter(ref ConfigFile, "ArmsSize", -200f, 1000f);

		public RangeParameter BellySize = new RangeParameter(ref ConfigFile, "BellySize", -300f, 1000f);

		public RangeParameter BottomSize = new RangeParameter(ref ConfigFile, "BottomSize", -300f, 1000f);

		public RangeParameter VoicePitch = new RangeParameter(ref ConfigFile, "VoicePitch", 0.05f, 3f);

		public GlobalRaceDisplayParameters(ref ConfigFile ConfigFile)
		{
		}
	}
}
namespace Tanuki.Atlyss.FluffUtilities.Managers
{
	internal class FreeCamera
	{
		public static FreeCamera Instance;

		private Tanuki.Atlyss.FluffUtilities.Components.FreeCamera Component;

		public KeyCode Forward;

		public KeyCode Right;

		public KeyCode Backward;

		public KeyCode Left;

		public KeyCode Up;

		public KeyCode Down;

		public float ScrollSpeedAdjustmentStep;

		public bool Status;

		private bool LockCharacterControls;

		private FreeCamera()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			OnStopClient_Prefix.OnInvoke += new EventHandler(OnStopClient_Prefix_OnInvoke);
		}

		public static void Initialize()
		{
			if (Instance == null)
			{
				Instance = new FreeCamera();
			}
		}

		public void Reload()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			Forward = Configuration.Instance.Hotkeys.FreeCamera_Forward.Value;
			Right = Configuration.Instance.Hotkeys.FreeCamera_Right.Value;
			Backward = Configuration.Instance.Hotkeys.FreeCamera_Backward.Value;
			Left = Configuration.Instance.Hotkeys.FreeCamera_Left.Value;
			Up = Configuration.Instance.Hotkeys.FreeCamera_Up.Value;
			Down = Configuration.Instance.Hotkeys.FreeCamera_Down.Value;
			ScrollSpeedAdjustmentStep = Configuration.Instance.FreeCamera.ScrollSpeedAdjustmentStep.Value;
		}

		public void Enable(bool LockCharacterControls, bool SmoothLook)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			NoClip.Instance.Disable();
			if (Component == null)
			{
				Component = ((Component)CameraFunction._current._mainCamera).gameObject.AddComponent<Tanuki.Atlyss.FluffUtilities.Components.FreeCamera>();
			}
			if (!Status)
			{
				Component.Speed = Configuration.Instance.FreeCamera.Speed.Value;
				Status = true;
			}
			this.LockCharacterControls = LockCharacterControls;
			if (LockCharacterControls)
			{
				Client_LocalPlayerControl_Prefix.OnInvoke += new EventHandler(Client_LocalPlayerControl_Prefix_OnInvoke);
			}
			Component.SmoothLookMode = SmoothLook;
			if (SmoothLook)
			{
				Component.SmoothLookModeInterpolation = Configuration.Instance.FreeCamera.SmoothLookModeInterpolation.Value;
			}
			((Behaviour)Component).enabled = true;
			((Behaviour)CameraFunction._current).enabled = false;
			((Behaviour)CameraCollision._current).enabled = false;
			Cursor.lockState = (CursorLockMode)1;
			Cursor.visible = false;
		}

		public void Disable()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (Status)
			{
				if (LockCharacterControls)
				{
					Client_LocalPlayerControl_Prefix.OnInvoke -= new EventHandler(Client_LocalPlayerControl_Prefix_OnInvoke);
				}
				((Behaviour)CameraFunction._current).enabled = true;
				((Behaviour)CameraCollision._current).enabled = true;
				Status = false;
				((Behaviour)Component).enabled = false;
			}
		}

		private void Client_LocalPlayerControl_Prefix_OnInvoke(PlayerMove PlayerMove, ref bool ShouldAllow)
		{
			if (((NetworkBehaviour)PlayerMove).isLocalPlayer)
			{
				ShouldAllow = false;
			}
		}

		private void OnStopClient_Prefix_OnInvoke()
		{
			Disable();
			if (Object.op_Implicit((Object)(object)Component))
			{
				Object.Destroy((Object)(object)Component);
				Component = null;
			}
		}
	}
	internal class GlobalRaceDisplayParameters
	{
		public static GlobalRaceDisplayParameters Instance;

		private bool Enabled;

		private bool Reloaded;

		private GlobalRaceDisplayParameters()
		{
		}

		public static void Initialize()
		{
			if (Instance == null)
			{
				Instance = new GlobalRaceDisplayParameters();
			}
		}

		public void Load()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			Enabled = Configuration.Instance.PlayerAppearance.AllowParametersBeyondLimits.Value;
			if (Enabled)
			{
				if (Reloaded)
				{
					Override();
					return;
				}
				Main.Instance.Patch(typeof(Cache_ScriptableAssets_Postfix));
				Cache_ScriptableAssets_Postfix.OnInvoke += new EventHandler(Override);
			}
		}

		public void Unload()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			Reloaded = true;
			if (Enabled)
			{
				Cache_ScriptableAssets_Postfix.OnInvoke -= new EventHandler(Override);
			}
		}

		public void Override()
		{
			//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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			foreach (ScriptablePlayerRace value in GameManager.Instance.CachedScriptableRaces.Values)
			{
				CharacterParamsGroup raceDisplayParams = value._raceDisplayParams;
				raceDisplayParams._headWidthRange = Configuration.Instance.GlobalRaceDisplayParameters.HeadWidth.AsVector2;
				raceDisplayParams._headModRange = Configuration.Instance.GlobalRaceDisplayParameters.MuzzleLength.AsVector2;
				raceDisplayParams._heightRange = Configuration.Instance.GlobalRaceDisplayParameters.Height.AsVector2;
				raceDisplayParams._widthRange = Configuration.Instance.GlobalRaceDisplayParameters.Width.AsVector2;
				raceDisplayParams._torsoRange = Configuration.Instance.GlobalRaceDisplayParameters.TorsoSize.AsVector2;
				raceDisplayParams._boobRange = Configuration.Instance.GlobalRaceDisplayParameters.BreastSize.AsVector2;
				raceDisplayParams._armRange = Configuration.Instance.GlobalRaceDisplayParameters.ArmsSize.AsVector2;
				raceDisplayParams._bellyRange = Configuration.Instance.GlobalRaceDisplayParameters.BellySize.AsVector2;
				raceDisplayParams._bottomRange = Configuration.Instance.GlobalRaceDisplayParameters.BottomSize.AsVector2;
				raceDisplayParams._pitchRange = Configuration.Instance.GlobalRaceDisplayParameters.VoicePitch.AsVector2;
			}
		}
	}
	internal class Hotkey : MonoBehaviour
	{
		private class HotkeyActionGroup : IComparable<HotkeyActionGroup>
		{
			public KeyCode KeyCode;

			public HashSet<Action> Actions;

			public HotkeyActionGroup(KeyCode KeyCode)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				this.KeyCode = KeyCode;
				Actions = new HashSet<Action>();
				base..ctor();
			}

			public int CompareTo(HotkeyActionGroup HotkeyActionGroup)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return ((Enum)(KeyCode)(ref KeyCode)).CompareTo((object?)HotkeyActionGroup.KeyCode);
			}
		}

		public static Hotkey Instance;

		private readonly SortedSet<HotkeyActionGroup> HotkeyActionGroups;

		private readonly IInputSystem InputSystem;

		private Hotkey()
		{
			HotkeyActionGroups = new SortedSet<HotkeyActionGroup>();
			InputSystem = UnityInput.Current;
		}

		public static void Initialize()
		{
			if (Instance == null)
			{
				Instance = ((Component)Main.Instance).gameObject.AddComponent<Hotkey>();
				Object.DontDestroyOnLoad((Object)(object)Instance);
			}
		}

		public void BindAction(KeyCode KeyCode, Action Action)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			if ((int)KeyCode != 0)
			{
				HotkeyActionGroup hotkeyActionGroup = HotkeyActionGroups.Where((HotkeyActionGroup x) => x.KeyCode == KeyCode).SingleOrDefault();
				if (hotkeyActionGroup == null)
				{
					hotkeyActionGroup = new HotkeyActionGroup(KeyCode);
					HotkeyActionGroups.Add(hotkeyActionGroup);
				}
				hotkeyActionGroup.Actions.Add(Action);
				((Behaviour)this).enabled = true;
			}
		}

		public void UnbindAction(Action Action)
		{
			List<HotkeyActionGroup> list = new List<HotkeyActionGroup>();
			foreach (HotkeyActionGroup hotkeyActionGroup in HotkeyActionGroups)
			{
				hotkeyActionGroup.Actions.Remove(Action);
				if (hotkeyActionGroup.Actions.Count <= 0)
				{
					list.Add(hotkeyActionGroup);
				}
			}
			list.ForEach(delegate(HotkeyActionGroup x)
			{
				HotkeyActionGroups.Remove(x);
			});
		}

		public void UnbindAction(KeyCode KeyCode, Action Action)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			HotkeyActionGroup hotkeyActionGroup = HotkeyActionGroups.Where((HotkeyActionGroup x) => x.KeyCode == KeyCode).SingleOrDefault();
			if (hotkeyActionGroup != null)
			{
				hotkeyActionGroup.Actions.Remove(Action);
				if (hotkeyActionGroup.Actions.Count == 0)
				{
					HotkeyActionGroups.Remove(hotkeyActionGroup);
				}
			}
		}

		public void Reset()
		{
			((Behaviour)this).enabled = false;
			HotkeyActionGroups.Clear();
		}

		private void Awake()
		{
			((Behaviour)this).enabled = false;
		}

		private void Update()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			foreach (HotkeyActionGroup hotkeyActionGroup in HotkeyActionGroups)
			{
				if (!InputSystem.GetKeyDown(hotkeyActionGroup.KeyCode))
				{
					continue;
				}
				foreach (Action action in hotkeyActionGroup.Actions)
				{
					action();
				}
			}
		}
	}
	internal class Lobby
	{
		[CompilerGenerated]
		private sealed class <CheckPlayerPlugin>d__9 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player Player;

			public Lobby <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Expected O, but got Unknown
				//IL_008f: 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)
				int num = <>1__state;
				Lobby lobby = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (Object.op_Implicit((Object)(object)Player) && (int)Player._currentPlayerCondition == 0)
				{
					<>2__current = (object)new WaitForSeconds(0.3f);
					<>1__state = 1;
					return true;
				}
				if (!Object.op_Implicit((Object)(object)Player))
				{
					return false;
				}
				if (((NetworkBehaviour)Player).isLocalPlayer)
				{
					return false;
				}
				if (!ulong.TryParse(Player._steamID, out var result))
				{
					return false;
				}
				string lobbyMemberData = SteamMatchmaking.GetLobbyMemberData(lobby.LobbyID, new CSteamID(result), "cc8615a747a44321be7911e36887b64a.ver");
				if (string.IsNullOrEmpty(lobbyMemberData))
				{
					return false;
				}
				ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("General.OtherPluginUserMessage", new object[4]
				{
					((NetworkBehaviour)Player).netId,
					Player._nickname,
					string.IsNullOrEmpty(Player._globalNickname) ? string.Empty : ((Plugin)Main.Instance).Translate("General.OtherPluginUserMessage.GlobalNickname", new object[1] { Player._globalNickname }),
					lobbyMemberData
				}));
				return false;
			}

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

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

		public static Lobby Instance;

		public CSteamID LobbyID = CSteamID.Nil;

		public CSteamID PlayerID = CSteamID.Nil;

		public const string LobbyMemberDataKey_Version = "cc8615a747a44321be7911e36887b64a.ver";

		private Lobby()
		{
			//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_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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			OnStartAuthority_Postfix.OnInvoke += new EventHandler(OnStartAuthority_Postfix_OnInvoke);
			OnStopClient_Prefix.OnInvoke += new EventHandler(OnStopClient_Prefix_OnInvoke);
		}

		public static void Initialize()
		{
			if (Instance == null)
			{
				Instance = new Lobby();
			}
		}

		public void Load()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			if (Configuration.Instance.General.Plugin_ShowOtherPluginUserMessageOnJoin.Value)
			{
				Main.Instance.Patch(typeof(Awake_Postfix));
				Awake_Postfix.OnInvoke += new EventHandler(Awake_Postfix_OnInvoke);
			}
		}

		public void Unload()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (Configuration.Instance.General.Plugin_ShowOtherPluginUserMessageOnJoin.Value)
			{
				Awake_Postfix.OnInvoke -= new EventHandler(Awake_Postfix_OnInvoke);
			}
		}

		private void Awake_Postfix_OnInvoke(Player Player)
		{
			if (Object.op_Implicit((Object)(object)Player._mainPlayer))
			{
				((MonoBehaviour)Main.Instance).StartCoroutine(CheckPlayerPlugin(Player));
			}
		}

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

		private void OnStartAuthority_Postfix_OnInvoke()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!AtlyssNetworkManager._current._soloMode)
			{
				LobbyID = new CSteamID(SteamLobby._current._currentLobbyID);
				PlayerID = (CSteamID)(Player._mainPlayer._isHostPlayer ? SteamMatchmaking.GetLobbyOwner(LobbyID) : new CSteamID(ulong.Parse(Player._mainPlayer._steamID)));
				SteamMatchmaking.SetLobbyMemberData(LobbyID, "cc8615a747a44321be7911e36887b64a.ver", "1.0.15");
			}
		}

		private void OnStopClient_Prefix_OnInvoke()
		{
			//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)
			LobbyID = CSteamID.Nil;
		}
	}
	internal class NessieEasySettings
	{
		internal static NessieEasySettings Instance;

		private NessieEasySettings()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			Settings.OnInitialized.AddListener(new UnityAction(NessieEasySettings_OnInitialize));
			Settings.OnApplySettings.AddListener(new UnityAction(NessieEasySettings_OnApplySettings));
		}

		public static void Initialize()
		{
			if (Instance == null)
			{
				Instance = new NessieEasySettings();
			}
		}

		private void NessieEasySettings_OnInitialize()
		{
			SettingsTab modTab = Settings.ModTab;
			modTab.AddHeader("- Tanuki Atlyss FluffUtilities -");
			modTab.AddHeader("Free camera");
			modTab.AddKeyButton("Toggle", Configuration.Instance.Hotkeys.FreeCamera);
			modTab.AddKeyButton("Movement • Forward", Configuration.Instance.Hotkeys.FreeCamera_Forward);
			modTab.AddKeyButton("Movement • Right", Configuration.Instance.Hotkeys.FreeCamera_Right);
			modTab.AddKeyButton("Movement • Backward", Configuration.Instance.Hotkeys.FreeCamera_Backward);
			modTab.AddKeyButton("Movement • Left", Configuration.Instance.Hotkeys.FreeCamera_Left);
			modTab.AddKeyButton("Movement • Up", Configuration.Instance.Hotkeys.FreeCamera_Up);
			modTab.AddKeyButton("Movement • Down", Configuration.Instance.Hotkeys.FreeCamera_Down);
			modTab.AddToggle("Lock character controls", Configuration.Instance.FreeCamera.LockCharacterControls);
			modTab.AddAdvancedSlider("Speed", Configuration.Instance.FreeCamera.Speed.Value, 1f, 100f, true).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.FreeCamera.Speed.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddAdvancedSlider("Speed • Scroll adjustment step", Configuration.Instance.FreeCamera.ScrollSpeedAdjustmentStep.Value, 1f, 25f, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.FreeCamera.ScrollSpeedAdjustmentStep.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddToggle("Smooth mode", Configuration.Instance.FreeCamera.SmoothLookMode);
			modTab.AddAdvancedSlider("Smooth mode • Interpolation", Configuration.Instance.FreeCamera.SmoothLookModeInterpolation.Value, 1f, 10f, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.FreeCamera.SmoothLookModeInterpolation.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddHeader("No clip");
			modTab.AddKeyButton("Toggle", Configuration.Instance.Hotkeys.NoClip_Toggle);
			modTab.AddKeyButton("Movement • Forward", Configuration.Instance.Hotkeys.NoClip_Forward);
			modTab.AddKeyButton("Movement • Right", Configuration.Instance.Hotkeys.NoClip_Right);
			modTab.AddKeyButton("Movement • Backward", Configuration.Instance.Hotkeys.NoClip_Backward);
			modTab.AddKeyButton("Movement • Left", Configuration.Instance.Hotkeys.NoClip_Left);
			modTab.AddKeyButton("Movement • Up", Configuration.Instance.Hotkeys.NoClip_Up);
			modTab.AddKeyButton("Movement • Down", Configuration.Instance.Hotkeys.NoClip_Down);
			modTab.AddKeyButton("Movement • Alternative Speed", Configuration.Instance.Hotkeys.NoClip_AlternativeSpeedKey);
			modTab.AddAdvancedSlider("Speed", Configuration.Instance.NoClip.Speed.Value, 0.01f, 250f, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.NoClip.Speed.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddAdvancedSlider("Alternative speed", Configuration.Instance.NoClip.AlternativeSpeed.Value, 0.01f, 1000f, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.NoClip.AlternativeSpeed.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddHeader("Player Appearance");
			modTab.AddToggle("Allow parameters beyond limits", Configuration.Instance.PlayerAppearance.AllowParametersBeyondLimits);
			modTab.AddToggle("Hotkeys update character save", Configuration.Instance.PlayerAppearance.HotkeysUpdateCharacterSave);
			modTab.AddSpace();
			modTab.AddKeyButton("Head width • Decrease", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeadWidth.Decrease);
			modTab.AddKeyButton("Head width • Increase", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeadWidth.Increase);
			modTab.AddAdvancedSlider("Head width • Step", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeadWidth.Step.Value, 0f, Configuration.Instance.GlobalRaceDisplayParameters.HeadWidth.Maximum.Value, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeadWidth.Step.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddKeyButton("Muzzle length • Decrease", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyMuzzleLength.Decrease);
			modTab.AddKeyButton("Muzzle length • Increase", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyMuzzleLength.Increase);
			modTab.AddAdvancedSlider("Muzzle length • Step", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyMuzzleLength.Step.Value, 0f, Configuration.Instance.GlobalRaceDisplayParameters.MuzzleLength.Maximum.Value, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.Hotkeys.PlayerAppearance_ModifyMuzzleLength.Step.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddKeyButton("Height • Decrease", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeight.Decrease);
			modTab.AddKeyButton("Height • Increase", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeight.Increase);
			modTab.AddAdvancedSlider("Height • Step", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeight.Step.Value, 0f, Configuration.Instance.GlobalRaceDisplayParameters.Height.Maximum.Value, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.Hotkeys.PlayerAppearance_ModifyHeight.Step.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddKeyButton("Width • Decrease", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyWidth.Decrease);
			modTab.AddKeyButton("Width • Increase", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyWidth.Increase);
			modTab.AddAdvancedSlider("Width • Step", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyWidth.Step.Value, 0f, Configuration.Instance.GlobalRaceDisplayParameters.Width.Maximum.Value, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.Hotkeys.PlayerAppearance_ModifyWidth.Step.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddKeyButton("Torso size • Decrease", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyTorsoSize.Decrease);
			modTab.AddKeyButton("Torso size • Increase", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyTorsoSize.Increase);
			modTab.AddAdvancedSlider("Torso size • Step", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyTorsoSize.Step.Value, 0f, Configuration.Instance.GlobalRaceDisplayParameters.TorsoSize.Maximum.Value, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.Hotkeys.PlayerAppearance_ModifyTorsoSize.Step.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddKeyButton("Breast size • Decrease", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBreastSize.Decrease);
			modTab.AddKeyButton("Breast size • Increase", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBreastSize.Increase);
			modTab.AddAdvancedSlider("Breast size • Step", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBreastSize.Step.Value, 0f, Configuration.Instance.GlobalRaceDisplayParameters.BreastSize.Maximum.Value, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBreastSize.Step.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddKeyButton("Arms size • Decrease", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyArmsSize.Decrease);
			modTab.AddKeyButton("Arms size • Increase", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyArmsSize.Increase);
			modTab.AddAdvancedSlider("Arms size • Step", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyArmsSize.Step.Value, 0f, Configuration.Instance.GlobalRaceDisplayParameters.ArmsSize.Maximum.Value, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.Hotkeys.PlayerAppearance_ModifyArmsSize.Step.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddKeyButton("Belly size • Decrease", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBellySize.Decrease);
			modTab.AddKeyButton("Belly size • Increase", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBellySize.Increase);
			modTab.AddAdvancedSlider("Belly size • Step", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBellySize.Step.Value, 0f, Configuration.Instance.GlobalRaceDisplayParameters.BellySize.Maximum.Value, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBellySize.Step.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddKeyButton("Bottom size • Decrease", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBottomSize.Decrease);
			modTab.AddKeyButton("Bottom size • Increase", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBottomSize.Increase);
			modTab.AddAdvancedSlider("Bottom size • Step", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBottomSize.Step.Value, 0f, Configuration.Instance.GlobalRaceDisplayParameters.BottomSize.Maximum.Value, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.Hotkeys.PlayerAppearance_ModifyBottomSize.Step.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
			modTab.AddKeyButton("Voice pitch • Decrease", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyVoicePitch.Decrease);
			modTab.AddKeyButton("Voice pitch • Increase", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyVoicePitch.Increase);
			modTab.AddAdvancedSlider("Voice pitch • Step", Configuration.Instance.Hotkeys.PlayerAppearance_ModifyVoicePitch.Step.Value, 0f, Configuration.Instance.GlobalRaceDisplayParameters.VoicePitch.Maximum.Value, false).OnValueChanged.AddListener((UnityAction<float>)delegate(float Value)
			{
				Configuration.Instance.Hotkeys.PlayerAppearance_ModifyVoicePitch.Step.Value = (float)Math.Round(Value, 2);
			});
			modTab.AddSpace();
		}

		private void NessieEasySettings_OnApplySettings()
		{
			Configuration.Instance.Load(((BaseUnityPlugin)Main.Instance).Config);
			PlayerAppearance.Instance.Reload();
			FreeCamera.Instance.Reload();
			NoClip.Instance.Reload();
			Main.Instance.ReloadHotkeys();
		}
	}
	internal class NoClip
	{
		public static NoClip Instance;

		private Tanuki.Atlyss.FluffUtilities.Components.NoClip Component;

		public bool Status;

		public KeyCode Forward;

		public KeyCode Right;

		public KeyCode Backward;

		public KeyCode Left;

		public KeyCode Up;

		public KeyCode Down;

		public KeyCode AlternativeSpeedKey;

		public float Speed;

		public float AlternativeSpeed;

		private NoClip()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			OnStopClient_Prefix.OnInvoke += new EventHandler(OnStopClient_Prefix_OnInvoke);
		}

		public static void Initialize()
		{
			Instance = new NoClip();
		}

		public void Reload()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			Forward = Configuration.Instance.Hotkeys.NoClip_Forward.Value;
			Right = Configuration.Instance.Hotkeys.NoClip_Right.Value;
			Backward = Configuration.Instance.Hotkeys.NoClip_Backward.Value;
			Left = Configuration.Instance.Hotkeys.NoClip_Left.Value;
			Up = Configuration.Instance.Hotkeys.NoClip_Up.Value;
			Down = Configuration.Instance.Hotkeys.NoClip_Down.Value;
			Speed = Configuration.Instance.NoClip.Speed.Value;
			AlternativeSpeedKey = Configuration.Instance.Hotkeys.NoClip_AlternativeSpeedKey.Value;
			AlternativeSpeed = Configuration.Instance.NoClip.AlternativeSpeed.Value;
		}

		public void Enable()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			if (FreeCamera.Instance.Status)
			{
				((Component)CameraCollision._current).transform.localPosition = CameraCollision._current.dollyDir * CameraCollision._current.distance;
				FreeCamera.Instance.Disable();
			}
			if (Component == null)
			{
				Component = ((Component)((Component)Player._mainPlayer._pMove).transform).gameObject.AddComponent<Tanuki.Atlyss.FluffUtilities.Components.NoClip>();
			}
			Status = true;
			Client_LocalPlayerControl_Prefix.OnInvoke += new EventHandler(Client_LocalPlayerControl_Prefix_OnInvoke);
			((Collider)Player._mainPlayer._pMove._playerController).enabled = false;
			((Behaviour)CameraCollision._current).enabled = false;
			((Behaviour)Component).enabled = true;
		}

		public void Disable()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (Status)
			{
				Client_LocalPlayerControl_Prefix.OnInvoke -= new EventHandler(Client_LocalPlayerControl_Prefix_OnInvoke);
				((Collider)Player._mainPlayer._pMove._playerController).enabled = true;
				((Behaviour)CameraCollision._current).enabled = true;
				Status = false;
				((Behaviour)Component).enabled = false;
			}
		}

		private void Client_LocalPlayerControl_Prefix_OnInvoke(PlayerMove PlayerMove, ref bool ShouldAllow)
		{
			if (((NetworkBehaviour)PlayerMove).isLocalPlayer)
			{
				ShouldAllow = false;
			}
		}

		private void OnStopClient_Prefix_OnInvoke()
		{
			Disable();
			if (Object.op_Implicit((Object)(object)Component))
			{
				Object.Destroy((Object)(object)Component);
				Component = null;
			}
		}
	}
	internal class PlayerAppearance
	{
		[CompilerGenerated]
		private sealed class <NewPlayerAppearanceCommand>d__9 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerAppearance <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				PlayerAppearance playerAppearance = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					playerAppearance.PendingNewPlayerAppearanceCommand = false;
					Player._mainPlayer._pVisual.Cmd_SendNew_PlayerAppearanceStruct(Player._mainPlayer._pVisual._playerAppearanceStruct);
					return false;
				}
			}

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

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

		public static PlayerAppearance Instance;

		private bool AllowParametersBeyondLimits;

		private bool PendingNewPlayerAppearanceCommand;

		private PlayerAppearance()
		{
		}

		public static void Initialize()
		{
			if (Instance == null)
			{
				Instance = new PlayerAppearance();
			}
		}

		public void Load()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			Main.Instance.Patch(typeof(Apply_NetworkedCharacterDisplay_Prefix));
			AllowParametersBeyondLimits = Configuration.Instance.PlayerAppearance.AllowParametersBeyondLimits.Value;
			PendingNewPlayerAppearanceCommand = false;
			if (AllowParametersBeyondLimits)
			{
				Main.Instance.Patch(typeof(Init_ParamsCheck_Prefix));
				Init_ParamsCheck_Prefix.OnInvoke += new EventHandler(Init_ParamsCheck_Prefix_OnInvoke);
			}
			OnStartAuthority_Postfix.OnInvoke += new EventHandler(OnStartAuthority_Postfix_OnInvoke);
			OnStopClient_Prefix.OnInvoke += new EventHandler(OnStopClient_Prefix_OnInvoke);
		}

		private void OnStopClient_Prefix_OnInvoke()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Apply_NetworkedCharacterDisplay_Prefix.OnInvoke -= new EventHandler(Apply_NetworkedCharacterDisplay_Prefix_OnInvoke_OnJoin);
		}

		private void Apply_NetworkedCharacterDisplay_Prefix_OnInvoke_OnJoin(PlayerVisual PlayerVisual)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)PlayerVisual).isLocalPlayer)
			{
				Apply_NetworkedCharacterDisplay_Prefix.OnInvoke -= new EventHandler(Apply_NetworkedCharacterDisplay_Prefix_OnInvoke_OnJoin);
				PlayerAppearance_Profile appearanceProfile = ProfileDataManager._current._characterFile._appearanceProfile;
				PlayerAppearanceStruct val = default(PlayerAppearanceStruct);
				val._setRaceTag = appearanceProfile._setRaceTag;
				val._textureID = appearanceProfile._setTexture;
				val._bodyColorHue = appearanceProfile._setSkinColorProfile._hue;
				val._bodyColorBrightness = appearanceProfile._setSkinColorProfile._brightness;
				val._bodyColorContrast = appearanceProfile._setSkinColorProfile._contrast;
				val._bodyColorSaturation = appearanceProfile._setSkinColorProfile._saturation;
				val._hairStyleHue = appearanceProfile._hairColorProfile._hue;
				val._hairStyleBrightness = appearanceProfile._hairColorProfile._brightness;
				val._hairStyleContrast = appearanceProfile._hairColorProfile._contrast;
				val._hairStyleSaturation = appearanceProfile._hairColorProfile._saturation;
				val._hairIsBodyColor = appearanceProfile._hairIsBodyColor;
				val._miscHue = appearanceProfile._miscColorProfile._hue;
				val._miscBrightness = appearanceProfile._miscColorProfile._brightness;
				val._miscContrast = appearanceProfile._miscColorProfile._contrast;
				val._miscSaturation = appearanceProfile._miscColorProfile._saturation;
				val._dyeIndex = appearanceProfile._helmDyeIndex;
				val._headWidth = appearanceProfile._headWidth;
				val._muzzleWeight = appearanceProfile._muzzleWeight;
				val._hairStyleID = appearanceProfile._setHairStyle;
				val._miscID = appearanceProfile._setMisc;
				val._mouthID = appearanceProfile._setMouth;
				val._earID = appearanceProfile._setEar;
				val._eyeID = appearanceProfile._setEye;
				val._voicePitch = appearanceProfile._voicePitch;
				val._heightWeight = appearanceProfile._heightWeight;
				val._widthWeight = appearanceProfile._widthWeight;
				val._torsoWeight = appearanceProfile._torsoWeight;
				val._displayBoobs = appearanceProfile._displayBoobs;
				val._boobWeight = appearanceProfile._boobWeight;
				val._armWeight = appearanceProfile._armWeight;
				val._bellyWeight = appearanceProfile._bellyWeight;
				val._bottomWeight = appearanceProfile._bottomWeight;
				val._isLeftHanded = appearanceProfile._isLeftHanded;
				val._tailID = appearanceProfile._setTail;
				val._hideHelm = appearanceProfile._hideHelm;
				val._hideCape = appearanceProfile._hideCape;
				val._hideChest = appearanceProfile._hideChest;
				val._hideLeggings = appearanceProfile._hideLeggings;
				val._hideVanityHelm = appearanceProfile._hideVanityHelm;
				val._hideVanityCape = appearanceProfile._hideVanityCape;
				val._hideVanityChest = appearanceProfile._hideVanityChest;
				val._hideVanityLeggings = appearanceProfile._hideVanityLeggings;
				PlayerAppearanceStruct val2 = val;
				PlayerVisual.Cmd_SendNew_PlayerAppearanceStruct(val2);
			}
		}

		private void OnStartAuthority_Postfix_OnInvoke()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			if (((NetworkManager)AtlyssNetworkManager._current).isNetworkActive && !Player._mainPlayer._isHostPlayer)
			{
				Apply_NetworkedCharacterDisplay_Prefix.OnInvoke += new EventHandler(Apply_NetworkedCharacterDisplay_Prefix_OnInvoke_OnJoin);
			}
		}

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

		public void Unload()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			if (AllowParametersBeyondLimits)
			{
				Init_ParamsCheck_Prefix.OnInvoke -= new EventHandler(Init_ParamsCheck_Prefix_OnInvoke);
			}
			OnStartAuthority_Postfix.OnInvoke -= new EventHandler(OnStartAuthority_Postfix_OnInvoke);
			OnStopClient_Prefix.OnInvoke -= new EventHandler(OnStopClient_Prefix_OnInvoke);
			Apply_NetworkedCharacterDisplay_Prefix.OnInvoke -= new EventHandler(Apply_NetworkedCharacterDisplay_Prefix_OnInvoke_OnJoin);
		}

		public void Reload()
		{
			Unload();
			Load();
		}

		private void Init_ParamsCheck_Prefix_OnInvoke(PlayerAppearance_Profile PlayerAppearance, ref bool ShouldAllow)
		{
			ShouldAllow = false;
		}

		private void ApplyPlayerAppearanceStruct()
		{
			Player._mainPlayer._pVisual.Apply_NetworkedCharacterDisplay();
			if (!Player._mainPlayer._isHostPlayer && !PendingNewPlayerAppearanceCommand)
			{
				PendingNewPlayerAppearanceCommand = true;
				((MonoBehaviour)Main.Instance).StartCoroutine(NewPlayerAppearanceCommand());
			}
		}

		public void ModifyBreastSize(float Delta, bool UpdateCharacterFile)
		{
			Player._mainPlayer._pVisual._playerAppearanceStruct._boobWeight += Delta;
			if (UpdateCharacterFile)
			{
				ProfileDataManager._current._characterFile._appearanceProfile._boobWeight = Player._mainPlayer._pVisual._playerAppearanceStruct._boobWeight;
			}
			ApplyPlayerAppearanceStruct();
		}

		public void ModifyArmsSize(float Delta, bool UpdateCharacterFile)
		{
			Player._mainPlayer._pVisual._playerAppearanceStruct._armWeight += Delta;
			if (UpdateCharacterFile)
			{
				ProfileDataManager._current._characterFile._appearanceProfile._armWeight = Player._mainPlayer._pVisual._playerAppearanceStruct._armWeight;
			}
			ApplyPlayerAppearanceStruct();
		}

		public void ModifyBellySize(float Delta, bool UpdateCharacterFile)
		{
			Player._mainPlayer._pVisual._playerAppearanceStruct._bellyWeight += Delta;
			if (UpdateCharacterFile)
			{
				ProfileDataManager._current._characterFile._appearanceProfile._bellyWeight = Player._mainPlayer._pVisual._playerAppearanceStruct._bellyWeight;
			}
			ApplyPlayerAppearanceStruct();
		}

		public void ModifyBottomSize(float Delta, bool UpdateCharacterFile)
		{
			Player._mainPlayer._pVisual._playerAppearanceStruct._bottomWeight += Delta;
			if (UpdateCharacterFile)
			{
				ProfileDataManager._current._characterFile._appearanceProfile._bottomWeight = Player._mainPlayer._pVisual._playerAppearanceStruct._bottomWeight;
			}
			ApplyPlayerAppearanceStruct();
		}

		public void ModifyTorsoSize(float Delta, bool UpdateCharacterFile)
		{
			Player._mainPlayer._pVisual._playerAppearanceStruct._torsoWeight += Delta;
			if (UpdateCharacterFile)
			{
				ProfileDataManager._current._characterFile._appearanceProfile._torsoWeight = Player._mainPlayer._pVisual._playerAppearanceStruct._torsoWeight;
			}
			ApplyPlayerAppearanceStruct();
		}

		public void ModifyMuzzleLength(float Delta, bool UpdateCharacterFile)
		{
			Player._mainPlayer._pVisual._playerAppearanceStruct._muzzleWeight += Delta;
			if (UpdateCharacterFile)
			{
				ProfileDataManager._current._characterFile._appearanceProfile._muzzleWeight = Player._mainPlayer._pVisual._playerAppearanceStruct._muzzleWeight;
			}
			ApplyPlayerAppearanceStruct();
		}

		public void ModifyHeight(float Delta, bool UpdateCharacterFile)
		{
			Player._mainPlayer._pVisual._playerAppearanceStruct._heightWeight += Delta;
			if (UpdateCharacterFile)
			{
				ProfileDataManager._current._characterFile._appearanceProfile._heightWeight = Player._mainPlayer._pVisual._playerAppearanceStruct._heightWeight;
			}
			ApplyPlayerAppearanceStruct();
		}

		public void ModifyWidth(float Delta, bool UpdateCharacterFile)
		{
			Player._mainPlayer._pVisual._playerAppearanceStruct._widthWeight += Delta;
			if (UpdateCharacterFile)
			{
				ProfileDataManager._current._characterFile._appearanceProfile._widthWeight = Player._mainPlayer._pVisual._playerAppearanceStruct._widthWeight;
			}
			ApplyPlayerAppearanceStruct();
		}

		public void ModifyHeadWidth(float Delta, bool UpdateCharacterFile)
		{
			Player._mainPlayer._pVisual._playerAppearanceStruct._headWidth += Delta;
			if (UpdateCharacterFile)
			{
				ProfileDataManager._current._characterFile._appearanceProfile._headWidth = Player._mainPlayer._pVisual._playerAppearanceStruct._headWidth;
			}
			ApplyPlayerAppearanceStruct();
		}

		public void ModifyVoicePitch(float Delta, bool UpdateCharacterFile)
		{
			Player._mainPlayer._pVisual._playerAppearanceStruct._voicePitch += Delta;
			if (UpdateCharacterFile)
			{
				ProfileDataManager._current._characterFile._appearanceProfile._voicePitch = Player._mainPlayer._pVisual._playerAppearanceStruct._voicePitch;
			}
			ApplyPlayerAppearanceStruct();
		}
	}
}
namespace Tanuki.Atlyss.FluffUtilities.Components
{
	internal class FreeCamera : MonoBehaviour
	{
		private IInputSystem InputSystem;

		private bool IsUpsideDown;

		private float RotationShiftX;

		private float RotationShiftY;

		private float RotationX;

		private float RotationY;

		private Quaternion TargetRotation;

		public float Speed;

		public bool SmoothLookMode;

		public float SmoothLookModeInterpolation;

		private void Awake()
		{
			((Behaviour)this).enabled = false;
			InputSystem = UnityInput.Current;
		}

		private void OnEnable()
		{
			RotationX = CameraFunction._current._RotX;
			RotationY = CameraFunction._current._RotY;
		}

		private void OnDisable()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			((Component)CameraFunction._current._mainCamera).transform.rotation = ((Component)CameraFunction._current).transform.rotation;
			CameraFunction._current.CameraReset_Lerp();
		}

		private void Update()
		{
			HandleControl();
			HandleRotation();
			HandlePosition();
		}

		private void HandleControl()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (InputSystem.mouseScrollDelta.y != 0f)
			{
				Speed += InputSystem.mouseScrollDelta.y * Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.ScrollSpeedAdjustmentStep;
				if ((double)Speed < 0.01)
				{
					Speed = 0.01f;
				}
			}
		}

		private void HandleRotation()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			RotationShiftX = InputControlManager.current._altVert_input * CameraFunction._current.inputSensitivity;
			RotationShiftY = InputControlManager.current._altHoriz_input * CameraFunction._current.inputSensitivity;
			IsUpsideDown = Vector3.Dot(((Component)this).transform.up, Vector3.up) < 0f;
			if (IsUpsideDown)
			{
				RotationShiftY = 0f - RotationShiftY;
			}
			RotationX += RotationShiftX;
			RotationY += RotationShiftY;
			TargetRotation = Quaternion.Euler(RotationX, RotationY, 0f);
			((Component)this).transform.rotation = (SmoothLookMode ? Quaternion.Slerp(((Component)this).transform.rotation, TargetRotation, SmoothLookModeInterpolation * Time.deltaTime) : TargetRotation);
		}

		private void HandlePosition()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Left))
			{
				Transform transform = ((Component)this).transform;
				transform.position -= ((Component)this).transform.right * Speed * Time.deltaTime;
			}
			else if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Right))
			{
				Transform transform2 = ((Component)this).transform;
				transform2.position += ((Component)this).transform.right * Speed * Time.deltaTime;
			}
			if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Forward))
			{
				Transform transform3 = ((Component)this).transform;
				transform3.position += ((Component)this).transform.forward * Speed * Time.deltaTime;
			}
			else if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Backward))
			{
				Transform transform4 = ((Component)this).transform;
				transform4.position -= ((Component)this).transform.forward * Speed * Time.deltaTime;
			}
			if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Up))
			{
				Transform transform5 = ((Component)this).transform;
				transform5.position += Vector3.up * Speed * Time.deltaTime;
			}
			else if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Down))
			{
				Transform transform6 = ((Component)this).transform;
				transform6.position += Vector3.down * Speed * Time.deltaTime;
			}
		}
	}
	internal class NoClip : MonoBehaviour
	{
		public float Speed;

		private Vector3 PositionShift;

		private IInputSystem InputSystem;

		private void Awake()
		{
			((Behaviour)this).enabled = false;
			InputSystem = UnityInput.Current;
		}

		private void Update()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			if (!Player._mainPlayer._inChat)
			{
				Speed = (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.AlternativeSpeedKey) ? Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.AlternativeSpeed : Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Speed);
				PositionShift = Vector3.zero;
				((Component)Player._mainPlayer._pMove).transform.rotation = Quaternion.Euler(0f, CameraFunction._current._RotY, 0f);
				if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Left))
				{
					PositionShift -= Vector3.right * Speed * Time.deltaTime;
				}
				else if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Right))
				{
					PositionShift += Vector3.right * Speed * Time.deltaTime;
				}
				if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Forward))
				{
					PositionShift += Vector3.forward * Speed * Time.deltaTime;
				}
				else if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Backward))
				{
					PositionShift -= Vector3.forward * Speed * Time.deltaTime;
				}
				if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Up))
				{
					PositionShift += Vector3.up * Speed * Time.deltaTime;
				}
				else if (InputSystem.GetKey(Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Down))
				{
					PositionShift += Vector3.down * Speed * Time.deltaTime;
				}
				((Component)Player._mainPlayer._pMove).transform.Translate(PositionShift);
			}
		}
	}
}
namespace Tanuki.Atlyss.FluffUtilities.Commands
{
	internal class NoClip : ICommand
	{
		public bool Execute(string[] Arguments)
		{
			if (Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Status)
			{
				Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Disable();
				Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockoutSound);
			}
			else
			{
				Tanuki.Atlyss.FluffUtilities.Managers.NoClip.Instance.Enable();
				Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockonSound);
			}
			return false;
		}
	}
	internal class FreeCamera : ICommand
	{
		public bool Execute(string[] Arguments)
		{
			if (Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Status)
			{
				Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Disable();
				Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockoutSound);
			}
			else
			{
				Tanuki.Atlyss.FluffUtilities.Managers.FreeCamera.Instance.Enable(Configuration.Instance.FreeCamera.LockCharacterControls.Value, Configuration.Instance.FreeCamera.SmoothLookMode.Value);
				Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockonSound);
			}
			return false;
		}
	}
	internal class NoSkillCooldown : ICommand, IDisposable
	{
		private bool Status;

		public NoSkillCooldown()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			OnStopClient_Prefix.OnInvoke += new EventHandler(Disable);
		}

		public bool Execute(string[] Arguments)
		{
			if (Status)
			{
				Disable();
				Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockoutSound);
			}
			else
			{
				Enable();
				Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockonSound);
			}
			return false;
		}

		private void Enable()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			if (!Status)
			{
				Status = true;
				Main.Instance.Patch(typeof(New_CooldownSlot_Prefix));
				New_CooldownSlot_Prefix.OnInvoke += new EventHandler(New_CooldownSlot_Prefix_OnInvoke);
			}
		}

		private void Disable()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (Status)
			{
				Status = false;
				New_CooldownSlot_Prefix.OnInvoke -= new EventHandler(New_CooldownSlot_Prefix_OnInvoke);
			}
		}

		private void New_CooldownSlot_Prefix_OnInvoke(PlayerCasting PlayerCasting, ref ScriptableSkill ScriptableSkill, ref bool ShouldAllow)
		{
			if (((NetworkBehaviour)PlayerCasting).isLocalPlayer)
			{
				ShouldAllow = false;
			}
		}

		public void Dispose()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			OnStopClient_Prefix.OnInvoke -= new EventHandler(Disable);
			Disable();
		}
	}
	internal class SteamProfile : ICommand
	{
		public bool Execute(string[] Arguments)
		{
			if (Arguments.Length == 0)
			{
				ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.SteamProfile.NicknameNotSpecified", Array.Empty<object>()));
				return false;
			}
			string value = string.Join(" ", Arguments.Select((string x) => x.ToLower()));
			Player[] array = Object.FindObjectsOfType<Player>();
			foreach (Player val in array)
			{
				if (!((NetworkBehaviour)val).isLocalPlayer && val._nickname.ToLower().Contains(value))
				{
					Application.OpenURL(string.Format(Configuration.Instance.Commands.SteamProfile_LinkTemplate.Value, val._steamID));
					Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockonSound);
					return false;
				}
			}
			ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.SteamProfile.PlayerNotFound", Array.Empty<object>()));
			return false;
		}
	}
	internal class NoSkillTimer : ICommand, IDisposable
	{
		private bool Status;

		public NoSkillTimer()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			OnStopClient_Prefix.OnInvoke += new EventHandler(Disable);
		}

		public bool Execute(string[] Arguments)
		{
			if (Status)
			{
				Disable();
				Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockoutSound);
			}
			else
			{
				Enable();
				Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockonSound);
			}
			return false;
		}

		private void Enable()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			if (!Status)
			{
				Status = true;
				Main.Instance.Patch(typeof(Cmd_InitSkill_Postfix));
				Cmd_InitSkill_Postfix.OnInvoke += new EventHandler(Cmd_InitSkill_Postfix_OnInvoke);
			}
		}

		private void Cmd_InitSkill_Postfix_OnInvoke(PlayerCasting PlayerCasting)
		{
			if (((NetworkBehaviour)PlayerCasting).isLocalPlayer && Object.op_Implicit((Object)(object)PlayerCasting._currentCastSkill))
			{
				PlayerCasting._cooldownTimer = 0f;
				PlayerCasting._castTimer = float.MaxValue;
				if (!Player._mainPlayer._isHostPlayer)
				{
					PlayerCasting.Cmd_CastInit();
				}
			}
		}

		private void Disable()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (Status)
			{
				Status = false;
				Cmd_InitSkill_Postfix.OnInvoke -= new EventHandler(Cmd_InitSkill_Postfix_OnInvoke);
			}
		}

		public void Dispose()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			OnStopClient_Prefix.OnInvoke -= new EventHandler(Disable);
			Disable();
		}
	}
	internal class AutoPickup : ICommand, IDisposable
	{
		private float Distance;

		private bool Status;

		public AutoPickup()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			OnStopClient_Prefix.OnInvoke += new EventHandler(Disable);
		}

		public bool Execute(string[] Arguments)
		{
			if (Arguments.Length != 0)
			{
				if (!float.TryParse(Arguments[0], NumberStyles.Any, CultureInfo.InvariantCulture, out Distance))
				{
					ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.AutoPickup.DistanceNotFloat", Array.Empty<object>()));
					return false;
				}
				if (Distance > 0f)
				{
					Enable();
					ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.AutoPickup.Enabled", new object[1] { Distance }));
					Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockonSound);
					return false;
				}
			}
			if (Status)
			{
				Disable();
				ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.AutoPickup.Disabled", Array.Empty<object>()));
				Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockoutSound);
			}
			else
			{
				ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.AutoPickup.DistanceNotSpecified", Array.Empty<object>()));
			}
			return false;
		}

		private void Enable()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (!Status)
			{
				Status = true;
				Enable_GroundCheckToVelocityZero_Postfix.OnInvoke += new EventHandler(Enable_GroundCheckToVelocityZero);
			}
		}

		private void Disable()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (Status)
			{
				Status = false;
				Enable_GroundCheckToVelocityZero_Postfix.OnInvoke -= new EventHandler(Enable_GroundCheckToVelocityZero);
			}
		}

		private void Enable_GroundCheckToVelocityZero(ItemObject ItemObject)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!ItemObject._isPickedUp && ItemObject._canPickUp && !(Vector3.Distance(((Component)Player._mainPlayer).transform.position, ((Component)ItemObject._interactableCollider).transform.position) > Distance))
			{
				ItemObject.Init_PickupItem(((NetworkBehaviour)Player._mainPlayer).netIdentity);
			}
		}

		public void Dispose()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			OnStopClient_Prefix.OnInvoke -= new EventHandler(Disable);
			Disable();
		}
	}
	internal class Currency : ICommand
	{
		public bool Execute(string[] Arguments)
		{
			if (Arguments.Length == 0)
			{
				ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.Currency.DeltaNotSpecified", Array.Empty<object>()));
				return false;
			}
			if (!int.TryParse(Arguments[0], out var result))
			{
				ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.Currency.DeltaNotInteger", Array.Empty<object>()));
				return false;
			}
			if (result < 0)
			{
				Player._mainPlayer._pInventory.Cmd_SubtractCurrency(-result);
			}
			else
			{
				Player._mainPlayer._pInventory.Cmd_AddCurrency(result);
			}
			return false;
		}
	}
	internal class Disenchant : ICommand
	{
		public bool Execute(string[] Arguments)
		{
			ItemData item = PlayerInventory.GetItem(Player._mainPlayer._pInventory, 0, false, (ItemType)0);
			if (item == null)
			{
				ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.Disenchant.FirstEquipmentSlotIsEmpty", Array.Empty<object>()));
				return false;
			}
			item._modifierID = 0;
			item._useDamageTypeOverride = false;
			Player._mainPlayer._pSound._aSrcGeneral.PlayOneShot(Player._mainPlayer._pSound._lockonSound);
			return false;
		}
	}
	internal class Enchant : ICommand
	{
		public bool Execute(string[] Arguments)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			ItemData item = PlayerInventory.GetItem(Player._mainPlayer._pInventory, 0, false, (ItemType)0);
			if (item == null)
			{
				ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.Enchant.FirstEquipmentSlotIsEmpty", Array.Empty<object>()));
				return false;
			}
			ScriptableEquipment val = (ScriptableEquipment)GameManager._current.Locate_Item(item._itemName);
			if (!Object.op_Implicit((Object)(object)val._statModifierTable))
			{
				ChatBehaviour._current.New_ChatMessage(((Plugin)Main.Instance).Translate("Commands.Enchant.NotEnchantableItem", new object[1] { item._itemName }));
				return false;
			}
			byte b = ((((object)val).GetType() == typeof(ScriptableWeapon)) ? ((byte)1) : ((byte)0));
			if (Arguments.Length == 0)