using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using ENA_Utils;
using JoelG.ENA4;
using LMirman.VespaIO;
using Logger;
using Microsoft.CodeAnalysis;
using MonoMod.RuntimeDetour;
using On.JoelG.ENA4;
using On.LMirman.VespaIO;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("DevConsole")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e5989009a42b81623359be2c55b302eb93ac0a1c")]
[assembly: AssemblyProduct("DevConsole")]
[assembly: AssemblyTitle("DevConsole")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public static class ModdedCommands
{
	[VespaCommand("noclip", Name = "noclip", Description = "toggle noclip")]
	public static void Noclip()
	{
		if (Object.op_Implicit((Object)(object)NoClipController.noClipController))
		{
			NoClipController.noclip = !NoClipController.noclip;
			DevConsole.Log("Set noclip: " + NoClipController.noclip, (LogStyling)0);
		}
		else
		{
			DevConsole.Log("player not found", (LogStyling)5);
		}
	}

	[VespaCommand("walljump", Name = "toggle walljumps", Description = "toggle walljumps")]
	public static void WallJump()
	{
		PlayerCore.Instance.Mover.Config.canJumpOnSteep = !PlayerCore.Instance.Mover.Config.canJumpOnSteep;
		DevConsole.Log("toggled walljumps: " + PlayerCore.Instance.Mover.Config.canJumpOnSteep, (LogStyling)0);
	}

	[VespaCommand("airjumps", Name = "Air Jumps", Description = "number of air jumps")]
	public static void AirJumps(int jumpCount)
	{
		PlayerCore.Instance.Mover.Config.airJumps = jumpCount;
		DevConsole.Log("Set number of air jumps: " + jumpCount, (LogStyling)0);
	}

	[CommandAutofill("airjumps")]
	private static AutofillValue AirJumpsAutofill(AutofillBuilder autofillBuilder)
	{
		return autofillBuilder.CreateAutofill("<number>");
	}

	[VespaCommand("spawngo", Name = "Spawn Game Object", Description = "spawn a game object from its addressable name")]
	public static void SpawnGO(string path)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		AsyncOperationHandle<GameObject> val = Addressables.LoadAssetAsync<GameObject>((object)path);
		val.Completed += delegate(AsyncOperationHandle<GameObject> x)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Object.Instantiate<GameObject>(x.Result, ((Component)PlayerCore.Instance).transform.position, Quaternion.identity);
		};
	}

	[CommandAutofill("spawngo")]
	private static AutofillValue SpawnAutofill(AutofillBuilder autofillBuilder)
	{
		return autofillBuilder.CreateAutofill("<object path>");
	}
}
public class NoClipController : MonoBehaviour
{
	[CompilerGenerated]
	private static class <>O
	{
		public static hook_Awake <0>__PlayerCore_Awake;
	}

	public static NoClipController noClipController;

	private Transform Viewpoint;

	private float flyspeed = 5f;

	private bool _noclip;

	public static bool noclip
	{
		get
		{
			if (Object.op_Implicit((Object)(object)noClipController))
			{
				return noClipController._noclip;
			}
			return false;
		}
		set
		{
			if (Object.op_Implicit((Object)(object)noClipController))
			{
				PlayerCore.Instance.Rigidbody.isKinematic = !value;
				((Collider)PlayerCore.Instance.Mover.collider).enabled = false;
				((Behaviour)((Component)noClipController).GetComponent<PlayerMover>()).enabled = !value;
				noClipController._noclip = value;
			}
		}
	}

	[Initializer(0f)]
	private static void Init()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected O, but got Unknown
		object obj = <>O.<0>__PlayerCore_Awake;
		if (obj == null)
		{
			hook_Awake val = PlayerCore_Awake;
			<>O.<0>__PlayerCore_Awake = val;
			obj = (object)val;
		}
		PlayerCore.Awake += (hook_Awake)obj;
	}

	private static void PlayerCore_Awake(orig_Awake orig, PlayerCore self)
	{
		orig.Invoke(self);
		noClipController = ((Component)self).gameObject.AddComponent<NoClipController>();
		noClipController.Viewpoint = ((Component)self).gameObject.transform.Find("Rendering/View Point");
	}

	private void FixedUpdate()
	{
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		if (_noclip || !Object.op_Implicit((Object)(object)PlayerCore.Instance) || !Object.op_Implicit((Object)(object)PlayerCore.Instance.Mover))
		{
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (axis != 0f)
			{
				flyspeed = Mathf.Clamp(flyspeed * (axis + 1f), 1f, 9000f);
				Debug.Log((object)("flyspeed: " + flyspeed));
			}
			Vector3 val = Vector3.ClampMagnitude(new Vector3(PlayerCore.Instance.Input.GetAxis(0), 0f, PlayerCore.Instance.Input.GetAxis(1)), 1f);
			PlayerCore.Instance.Mover.rigidbody.velocity = Viewpoint.TransformDirection(val * flyspeed);
		}
	}
}
public static class NativeCommands
{
	private const int HelpPageLength = 10;

	private static bool hasBuiltSceneNameList;

	private static readonly List<string> SceneNameList = new List<string>();

	private const int AliasPageLength = 10;

	[VespaCommand("quit", Name = "Quit Application", Description = "Closes the application", ManualPriority = 70)]
	public static void Quit()
	{
		Application.Quit();
	}

	[VespaCommand("welcome", Name = "Welcome Prompt", Description = "Log the welcome prompt into the console")]
	public static void Welcome()
	{
		DevConsole.PrintWelcome();
	}

	[VespaCommand("clear", Name = "Clear Console History", Description = "Clears the entire console history including this command's execution. Usage is recommended when the history grows too large or the application freezes when logging occurs.", ManualPriority = 80)]
	public static void Clear()
	{
		((Console)DevConsole.console).Clear();
	}

	[VespaCommand("scene", Name = "Change Scene", Description = "Changes the scene to the scene name provided by the user", Cheat = true)]
	public static void Scene()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		Scene activeScene = SceneManager.GetActiveScene();
		DevConsole.Log("Current Scene: " + ((Scene)(ref activeScene)).name, (LogStyling)0);
	}

	[VespaCommand("scene", Cheat = true)]
	public static void Scene(string target)
	{
		DevConsole.Log("Attempting to load scene: " + target, (LogStyling)0);
		SceneManager.LoadScene(target);
	}

	[CommandAutofill("scene")]
	private static AutofillValue GetSceneAutofillValue(AutofillBuilder autofillBuilder)
	{
		if (!hasBuiltSceneNameList)
		{
			SceneNameList.Clear();
			int sceneCountInBuildSettings = SceneManager.sceneCountInBuildSettings;
			for (int i = 0; i < sceneCountInBuildSettings; i++)
			{
				SceneNameList.Add(Path.GetFileNameWithoutExtension(SceneUtility.GetScenePathByBuildIndex(i)));
			}
		}
		if (autofillBuilder.RelevantParameterIndex != 0)
		{
			return null;
		}
		string relevantWordText = autofillBuilder.GetRelevantWordText();
		return autofillBuilder.CreateAutofillFromFirstMatch((IEnumerable<string>)SceneNameList, relevantWordText, StringComparison.OrdinalIgnoreCase);
	}

	[VespaCommand("echo", Name = "Echo", Description = "Repeat the input back to the console.")]
	public static void Echo(string message)
	{
		DevConsole.Log(message, (LogStyling)0);
	}

	[VespaCommand("cheats", Name = "Enable Cheats", Description = "Enable cheats for this play session.")]
	public static void EnableCheats(string value = "")
	{
		if (((Console)DevConsole.console).CheatsEnabled)
		{
			DevConsole.Log("Cheats are already enabled! Cheats can't be disabled on this save slot.", (LogStyling)3);
		}
		else if (Application.isEditor || value == "enable")
		{
			DevConsole.console.EnableCheats();
		}
		else
		{
			DevConsole.Log("WARNING: By enabling cheats you understand and agree to the following:\n<color=red>- You will be unable to disable cheats for this session.\n- Cheat commands will compromise the standard gameplay experience.\n- The game may become unstable with the use of cheat commands.\n- Some features like saving and achievements may be disabled.\n\n</color>It is highly recommended you don't enable cheats unless you are comfortable with the unstable experience.\nIf you are still sure you would like to enable cheat commands please enter the following command <b>exactly</b> as follows: cheats enable", (LogStyling)0);
		}
	}

	[VespaCommand("help", Name = "Help Manual", Description = "Search for commands and get assistance with particular commands.", ManualPriority = 90)]
	public static void Help()
	{
		LogPage();
	}

	[VespaCommand("help")]
	public static void Help(int pageNum)
	{
		LogPage(pageNum);
	}

	[VespaCommand("help")]
	public static void Help(string query)
	{
		string text = query.ToLower();
		Command val = default(Command);
		if (Commands.commandSet.TryGetCommand(text, ref val))
		{
			DevConsole.Log(val.Guide, (LogStyling)0);
		}
		else
		{
			PrintMatching(text);
		}
	}

	[CommandAutofill("help")]
	private static AutofillValue GetHelpAutofillValue(AutofillBuilder autofillBuilder)
	{
		if (autofillBuilder.RelevantParameterIndex != 0)
		{
			return null;
		}
		string text = VespaFunctions.CleanseKey(autofillBuilder.GetRelevantWordText());
		IEnumerable<string> enumerable = from command in Commands.commandSet.GetPublicCommands(false)
			select command.Key;
		return autofillBuilder.CreateAutofillFromFirstMatch(enumerable, text, StringComparison.OrdinalIgnoreCase);
	}

	private static int CountPages()
	{
		int num = 0;
		foreach (Command publicCommand in Commands.commandSet.GetPublicCommands(((Console)DevConsole.console).CheatsEnabled))
		{
			num++;
		}
		return Mathf.CeilToInt((float)num / 10f);
	}

	private static void LogPage(int page = 1)
	{
		int num = CountPages();
		page = Mathf.Clamp(page, 1, num);
		int num2 = 10;
		int num3 = (page - 1) * 10;
		DevConsole.Log($"========== Help: Page {page}/{num} ==========", (LogStyling)0);
		foreach (Command publicCommand in Commands.commandSet.GetPublicCommands(((Console)DevConsole.console).CheatsEnabled))
		{
			if (num2 <= 0)
			{
				break;
			}
			if (num3 <= 0)
			{
				PrintLookup(publicCommand);
				num2--;
			}
			else
			{
				num3--;
			}
		}
		DevConsole.Log($"========== END OF PAGE {page}/{num} ==========", (LogStyling)0);
		DevConsole.Log("========== Use \"help {page #}\" for more ==========", (LogStyling)0);
	}

	private static void PrintMatching(string key)
	{
		DevConsole.Log("========== Commands Containing \"" + key + "\" ==========", (LogStyling)0);
		foreach (Command publicCommand in Commands.commandSet.GetPublicCommands(((Console)DevConsole.console).CheatsEnabled))
		{
			if (publicCommand.Key.Contains(VespaFunctions.CleanseKey(key)) || publicCommand.Name.ToLower().Contains(key.ToLower()))
			{
				PrintLookup(publicCommand);
			}
		}
	}

	private static void PrintLookup(Command command)
	{
		DevConsole.Log("- [" + command.Key + "] \"" + command.Name + "\"\n    - " + command.Description, (LogStyling)0);
	}

	[VespaCommand("alias", Name = "Set Alias", Description = "Set a particular alias definition")]
	public static void SetAlias(string alias, string value)
	{
		alias = VespaFunctions.CleanseKey(alias);
		if (alias.Length == 0 || value.Length == 0)
		{
			DevConsole.Log("Your alias or value was empty.", (LogStyling)3);
			return;
		}
		bool flag = Aliases.aliasSet.SetAlias(alias, value);
		Aliases.WriteToDisk();
		DevConsole.Log(flag ? ("<color=green>+</color> Added alias \"" + alias + "\" to represent \"" + value + "\"") : ("<color=yellow>*</color> Modified alias \"" + alias + "\" to represent \"" + value + "\""), (LogStyling)0);
	}

	[VespaCommand("alias_delete", Name = "Delete Alias", Description = "Delete a particular alias definition")]
	public static void DeleteAlias(string alias)
	{
		alias = VespaFunctions.CleanseKey(alias);
		bool flag = Aliases.aliasSet.RemoveAlias(alias);
		if (flag)
		{
			Aliases.WriteToDisk();
		}
		DevConsole.Log(flag ? ("<color=red>-</color> Removed alias \"" + alias + "\".") : ("<color=yellow>Warning:</color> Tried to remove alias \"" + alias + "\" but no such alias was found."), (LogStyling)0);
	}

	[CommandAutofill("alias_view")]
	[CommandAutofill("alias_delete")]
	private static AutofillValue GetAliasAutofillValue(AutofillBuilder autofillBuilder)
	{
		if (autofillBuilder.RelevantParameterIndex != 0)
		{
			return null;
		}
		string text = VespaFunctions.CleanseKey(autofillBuilder.GetRelevantWordText());
		return autofillBuilder.CreateAutofillFromFirstMatch((IEnumerable<string>)Aliases.aliasSet.Keys, text, StringComparison.OrdinalIgnoreCase);
	}

	[VespaCommand("alias_reset_all", Name = "Reset All Aliases", Description = "Reset all alias definitions")]
	public static void ResetAllAliasesWarning()
	{
		DevConsole.Log("This will remove <b>ALL</b> alias definitions!\nTo confirm alias reset please enter the following command: \"alias_reset_all CONFIRM\"", (LogStyling)3);
	}

	[VespaCommand("alias_reset_all", Name = "Reset All Aliases", Description = "Reset all alias definitions")]
	public static void ResetAllAliases(string confirmation)
	{
		if (confirmation == "CONFIRM")
		{
			Aliases.ResetAliasesAndFile();
			DevConsole.Log("<color=red>-</color> All aliases have been removed!", (LogStyling)0);
		}
		else
		{
			ResetAllAliasesWarning();
		}
	}

	[VespaCommand("alias")]
	[VespaCommand("alias_view", Name = "View Alias", Description = "View the definition for a particular alias")]
	public static void ViewAlias(string alias)
	{
		alias = VespaFunctions.CleanseKey(alias);
		string text = default(string);
		DevConsole.Log(Aliases.aliasSet.TryGetAlias(alias, ref text) ? ("\"" + alias + "\" -> \"" + text + "\"") : ("<color=red>Error:</color> Tried to view alias \"" + alias + "\" but no such alias was found."), (LogStyling)0);
	}

	[VespaCommand("alias_list", Name = "List Aliases", Description = "View list of all aliases that have been defined")]
	public static void ListAlias(string filter)
	{
		filter = VespaFunctions.CleanseKey(filter);
		DevConsole.Log("--- Aliases Containing \"" + filter + "\" ---", (LogStyling)0);
		foreach (KeyValuePair<string, string> allAlias in Aliases.aliasSet.AllAliases)
		{
			if (allAlias.Key.Contains(filter) || allAlias.Value.ToLower().Contains(filter))
			{
				DevConsole.Log("'" + allAlias.Key + "'  ->  '" + allAlias.Value + "'", (LogStyling)0);
			}
		}
	}

	[VespaCommand("alias_list", Name = "List Aliases", Description = "View list of all aliases that have been defined")]
	public static void ListAlias(int pageNum = 0)
	{
		int num = Mathf.Max(Mathf.CeilToInt((float)Aliases.aliasSet.AliasCount / 10f), 1);
		pageNum = Mathf.Clamp(pageNum, 1, num);
		int num2 = 10;
		int num3 = (pageNum - 1) * 10;
		DevConsole.Log($"--- Aliases {pageNum}/{num} ---", (LogStyling)0);
		foreach (KeyValuePair<string, string> allAlias in Aliases.aliasSet.AllAliases)
		{
			if (num2 <= 0)
			{
				break;
			}
			if (num3 > 0)
			{
				num3--;
				continue;
			}
			DevConsole.Log("'" + allAlias.Key + "'  ->  '" + allAlias.Value + "'", (LogStyling)0);
			num2--;
		}
		DevConsole.Log($"--- END OF PAGE {pageNum}/{num} ---", (LogStyling)0);
		DevConsole.Log("--- Use \"alias_list {page #}\" for more ---", (LogStyling)0);
	}
}
namespace Logger
{
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			StackFrame stackFrame = new StackFrame(1);
			MethodBase method = stackFrame.GetMethod();
			_logSource.LogDebug((object)("[" + method.Name + "]: " + data));
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			StackFrame stackFrame = new StackFrame(1);
			MethodBase method = stackFrame.GetMethod();
			_logSource.LogInfo((object)("[" + method.Name + "]: " + data));
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
}
namespace EnableConsole
{
	[BepInPlugin("Onyx.EnableConsole", "EnableConsole", "1.0.1")]
	public class EnableConsole : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_RunInvocation <0>__RunInvocation;

			public static Func<Func<bool>, bool> <1>__ConsoleActive_get;

			public static Action<Action<bool>, bool> <2>__ConsoleActive_set;
		}

		public const string PluginGUID = "Onyx.EnableConsole";

		public const string PluginAuthor = "Onyx";

		public const string PluginName = "EnableConsole";

		public const string PluginVersion = "1.0.1";

		private static bool _consoleState;

		public void Awake()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
		}

		[Initializer(0f)]
		private static void Init()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0083: 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)
			AsyncOperationHandle<GameObject> val = Addressables.LoadAssetAsync<GameObject>((object)"VespaIO/Dev Console");
			val.Completed += delegate(AsyncOperationHandle<GameObject> x)
			{
				GameObject result = x.Result;
				Object.Instantiate<GameObject>(result);
			};
			object obj = <>O.<0>__RunInvocation;
			if (obj == null)
			{
				hook_RunInvocation val2 = RunInvocation;
				<>O.<0>__RunInvocation = val2;
				obj = (object)val2;
			}
			Invocation.RunInvocation += (hook_RunInvocation)obj;
			new Hook((MethodBase)Reflection.GetPropertyGetter(typeof(DevConsole), "ConsoleActive"), (Delegate)new Func<Func<bool>, bool>(ConsoleActive_get));
			new Hook((MethodBase)Reflection.GetPropertySetter(typeof(DevConsole), "ConsoleActive"), (Delegate)new Action<Action<bool>, bool>(ConsoleActive_set));
			((Console)DevConsole.console).Enabled = true;
			((Console)DevConsole.console).cheatsEnabled = true;
		}

		private static InvokeResult RunInvocation(orig_RunInvocation orig, Invocation self, Console console, out Exception exception)
		{
			//IL_001f: 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_0035: Invalid comparison between Unknown and I4
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_005a: 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_009d: Invalid comparison between Unknown and I4
			//IL_008b: 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_00dd: Invalid comparison between Unknown and I4
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Invalid comparison between Unknown and I4
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, console, ref exception);
			try
			{
				exception = null;
				if ((int)self.validState != 1)
				{
					return (InvokeResult)2;
				}
				if (!console.Enabled)
				{
					return (InvokeResult)4;
				}
				if (self.command.Cheat && !console.CheatsEnabled)
				{
					return (InvokeResult)3;
				}
				if ((int)self.invocationType == 0)
				{
					self.methodInfo.Invoke(self.targetObject, self.methodParameters);
					return (InvokeResult)0;
				}
				if ((int)self.invocationType == 1)
				{
					InvokeProperty();
					return (InvokeResult)0;
				}
				if ((int)self.invocationType == 2)
				{
					InvokeField();
					return (InvokeResult)0;
				}
				return (InvokeResult)1;
			}
			catch (Exception ex)
			{
				exception = ex.InnerException ?? ex;
				return (InvokeResult)1;
			}
			void InvokeField()
			{
				object value = self.fieldInfo.GetValue(self.targetObject);
				if (self.fieldInfo.IsInitOnly)
				{
					console.Log(string.Format("{0} has readonly value \"{1}\"", self.GetLogValue("Field", self.fieldInfo.Name), value), (LogStyling)0);
				}
				else if (self.arguments.Length == 0)
				{
					console.Log(string.Format("{0} has value \"{1}\"", self.GetLogValue("Field", self.fieldInfo.Name), value), (LogStyling)0);
				}
				else
				{
					string text = self.arguments[0].text;
					TypeConverter converter = TypeDescriptor.GetConverter(self.fieldInfo.FieldType);
					if (converter.IsValid(text))
					{
						object obj = converter.ConvertFrom(text);
						self.fieldInfo.SetValue(self.targetObject, obj);
						console.Log(string.Format("Set {0} from \"{1}\" to \"{2}\"", self.GetLogValue("field", self.fieldInfo.Name), value, obj), (LogStyling)0);
					}
					else
					{
						console.Log($"Cannot set value of field \"{self.fieldInfo.Name}\" ({self.fieldInfo.FieldType}) to \"{text}\"", (LogStyling)5);
					}
				}
			}
			void InvokeProperty()
			{
				object arg = (self.propertyInfo.CanRead ? self.propertyInfo.GetValue(self.targetObject) : string.Empty);
				if (!self.propertyInfo.CanWrite)
				{
					console.Log(string.Format("{0} has readonly value \"{1}\"", self.GetLogValue("Property", self.propertyInfo.Name), arg), (LogStyling)0);
				}
				else if (self.arguments.Length == 0 && !self.propertyInfo.CanRead)
				{
					console.Log("Property \"" + self.propertyInfo.Name + "\" can only have its value set.", (LogStyling)5);
				}
				else if (self.arguments.Length == 0)
				{
					console.Log(string.Format("{0} has value \"{1}\"", self.GetLogValue("Property", self.propertyInfo.Name), arg), (LogStyling)0);
				}
				else
				{
					string text = self.arguments[0].text;
					TypeConverter converter = TypeDescriptor.GetConverter(self.propertyInfo.PropertyType);
					if (converter.IsValid(text))
					{
						object obj = converter.ConvertFrom(text);
						self.propertyInfo.SetValue(self.targetObject, obj);
						console.Log(self.propertyInfo.CanRead ? string.Format("Set {0} from \"{1}\" to \"{2}\"", self.GetLogValue("property", self.propertyInfo.Name), arg, obj) : string.Format("Set {0} to \"{1}\"", self.GetLogValue("property", self.propertyInfo.Name), obj), (LogStyling)0);
					}
					else
					{
						console.Log($"Cannot set value of property \"{self.propertyInfo.Name}\" ({self.propertyInfo.PropertyType}) to \"{text}\"", (LogStyling)5);
					}
				}
			}
		}

		public static bool ConsoleActive_get(Func<bool> orig)
		{
			orig();
			return _consoleState;
		}

		public static void ConsoleActive_set(Action<bool> orig, bool value)
		{
			orig(value);
			_consoleState = value;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}