using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Lib.GAB;
using Lib.GAB.Events;
using Lib.GAB.Server;
using Lib.GAB.Tools;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using TMPro;
using Unity.Collections;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using ValAgentBridge.Tools;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ValAgentBridge")]
[assembly: AssemblyDescription("Lets an AI agent automate and monitor mod testing in a running Valheim")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("BarryWhite")]
[assembly: AssemblyProduct("ValAgentBridge")]
[assembly: AssemblyCopyright("Copyright (c) 2026 BarryWhite")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7c1e3b52-9a4d-4f0e-8b6a-2d5f1c9e4a37")]
[assembly: AssemblyFileVersion("1.5.5")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.5.5.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ValAgentBridge
{
	public static class BackpackCompat
	{
		private sealed class Source
		{
			public string mod = "";

			public MethodInfo method;

			public bool takesPlayer;
		}

		private static List<Source>? _sources;

		public static List<(string mod, Inventory inventory)> EquippedBackpacks(Player player)
		{
			List<(string, Inventory)> list = new List<(string, Inventory)>();
			if ((Object)(object)player == (Object)null)
			{
				return list;
			}
			foreach (Source item in Sources())
			{
				try
				{
					object? obj = item.method.Invoke(null, (!item.takesPlayer) ? Array.Empty<object>() : new object[1] { player });
					Inventory val = (Inventory)((obj is Inventory) ? obj : null);
					if (val != null)
					{
						list.Add((item.mod, val));
					}
				}
				catch (Exception)
				{
				}
			}
			return list;
		}

		private static List<Source> Sources()
		{
			if (_sources != null)
			{
				return _sources;
			}
			_sources = new List<Source>();
			Add("Adventure Backpacks", "AdventureBackpacks.API.ABAPI", new Type[1] { typeof(Player) });
			Add("Backpacks", "Backpacks.API", Type.EmptyTypes);
			return _sources;
		}

		private static void Add(string mod, string typeName, Type[] args)
		{
			Type type = AccessTools.TypeByName(typeName);
			if (!(type == null))
			{
				MethodInfo methodInfo = AccessTools.Method(type, "GetEquippedBackpackInventory", args, (Type[])null);
				if (methodInfo == null || !methodInfo.IsStatic || methodInfo.ReturnType != typeof(Inventory))
				{
					ValAgentBridgePlugin.ModLogger.LogWarning((object)(mod + " API changed (GetEquippedBackpackInventory); its backpack contents won't be shown."));
					return;
				}
				_sources.Add(new Source
				{
					mod = mod,
					method = methodInfo,
					takesPlayer = (args.Length == 1)
				});
			}
		}
	}
	public static class BlockHold
	{
		private static Player? _held;

		private static bool _patched;

		private static FieldRef<Character, bool>? _blocking;

		public static string? Set(Player player, bool active)
		{
			//IL_007f: 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_00a3: Expected O, but got Unknown
			if (!active)
			{
				if ((Object)(object)_held != (Object)null && (Object)(object)_held == (Object)(object)player && _blocking != null)
				{
					_blocking.Invoke((Character)(object)player) = false;
				}
				_held = null;
				return null;
			}
			if (!_patched)
			{
				try
				{
					_blocking = AccessTools.FieldRefAccess<Character, bool>("m_blocking");
					MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(Player), "SetControls", (Type[])null, (Type[])null);
					if (methodInfo == null)
					{
						return "Player.SetControls not found; blocking can't be held.";
					}
					new Harmony("BarryWhite.ValAgentBridge.block").Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(BlockHold), "SetControlsPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					_patched = true;
				}
				catch (Exception ex)
				{
					return "Blocking can't be held: " + ex.GetBaseException().Message;
				}
			}
			_held = player;
			_blocking.Invoke((Character)(object)player) = true;
			return null;
		}

		private static void SetControlsPostfix(Player __instance)
		{
			if (!((Object)(object)_held == (Object)null))
			{
				if ((Object)(object)_held != (Object)(object)Player.m_localPlayer)
				{
					_held = null;
				}
				else if ((Object)(object)__instance == (Object)(object)_held)
				{
					_blocking.Invoke((Character)(object)__instance) = true;
				}
			}
		}
	}
	public static class Inspector
	{
		public sealed class PathEnd
		{
			public Type OwnerType = typeof(object);

			public object? Owner;

			public string? Member;

			public int Index = -1;

			public bool IsTypeOnly
			{
				get
				{
					if (Member == null)
					{
						return Index < 0;
					}
					return false;
				}
			}
		}

		public const BindingFlags All = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		private const int MaxItems = 50;

		private static readonly object IndexLock = new object();

		private static int _indexedAssemblies = -1;

		private static List<Type> _allTypes = new List<Type>();

		private static Dictionary<string, Type> _byFullName = new Dictionary<string, Type>();

		private static Dictionary<string, List<Type>> _byShortName = new Dictionary<string, List<Type>>();

		public static object? Describe(object? value, int depth, int nodeBudget = 3000)
		{
			int budget = nodeBudget;
			return Walk(value, depth, ref budget);
		}

		private static object? Walk(object? value, int depth, ref int budget)
		{
			if (--budget < 0)
			{
				return "(output limit reached)";
			}
			if (value == null)
			{
				return null;
			}
			Object val = (Object)((value is Object) ? value : null);
			if (val != null && val == (Object)null)
			{
				return "(destroyed)";
			}
			Type type = value.GetType();
			if (type.IsPrimitive || value is string || value is decimal)
			{
				return value;
			}
			if (type.IsEnum)
			{
				return value.ToString();
			}
			if (value is Type type2)
			{
				return type2.FullName;
			}
			if (value is Delegate obj)
			{
				return "(delegate " + obj.Method.DeclaringType?.Name + "." + obj.Method.Name + ")";
			}
			if (value is Vector2 || value is Vector3 || value is Vector4 || value is Quaternion || value is Color || value is Vector2Int || value is Vector3Int)
			{
				return value.ToString();
			}
			Object val2 = (Object)((value is Object) ? value : null);
			if (val2 != null && depth <= 0)
			{
				return val2.name + " (" + type.Name + ")";
			}
			if (depth <= 0)
			{
				return "(" + TypeName(type) + ")";
			}
			if (value is IDictionary dictionary)
			{
				Dictionary<string, object> dictionary2 = new Dictionary<string, object> { ["$count"] = dictionary.Count };
				int num = 0;
				foreach (DictionaryEntry item in dictionary)
				{
					if (num++ >= 50)
					{
						dictionary2["$more"] = dictionary.Count - 50;
						break;
					}
					dictionary2[item.Key?.ToString() ?? "null"] = Walk(item.Value, depth - 1, ref budget);
				}
				return dictionary2;
			}
			if (value is IEnumerable enumerable)
			{
				List<object> list = new List<object>();
				int num2 = 0;
				foreach (object item2 in enumerable)
				{
					if (num2++ >= 50)
					{
						list.Add("(more items not shown)");
						break;
					}
					list.Add(Walk(item2, depth - 1, ref budget));
				}
				return list;
			}
			Dictionary<string, object> dictionary3 = new Dictionary<string, object> { ["$type"] = TypeName(type) };
			Object val3 = (Object)((value is Object) ? value : null);
			if (val3 != null)
			{
				dictionary3["$name"] = val3.name;
			}
			List<FieldInfo> list2;
			try
			{
				list2 = InstanceFields(type).ToList();
			}
			catch (Exception ex)
			{
				dictionary3["$fields"] = "(unreadable: " + ex.GetBaseException().GetType().Name + ": " + ex.GetBaseException().Message + ")";
				return dictionary3;
			}
			foreach (FieldInfo item3 in list2)
			{
				object value2;
				try
				{
					value2 = item3.GetValue(value);
				}
				catch (Exception ex2)
				{
					value2 = "(error: " + ex2.GetType().Name + ")";
				}
				dictionary3[CleanName(item3.Name)] = Walk(value2, depth - 1, ref budget);
			}
			return dictionary3;
		}

		public static IEnumerable<FieldInfo> InstanceFields(Type type)
		{
			Type t = type;
			while (t != null && t != typeof(object) && !IsUnityType(t))
			{
				FieldInfo[] fields = t.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				for (int i = 0; i < fields.Length; i++)
				{
					yield return fields[i];
				}
				t = t.BaseType;
			}
		}

		public static bool IsUnityType(Type t)
		{
			if (!(t.Namespace ?? "").StartsWith("UnityEngine"))
			{
				return t.Assembly.GetName().Name.StartsWith("UnityEngine");
			}
			return true;
		}

		public static string CleanName(string name)
		{
			if (!name.StartsWith("<") || !name.Contains(">k__BackingField"))
			{
				return name;
			}
			return name.Substring(1, name.IndexOf('>') - 1);
		}

		public static string TypeName(Type t)
		{
			if (!t.IsGenericType)
			{
				return t.Name;
			}
			return t.Name.Split(new char[1] { '`' })[0] + "<" + string.Join(",", t.GetGenericArguments().Select(TypeName)) + ">";
		}

		public static IReadOnlyList<Type> AllTypes()
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			lock (IndexLock)
			{
				if (assemblies.Length == _indexedAssemblies)
				{
					return _allTypes;
				}
				List<Type> list = new List<Type>();
				Dictionary<string, Type> dictionary = new Dictionary<string, Type>();
				Dictionary<string, List<Type>> dictionary2 = new Dictionary<string, List<Type>>();
				Assembly[] array = assemblies;
				foreach (Assembly assembly in array)
				{
					if (assembly.IsDynamic)
					{
						continue;
					}
					Type[] types;
					try
					{
						types = assembly.GetTypes();
					}
					catch (ReflectionTypeLoadException ex)
					{
						types = ex.Types;
					}
					catch
					{
						continue;
					}
					Type[] array2 = types;
					foreach (Type type in array2)
					{
						if (type == null)
						{
							continue;
						}
						list.Add(type);
						string key = (type.FullName ?? type.Name).Replace('+', '.');
						if (!dictionary.ContainsKey(key))
						{
							dictionary[key] = type;
						}
						if (!type.IsNested)
						{
							if (!dictionary2.TryGetValue(type.Name, out var value))
							{
								value = (dictionary2[type.Name] = new List<Type>());
							}
							value.Add(type);
						}
					}
				}
				_allTypes = list;
				_byFullName = dictionary;
				_byShortName = dictionary2;
				_indexedAssemblies = assemblies.Length;
				return _allTypes;
			}
		}

		public static Type? ResolveType(string name, out string? ambiguous)
		{
			ambiguous = null;
			AllTypes();
			lock (IndexLock)
			{
				if (_byFullName.TryGetValue(name.Replace('+', '.'), out Type value))
				{
					return value;
				}
			}
			if (Enumerable.Contains(name, '.'))
			{
				return null;
			}
			List<Type> list;
			lock (IndexLock)
			{
				list = (_byShortName.TryGetValue(name, out List<Type> value2) ? value2 : new List<Type>());
			}
			if (list.Count == 1)
			{
				return list[0];
			}
			if (list.Count > 1)
			{
				List<Type> list2 = list.Where((Type t) => t.Assembly.GetName().Name == "assembly_valheim").ToList();
				if (list2.Count == 1)
				{
					return list2[0];
				}
				ambiguous = string.Join(", ", list.Select((Type t) => t.FullName).Take(6));
			}
			return null;
		}

		public static PathEnd? ResolvePath(string path, out string? error)
		{
			error = null;
			string[] array = path.Split(new char[1] { '.' });
			Type type = null;
			int num = 0;
			int num2 = array.Length;
			while (num2 >= 1 && type == null)
			{
				string text = string.Join(".", array.Take(num2));
				type = ResolveType(text, out string ambiguous);
				if (ambiguous != null)
				{
					error = "'" + text + "' matches several types: " + ambiguous + ". Use the full name.";
					return null;
				}
				if (type != null)
				{
					num = num2;
				}
				num2--;
			}
			if (type == null)
			{
				error = "No type found at the start of '" + path + "'. Try debug/find_types.";
				return null;
			}
			if (num == array.Length)
			{
				return new PathEnd
				{
					OwnerType = type
				};
			}
			object next = null;
			Type type2 = type;
			int num3 = num;
			while (num3 < array.Length - 1)
			{
				if (!Step(type2, next, array[num3], out next, out error))
				{
					return null;
				}
				if (next != null)
				{
					Object val = (Object)((next is Object) ? next : null);
					if (val == null || !(val == (Object)null))
					{
						type2 = next.GetType();
						num3++;
						continue;
					}
				}
				error = "'" + string.Join(".", array.Take(num3 + 1)) + "' is null";
				return null;
			}
			string text2 = array[^1];
			if (int.TryParse(text2, out var result) && next is IList)
			{
				return new PathEnd
				{
					OwnerType = type2,
					Owner = next,
					Index = result
				};
			}
			return new PathEnd
			{
				OwnerType = type2,
				Owner = next,
				Member = text2
			};
		}

		public static bool Read(PathEnd end, out object? value, out string? error)
		{
			value = null;
			error = null;
			if (end.Index >= 0)
			{
				IList list = (IList)end.Owner;
				if (end.Index >= list.Count)
				{
					error = $"Index {end.Index} is outside 0..{list.Count - 1}";
					return false;
				}
				value = list[end.Index];
				return true;
			}
			try
			{
				return TryGetMember(end.OwnerType, end.Owner, end.Member, out value, out error);
			}
			catch (Exception ex)
			{
				error = "Reading '" + end.Member + "' threw " + ex.GetBaseException().GetType().Name + ": " + ex.GetBaseException().Message;
				return false;
			}
		}

		public static bool Write(PathEnd end, string text, out object? before, out object? after, out string? error)
		{
			before = (after = null);
			error = null;
			if (end.IsTypeOnly)
			{
				error = "The path names a type, not a value.";
				return false;
			}
			if (end.Owner != null && end.OwnerType.IsValueType)
			{
				error = "'" + end.Member + "' belongs to a struct copy (" + end.OwnerType.Name + "); writing it would change nothing. Set the whole struct one level up.";
				return false;
			}
			try
			{
				if (end.Index >= 0)
				{
					IList list = (IList)end.Owner;
					Type type = (end.OwnerType.IsArray ? end.OwnerType.GetElementType() : (end.OwnerType.IsGenericType ? end.OwnerType.GetGenericArguments()[0] : typeof(object)));
					before = list[end.Index];
					list[end.Index] = ConvertText(text, type);
					after = list[end.Index];
					return true;
				}
				BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy;
				Type type2 = end.OwnerType;
				while (type2 != null)
				{
					FieldInfo fieldInfo = type2.GetField(end.Member, bindingFlags | BindingFlags.DeclaredOnly) ?? type2.GetField("<" + end.Member + ">k__BackingField", bindingFlags | BindingFlags.DeclaredOnly);
					if (fieldInfo != null)
					{
						if (fieldInfo.IsLiteral)
						{
							error = "'" + end.Member + "' is a constant";
							return false;
						}
						if (!fieldInfo.IsStatic && end.Owner == null)
						{
							error = "'" + end.Member + "' needs an instance";
							return false;
						}
						object obj = (fieldInfo.IsStatic ? null : end.Owner);
						before = fieldInfo.GetValue(obj);
						fieldInfo.SetValue(obj, ConvertText(text, fieldInfo.FieldType));
						after = fieldInfo.GetValue(obj);
						return true;
					}
					PropertyInfo property = type2.GetProperty(end.Member, bindingFlags | BindingFlags.DeclaredOnly);
					if (property != null && property.GetIndexParameters().Length == 0)
					{
						MethodInfo setMethod = property.GetSetMethod(nonPublic: true);
						if (setMethod == null)
						{
							error = "'" + end.Member + "' is read-only";
							return false;
						}
						if (!setMethod.IsStatic && end.Owner == null)
						{
							error = "'" + end.Member + "' needs an instance";
							return false;
						}
						object obj2 = (setMethod.IsStatic ? null : end.Owner);
						before = property.GetGetMethod(nonPublic: true)?.Invoke(obj2, null);
						setMethod.Invoke(obj2, new object[1] { ConvertText(text, property.PropertyType) });
						after = property.GetGetMethod(nonPublic: true)?.Invoke(obj2, null);
						return true;
					}
					type2 = type2.BaseType;
				}
				error = end.OwnerType.Name + " has no field or property '" + end.Member + "'";
				return false;
			}
			catch (Exception ex)
			{
				error = "Could not set '" + end.Member + "': " + ex.GetBaseException().Message;
				return false;
			}
		}

		public static object? ConvertText(string text, Type type)
		{
			//IL_012d: 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)
			if (type == typeof(string))
			{
				return text;
			}
			if (text == "null" && !type.IsValueType)
			{
				return null;
			}
			Type type2 = Nullable.GetUnderlyingType(type) ?? type;
			if (type2.IsEnum)
			{
				return Enum.Parse(type2, text, ignoreCase: true);
			}
			if (type2.IsPrimitive || type2 == typeof(decimal))
			{
				return Convert.ChangeType(text, type2, CultureInfo.InvariantCulture);
			}
			if (type2 == typeof(Vector3) || type2 == typeof(Vector2))
			{
				float[] array = (from s in text.Trim('(', ')', '[', ']', ' ').Split(new char[1] { ',' })
					select float.Parse(s.Trim(), CultureInfo.InvariantCulture)).ToArray();
				if (!(type2 == typeof(Vector2)))
				{
					return (object)new Vector3(array[0], (array.Length > 1) ? array[1] : 0f, (array.Length > 2) ? array[2] : 0f);
				}
				return (object)new Vector2(array[0], array[1]);
			}
			return JsonConvert.DeserializeObject(text, type2);
		}

		private static bool Step(Type type, object? instance, string seg, out object? next, out string? error)
		{
			next = null;
			error = null;
			if (int.TryParse(seg, out var result) && instance is IList list)
			{
				if (result < 0 || result >= list.Count)
				{
					error = $"Index {result} is outside 0..{list.Count - 1}";
					return false;
				}
				next = list[result];
				return true;
			}
			try
			{
				return TryGetMember(type, instance, seg, out next, out error);
			}
			catch (Exception ex)
			{
				error = "Reading '" + seg + "' threw " + ex.GetBaseException().GetType().Name + ": " + ex.GetBaseException().Message;
				return false;
			}
		}

		public static bool TryGetMember(Type type, object? instance, string name, out object? value, out string? error)
		{
			value = null;
			error = null;
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy;
			Type type2 = type;
			while (type2 != null)
			{
				FieldInfo fieldInfo = type2.GetField(name, bindingFlags | BindingFlags.DeclaredOnly) ?? type2.GetField("<" + name + ">k__BackingField", bindingFlags | BindingFlags.DeclaredOnly);
				if (fieldInfo != null)
				{
					if (!fieldInfo.IsStatic && instance == null)
					{
						error = "'" + name + "' needs an instance";
						return false;
					}
					value = fieldInfo.GetValue(fieldInfo.IsStatic ? null : instance);
					return true;
				}
				PropertyInfo property = type2.GetProperty(name, bindingFlags | BindingFlags.DeclaredOnly);
				if (property != null && property.GetIndexParameters().Length == 0 && property.GetGetMethod(nonPublic: true) != null)
				{
					MethodInfo getMethod = property.GetGetMethod(nonPublic: true);
					if (!getMethod.IsStatic && instance == null)
					{
						error = "'" + name + "' needs an instance";
						return false;
					}
					value = getMethod.Invoke(getMethod.IsStatic ? null : instance, null);
					return true;
				}
				type2 = type2.BaseType;
			}
			error = type.Name + " has no field or property '" + name + "'";
			return false;
		}
	}
	public class MainThreadDispatcher : MonoBehaviour
	{
		private static MainThreadDispatcher? _instance;

		private static readonly ConcurrentQueue<Action> ExecutionQueue = new ConcurrentQueue<Action>();

		private static int _mainThreadId = -1;

		private static readonly Stopwatch Clock = Stopwatch.StartNew();

		private static long _lastFrameMs = -1L;

		private static float _smoothedFrameMs;

		public static MainThreadDispatcher Instance
		{
			get
			{
				//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)
				//IL_0027: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("ValAgentBridge_MainThreadDispatcher");
					_instance = val.AddComponent<MainThreadDispatcher>();
					Object.DontDestroyOnLoad((Object)val);
				}
				return _instance;
			}
		}

		public static long FrameAgeMs
		{
			get
			{
				if (Interlocked.Read(in _lastFrameMs) >= 0)
				{
					return Clock.ElapsedMilliseconds - Interlocked.Read(in _lastFrameMs);
				}
				return -1L;
			}
		}

		public static float FrameMs => _smoothedFrameMs;

		public static void Init()
		{
			_mainThreadId = Thread.CurrentThread.ManagedThreadId;
			_ = Instance;
		}

		public void Enqueue(Action action)
		{
			ExecutionQueue.Enqueue(action);
		}

		public static T Run<T>(Func<T> work, int timeoutMs = 10000)
		{
			if (Thread.CurrentThread.ManagedThreadId == _mainThreadId)
			{
				return work();
			}
			TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
			Instance.Enqueue(delegate
			{
				try
				{
					tcs.SetResult(work());
				}
				catch (Exception exception)
				{
					tcs.SetException(exception);
				}
			});
			if (!tcs.Task.Wait(timeoutMs))
			{
				throw new TimeoutException("The game's main thread did not answer in time (loading screen or paused?)");
			}
			return tcs.Task.Result;
		}

		public static object RunTool(Func<object> work, int timeoutMs = 15000)
		{
			try
			{
				return Run(work, timeoutMs);
			}
			catch (TimeoutException)
			{
				return new
				{
					success = false,
					error = "The game's main thread did not answer in time (loading screen or paused?). The action may still happen when the game catches up."
				};
			}
			catch (Exception ex2)
			{
				Exception baseException = ex2.GetBaseException();
				return new
				{
					success = false,
					error = baseException.GetType().Name + ": " + baseException.Message
				};
			}
		}

		private void Update()
		{
			Interlocked.Exchange(ref _lastFrameMs, Clock.ElapsedMilliseconds);
			float num = Time.unscaledDeltaTime * 1000f;
			_smoothedFrameMs = ((_smoothedFrameMs <= 0f) ? num : (_smoothedFrameMs * 0.9f + num * 0.1f));
			Action result;
			while (ExecutionQueue.TryDequeue(out result))
			{
				try
				{
					result();
				}
				catch (Exception arg)
				{
					ValAgentBridgePlugin.ModLogger.LogError((object)$"Queued bridge work failed: {arg}");
				}
			}
		}
	}
	public static class ModCommands
	{
		public sealed class Found
		{
			public string name = "";

			public string mod = "";

			public string method = "";

			public string? description;

			public bool registered;

			public string? problem;
		}

		public static readonly List<Found> All = new List<Found>();

		public static void RegisterAll(IToolRegistry registry)
		{
			foreach (var item3 in from p in Chainloader.PluginInfos.Values
				where (Object)(object)p.Instance != (Object)null
				select (mod: p.Metadata.Name, asm: ((object)p.Instance).GetType().Assembly) into x
				where x.asm != typeof(ModCommands).Assembly
				group x by x.asm into g
				select g.First())
			{
				string item = item3.mod;
				Assembly item2 = item3.asm;
				int num = 0;
				Type[] types;
				try
				{
					types = item2.GetTypes();
				}
				catch (ReflectionTypeLoadException ex)
				{
					types = ex.Types;
				}
				catch
				{
					continue;
				}
				foreach (Type item4 in types.Where((Type t) => t != null))
				{
					MethodInfo[] methods;
					try
					{
						methods = item4.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					}
					catch
					{
						num++;
						continue;
					}
					MethodInfo[] array = methods;
					foreach (MethodInfo methodInfo in array)
					{
						try
						{
							object obj3 = methodInfo.GetCustomAttributes(inherit: false).FirstOrDefault((object a) => a.GetType().Name == "BridgeToolAttribute");
							if (obj3 != null)
							{
								Register(registry, item, methodInfo, obj3);
							}
						}
						catch (Exception)
						{
							num++;
						}
					}
				}
				if (num > 0)
				{
					ValAgentBridgePlugin.ModLogger.LogInfo((object)$"Mod commands: skipped {num} part(s) of {item} that need a mod which isn't installed.");
				}
			}
			if (All.Count > 0)
			{
				ValAgentBridgePlugin.ModLogger.LogInfo((object)$"Mod commands: {All.Count((Found f) => f.registered)} registered, {All.Count((Found f) => !f.registered)} skipped");
			}
		}

		private static void Register(IToolRegistry registry, string mod, MethodInfo method, object attr)
		{
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			Found found = new Found
			{
				mod = mod,
				method = method.DeclaringType?.FullName + "." + method.Name,
				name = (Read(attr, "Name") ?? ""),
				description = Read(attr, "Description")
			};
			All.Add(found);
			if (!ToolNameValidator.IsValid(found.name))
			{
				found.problem = "name '" + found.name + "' must look like 'mymod/do_thing' (lowercase, at least one '/')";
				ValAgentBridgePlugin.ModLogger.LogWarning((object)("Mod command from " + mod + " skipped: " + found.problem));
				return;
			}
			if (registry.HasTool(found.name))
			{
				found.problem = "a command with this name already exists";
				ValAgentBridgePlugin.ModLogger.LogWarning((object)("Mod command " + found.name + " from " + mod + " skipped: " + found.problem));
				return;
			}
			ParameterInfo[] parameters = method.GetParameters();
			ToolInfo info = new ToolInfo
			{
				Name = found.name,
				Description = "[" + mod + "] " + found.description,
				Parameters = ((IEnumerable<ParameterInfo>)parameters).Select((Func<ParameterInfo, ToolParameterInfo>)((ParameterInfo p) => new ToolParameterInfo
				{
					Name = (p.Name ?? ""),
					Type = p.ParameterType,
					Required = !p.HasDefaultValue,
					DefaultValue = (p.HasDefaultValue ? p.DefaultValue : null)
				})).ToList()
			};
			registry.RegisterTool(found.name, (Func<object, Task<object>>)delegate(object input)
			{
				string text = ToolGuard.CheckArgs(info, input);
				return Task.FromResult((text != null) ? new
				{
					success = false,
					error = text
				} : Invoke(method, parameters, input));
			}, info);
			found.registered = true;
		}

		private static object Invoke(MethodInfo method, ParameterInfo[] parameters, object input)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			JObject args;
			try
			{
				args = (JObject)((input != null) ? ((object)((input is string text) ? JObject.Parse(text) : JObject.FromObject(input))) : ((object)new JObject()));
			}
			catch (Exception ex)
			{
				return new
				{
					success = false,
					error = "Bad arguments: " + ex.Message
				};
			}
			object?[] values;
			try
			{
				values = parameters.Select(delegate(ParameterInfo p)
				{
					//IL_003a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0041: Invalid comparison between Unknown and I4
					JProperty? obj = args.Properties().FirstOrDefault((Func<JProperty, bool>)((JProperty x) => string.Equals(x.Name, p.Name, StringComparison.OrdinalIgnoreCase)));
					JToken val = ((obj != null) ? obj.Value : null);
					return (val == null || (int)val.Type == 10) ? ((!p.HasDefaultValue) ? ((!p.ParameterType.IsValueType) ? null : Activator.CreateInstance(p.ParameterType)) : p.DefaultValue) : val.ToObject(p.ParameterType);
				}).ToArray();
			}
			catch (Exception ex2)
			{
				return new
				{
					success = false,
					error = "Bad arguments: " + ex2.Message
				};
			}
			return MainThreadDispatcher.RunTool(() => method.Invoke(null, values) ?? new
			{
				success = true
			}, 30000);
		}

		private static string? Read(object attr, string property)
		{
			PropertyInfo property2 = attr.GetType().GetProperty(property);
			if (property2 != null)
			{
				return property2.GetValue(attr) as string;
			}
			return attr.GetType().GetField(property)?.GetValue(attr) as string;
		}
	}
	public class MovementManager : MonoBehaviour
	{
		private static MovementManager? _instance;

		private bool _isMoving;

		private TaskCompletionSource<object>? _tcs;

		private float _startTime;

		private float _duration;

		private Vector3 _moveDir;

		private bool _run;

		public static MovementManager Instance
		{
			get
			{
				//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)
				//IL_0027: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("ValAgentBridge_MovementManager");
					_instance = val.AddComponent<MovementManager>();
					Object.DontDestroyOnLoad((Object)val);
				}
				return _instance;
			}
		}

		public Task<object> StartMoving(Vector3 direction, bool run, float duration)
		{
			//IL_0009: 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)
			StopMoving();
			_moveDir = ((Vector3)(ref direction)).normalized;
			_run = run;
			_duration = duration;
			_startTime = Time.time;
			_isMoving = true;
			_tcs = new TaskCompletionSource<object>();
			return _tcs.Task;
		}

		public void StopMoving()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (_isMoving)
			{
				_isMoving = false;
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					((Character)localPlayer).SetMoveDir(Vector3.zero);
					((Character)localPlayer).SetRun(false);
				}
			}
		}

		private void FixedUpdate()
		{
			if (!_isMoving || _tcs == null)
			{
				return;
			}
			try
			{
				Step();
			}
			catch (Exception ex)
			{
				StopMoving();
				_tcs?.TrySetResult(new
				{
					success = false,
					message = "Moving failed: " + ex.GetBaseException().Message
				});
			}
		}

		private void Step()
		{
			//IL_003d: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				Finish("Player lost");
				return;
			}
			if (Time.time - _startTime >= _duration)
			{
				Finish("Completed");
				return;
			}
			((Character)localPlayer).SetMoveDir(_moveDir);
			((Character)localPlayer).SetLookDir(_moveDir, 0f);
			((Character)localPlayer).SetRun(_run);
		}

		private void Finish(string message)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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)
			Player localPlayer = Player.m_localPlayer;
			Vector3 val = (((Object)(object)localPlayer != (Object)null) ? ((Component)localPlayer).transform.position : Vector3.zero);
			StopMoving();
			_tcs?.TrySetResult(new
			{
				success = true,
				message = message,
				position = new { val.x, val.y, val.z }
			});
		}
	}
	public class NavigationManager : MonoBehaviour
	{
		private static NavigationManager? _instance;

		private Vector3 _targetPos;

		private readonly List<Vector3> _navPath = new List<Vector3>();

		private bool _isNavigating;

		private TaskCompletionSource<object>? _tcs;

		private float _startTime;

		private float _timeout;

		private float _lastPathCalcTime;

		private const float ArrivalDistXZ = 1.5f;

		private const float WaypointAdvanceDist = 1.5f;

		private const float PathRecalcInterval = 1f;

		private const float RunDistanceThreshold = 5f;

		public static NavigationManager Instance
		{
			get
			{
				//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)
				//IL_0027: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("ValAgentBridge_NavigationManager");
					_instance = val.AddComponent<NavigationManager>();
					Object.DontDestroyOnLoad((Object)val);
				}
				return _instance;
			}
		}

		public Task<object> StartNavigation(Vector3 target, float timeout)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			StopNavigation("Cancelled by new navigation request");
			_targetPos = target;
			_timeout = timeout;
			_startTime = Time.time;
			_lastPathCalcTime = 0f;
			_navPath.Clear();
			_isNavigating = true;
			_tcs = new TaskCompletionSource<object>();
			ValAgentBridgePlugin.ModLogger.LogInfo((object)$"Navigation started to ({target.x:F1}, {target.z:F1}), timeout={timeout}s");
			return _tcs.Task;
		}

		public void StopNavigation(string? reason = null)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (_isNavigating)
			{
				_isNavigating = false;
				_navPath.Clear();
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					((Character)localPlayer).SetMoveDir(Vector3.zero);
					((Character)localPlayer).SetRun(false);
				}
				if (reason != null)
				{
					ValAgentBridgePlugin.ModLogger.LogInfo((object)("Navigation stopped: " + reason));
				}
			}
		}

		private void FixedUpdate()
		{
			if (!_isNavigating || _tcs == null)
			{
				return;
			}
			try
			{
				Step();
			}
			catch (Exception ex)
			{
				Finish(success: false, "Navigation failed: " + ex.GetBaseException().Message);
			}
		}

		private void Step()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_0161: 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_013b: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				Finish(success: false, "Player lost");
				return;
			}
			Vector3 position = ((Component)localPlayer).transform.position;
			if (Time.time - _startTime > _timeout)
			{
				float num = Utils.DistanceXZ(position, _targetPos);
				Finish(success: false, $"Timeout after {_timeout}s (distance remaining: {num:F1}m)");
				return;
			}
			float num2 = Utils.DistanceXZ(position, _targetPos);
			if (num2 < 1.5f)
			{
				Finish(success: true, $"Arrived (distance: {num2:F2}m)");
			}
			else
			{
				if (!((Character)localPlayer).CanMove())
				{
					return;
				}
				if (Time.time - _lastPathCalcTime > 1f)
				{
					_lastPathCalcTime = Time.time;
					if ((Object)(object)Pathfinding.instance == (Object)null)
					{
						Finish(success: false, "Pathfinding isn't available (still loading?)");
						return;
					}
					if (!Pathfinding.instance.GetPath(position, _targetPos, _navPath, (AgentType)1, false, true, false) || _navPath.Count == 0)
					{
						Finish(success: false, "No path found");
						return;
					}
				}
				if (_navPath.Count != 0)
				{
					while (_navPath.Count > 1 && Utils.DistanceXZ(position, _navPath[0]) < 1.5f)
					{
						_navPath.RemoveAt(0);
					}
					Vector3 val = _navPath[0] - position;
					val.y = 0f;
					if (((Vector3)(ref val)).magnitude > 0.1f)
					{
						((Vector3)(ref val)).Normalize();
					}
					((Character)localPlayer).SetMoveDir(val);
					((Character)localPlayer).SetLookDir(val, 0f);
					((Character)localPlayer).SetRun(num2 > 5f);
				}
			}
		}

		private void Finish(bool success, string message)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			Vector3 val = (((Object)(object)localPlayer != (Object)null) ? ((Component)localPlayer).transform.position : Vector3.zero);
			float num = (((Object)(object)localPlayer != (Object)null) ? Utils.DistanceXZ(val, _targetPos) : (-1f));
			StopNavigation(message);
			_tcs?.TrySetResult(new
			{
				success = success,
				message = message,
				finalPosition = new { val.x, val.y, val.z },
				distanceToTarget = (float)Math.Round(num, 2)
			});
		}
	}
	public static class PlayerEvents
	{
		private static IEventManager? _events;

		private static float _lastHealth = -1f;

		private static float _nextSample;

		public static void Install(Harmony harmony, IEventManager events)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			_events = events;
			MethodInfo methodInfo = AccessTools.Method(typeof(Player), "OnDeath", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(PlayerEvents), "OnDeathPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				ValAgentBridgePlugin.ModLogger.LogWarning((object)"Player.OnDeath not found; player/death events won't be sent.");
			}
		}

		public static void Tick()
		{
			if (Time.unscaledTime < _nextSample)
			{
				return;
			}
			_nextSample = Time.unscaledTime + 0.5f;
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				_lastHealth = -1f;
				return;
			}
			float health = ((Character)localPlayer).GetHealth();
			if (_lastHealth < 0f)
			{
				_lastHealth = health;
				return;
			}
			float num = health - _lastHealth;
			if (!(Mathf.Abs(num) < 1f))
			{
				_lastHealth = health;
				Send("player/health_changed", new
				{
					health = (float)Math.Round(health, 1),
					maxHealth = (float)Math.Round(((Character)localPlayer).GetMaxHealth(), 1),
					change = (float)Math.Round(num, 1)
				});
			}
		}

		private static void OnDeathPostfix(Player __instance)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				Vector3 position = ((Component)__instance).transform.position;
				Send("player/death", new
				{
					position = new
					{
						x = (float)Math.Round(position.x, 1),
						y = (float)Math.Round(position.y, 1),
						z = (float)Math.Round(position.z, 1)
					},
					biome = ((object)__instance.GetCurrentBiome()/*cast due to .constrained prefix*/).ToString()
				});
				_lastHealth = -1f;
			}
		}

		private static void Send(string channel, object payload)
		{
			Recorder.AddEvent(channel, payload);
			try
			{
				IEventManager? events = _events;
				if (events != null)
				{
					events.EmitEventAsync(channel, payload, (DateTimeOffset?)null).ContinueWith(delegate(Task t)
					{
						_ = t.Exception;
					});
				}
			}
			catch (Exception)
			{
			}
		}
	}
	public static class PlayerLook
	{
		private static readonly FieldRef<Character, Quaternion> LookYaw = AccessTools.FieldRefAccess<Character, Quaternion>("m_lookYaw");

		private static readonly FieldRef<Player, float> LookPitch = AccessTools.FieldRefAccess<Player, float>("m_lookPitch");

		public static void Set(Player player, float heading, float tilt)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			tilt = Mathf.Clamp(tilt, -80f, 80f);
			LookYaw.Invoke((Character)(object)player) = Quaternion.Euler(0f, heading, 0f);
			LookPitch.Invoke(player) = 0f - tilt;
			((Character)player).SetLookDir(Quaternion.Euler(0f - tilt, heading, 0f) * Vector3.forward, 0f);
			player.FaceLookDirection();
		}

		public static bool Face(Player player, Vector3 direction)
		{
			//IL_001d: 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)
			direction.y = 0f;
			if (((Vector3)(ref direction)).magnitude < 0.01f)
			{
				return false;
			}
			Set(player, Mathf.Atan2(direction.x, direction.z) * 57.29578f, 0f);
			return true;
		}
	}
	public class BridgeConfig
	{
		[JsonProperty("port")]
		public int Port { get; set; }

		[JsonProperty("token")]
		public string Token { get; set; } = "";

		[JsonProperty("gameId")]
		public string GameId { get; set; } = "valheim";
	}
	[BepInPlugin("BarryWhite.ValAgentBridge", "ValAgentBridge", "1.5.5")]
	public class ValAgentBridgePlugin : BaseUnityPlugin
	{
		private const string ModName = "ValAgentBridge";

		private const string ModVersion = "1.5.5";

		private const string Author = "BarryWhite";

		private const string ModGUID = "BarryWhite.ValAgentBridge";

		public static readonly ManualLogSource ModLogger = Logger.CreateLogSource("ValAgentBridge");

		private GabpServer? _server;

		private Harmony? _harmony;

		private bool _bridgeUp;

		public static IToolRegistry? Tools { get; private set; }

		public void Start()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			ModLogger.LogInfo((object)"ValAgentBridge v1.5.5 is loading...");
			if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("GABP_SERVER_PORT")) && string.IsNullOrEmpty(Environment.GetEnvironmentVariable("GABS_BRIDGE_PATH")))
			{
				ModLogger.LogInfo((object)"Not started by GABS, so the bridge stays off.");
				return;
			}
			try
			{
				_harmony = new Harmony("BarryWhite.ValAgentBridge");
				Harmony recorderHarmony = _harmony;
				Optional("Log and message recording", delegate
				{
					Recorder.Install(recorderHarmony);
				});
				BridgeConfig bridgeConfig = ReadBridgeConfig();
				ModLogger.LogInfo((object)$"GABP config loaded - GameId: {bridgeConfig.GameId}, Port: {bridgeConfig.Port}");
				_server = Gabp.CreateServerWithExternalConfig("Valheim", "1.5.5", bridgeConfig.Port, bridgeConfig.Token, bridgeConfig.GameId);
				ToolGuard.RegisterChecked(_server.Tools, new PlayerTools());
				ToolGuard.RegisterChecked(_server.Tools, new ZNetSceneTools());
				ToolGuard.RegisterChecked(_server.Tools, new TerminalTools());
				ToolGuard.RegisterChecked(_server.Tools, new WorldTools());
				ToolGuard.RegisterChecked(_server.Tools, new ModTools());
				ToolGuard.RegisterChecked(_server.Tools, new ScreenTools());
				ToolGuard.RegisterChecked(_server.Tools, new LogTools());
				ToolGuard.RegisterChecked(_server.Tools, new UiTools());
				ToolGuard.RegisterChecked(_server.Tools, new TimeTools());
				ToolGuard.RegisterChecked(_server.Tools, new EditTools());
				ToolGuard.RegisterChecked(_server.Tools, new WatchTools());
				ToolGuard.RegisterChecked(_server.Tools, new TestTools());
				ToolGuard.RegisterChecked(_server.Tools, new ItemTools());
				ToolGuard.RegisterChecked(_server.Tools, new ControlTools());
				ToolGuard.RegisterChecked(_server.Tools, new InputTools());
				Optional("Commands from other mods", delegate
				{
					ModCommands.RegisterAll(_server.Tools);
				});
				Tools = _server.Tools;
				_server.Events.RegisterChannel("player/death", "Player death events");
				_server.Events.RegisterChannel("player/health_changed", "Player health change events");
				Harmony harmony = _harmony;
				IEventManager events = _server.Events;
				Optional("Player events", delegate
				{
					PlayerEvents.Install(harmony, events);
				});
				_bridgeUp = true;
				MainThreadDispatcher.Init();
				_ = NavigationManager.Instance;
				_ = MovementManager.Instance;
				_server.StartAsync(default(CancellationToken)).ContinueWith(delegate(Task task)
				{
					if (task.IsFaulted)
					{
						ModLogger.LogError((object)("GABP server failed to start: " + task.Exception?.InnerException?.Message));
					}
					else
					{
						ModLogger.LogInfo((object)$"GABP server listening on 127.0.0.1:{_server.Port}");
						ModLogger.LogInfo((object)"ValAgentBridge loaded successfully!");
					}
				});
			}
			catch (Exception ex)
			{
				ModLogger.LogError((object)("Failed to initialize GABP server: " + ex.Message));
				ModLogger.LogError((object)("Stack trace: " + ex.StackTrace));
			}
		}

		private static void Optional(string what, Action step)
		{
			try
			{
				step();
			}
			catch (Exception ex)
			{
				Exception baseException = ex.GetBaseException();
				ModLogger.LogWarning((object)(what + " unavailable (" + baseException.GetType().Name + ": " + baseException.Message + "); the bridge runs without it."));
			}
		}

		private BridgeConfig ReadBridgeConfig()
		{
			string environmentVariable = Environment.GetEnvironmentVariable("GABS_GAME_ID");
			string environmentVariable2 = Environment.GetEnvironmentVariable("GABP_SERVER_PORT");
			string environmentVariable3 = Environment.GetEnvironmentVariable("GABP_TOKEN");
			if (!string.IsNullOrEmpty(environmentVariable2) && !string.IsNullOrEmpty(environmentVariable3) && int.TryParse(environmentVariable2, out var result))
			{
				ModLogger.LogInfo((object)"Config loaded from environment variables");
				return new BridgeConfig
				{
					Port = result,
					Token = environmentVariable3,
					GameId = (environmentVariable ?? "valheim")
				};
			}
			string environmentVariable4 = Environment.GetEnvironmentVariable("GABS_BRIDGE_PATH");
			if (!string.IsNullOrEmpty(environmentVariable4) && File.Exists(environmentVariable4))
			{
				ModLogger.LogInfo((object)("Config loaded from bridge file: " + environmentVariable4));
				return JsonConvert.DeserializeObject<BridgeConfig>(File.ReadAllText(environmentVariable4)) ?? throw new Exception("Failed to parse bridge.json");
			}
			throw new Exception("GABP server config not found. Start the game through GABS. Expected: GABP_SERVER_PORT and GABP_TOKEN environment variables, or GABS_BRIDGE_PATH.");
		}

		private void Update()
		{
			if (_bridgeUp)
			{
				PlayerEvents.Tick();
			}
		}

		private void OnDestroy()
		{
			ModLogger.LogInfo((object)"ValAgentBridge is unloading...");
			if (_server == null)
			{
				return;
			}
			try
			{
				_server.StopAsync(default(CancellationToken)).ContinueWith(delegate(Task task)
				{
					if (task.IsFaulted)
					{
						ModLogger.LogError((object)("Error stopping GABP server: " + task.Exception?.InnerException?.Message));
					}
					else
					{
						ModLogger.LogInfo((object)"GABP server stopped");
					}
				});
				_server.Dispose();
			}
			catch (Exception ex)
			{
				ModLogger.LogError((object)("Error disposing GABP server: " + ex.Message));
			}
		}
	}
	public static class Recorder
	{
		public sealed class LogEntry
		{
			public long seq;

			public string time = "";

			public string level = "";

			public string source = "";

			public string text = "";
		}

		public sealed class MessageEntry
		{
			public long seq;

			public string time = "";

			public string type = "";

			public string text = "";
		}

		public sealed class EventEntry
		{
			public long seq;

			public string time = "";

			public string channel = "";

			public object? data;
		}

		private sealed class Listener : ILogListener, IDisposable
		{
			public void LogEvent(object sender, LogEventArgs e)
			{
				//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)
				try
				{
					string text = ((object)e.Level/*cast due to .constrained prefix*/).ToString();
					string text2;
					try
					{
						text2 = e.Data?.ToString() ?? "";
					}
					catch (Exception ex)
					{
						text2 = "(log line could not be read: " + ex.GetType().Name + ")";
					}
					LogEntry logEntry = new LogEntry();
					logEntry.time = DateTime.Now.ToString("HH:mm:ss.fff");
					logEntry.level = (text.Contains(",") ? text.Split(new char[1] { ',' })[0].Trim() : text);
					ILogSource source = e.Source;
					logEntry.source = ((source != null) ? source.SourceName : null) ?? "";
					logEntry.text = text2;
					LogEntry logEntry2 = logEntry;
					lock (Gate)
					{
						logEntry2.seq = ++_logSeq;
						Log.AddLast(logEntry2);
						while (Log.Count > 3000)
						{
							Log.RemoveFirst();
						}
					}
				}
				catch
				{
				}
			}

			public void Dispose()
			{
			}
		}

		private static readonly LinkedList<EventEntry> Events = new LinkedList<EventEntry>();

		private static long _eventSeq;

		private const int MaxLog = 3000;

		private const int MaxMessages = 200;

		private static readonly object Gate = new object();

		private static readonly LinkedList<LogEntry> Log = new LinkedList<LogEntry>();

		private static readonly LinkedList<MessageEntry> Messages = new LinkedList<MessageEntry>();

		private static long _logSeq;

		private static long _msgSeq;

		private static List<string>? _consoleCapture;

		public static long LastEventSeq
		{
			get
			{
				lock (Gate)
				{
					return _eventSeq;
				}
			}
		}

		public static long LastLogSeq
		{
			get
			{
				lock (Gate)
				{
					return _logSeq;
				}
			}
		}

		public static long LastMessageSeq
		{
			get
			{
				lock (Gate)
				{
					return _msgSeq;
				}
			}
		}

		public static void AddEvent(string channel, object data)
		{
			lock (Gate)
			{
				Events.AddLast(new EventEntry
				{
					seq = ++_eventSeq,
					time = DateTime.Now.ToString("HH:mm:ss.fff"),
					channel = channel,
					data = data
				});
				while (Events.Count > 500)
				{
					Events.RemoveFirst();
				}
			}
		}

		public static List<EventEntry> EventsSince(long since, string channel, int limit)
		{
			lock (Gate)
			{
				return Events.Where((EventEntry e) => e.seq > since && (channel.Length == 0 || e.channel == channel)).Reverse().Take(limit)
					.Reverse()
					.ToList();
			}
		}

		public static void Install(Harmony harmony)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			Logger.Listeners.Add((ILogListener)(object)new Listener());
			MethodInfo methodInfo = AccessTools.Method(typeof(MessageHud), "ShowMessage", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(Recorder), "ShowMessagePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				ValAgentBridgePlugin.ModLogger.LogWarning((object)"MessageHud.ShowMessage not found; ui/messages will stay empty.");
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Terminal), "AddString", new Type[1] { typeof(string) }, (Type[])null);
			if (methodInfo2 != null)
			{
				harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(Recorder), "AddStringPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		public static List<string> CaptureConsole(Action run)
		{
			List<string> result = (_consoleCapture = new List<string>());
			try
			{
				run();
				return result;
			}
			finally
			{
				_consoleCapture = null;
			}
		}

		private static void AddStringPostfix(string text)
		{
			_consoleCapture?.Add(text);
		}

		public static List<LogEntry> LogSince(long since, string minLevel, string filter, int limit)
		{
			HashSet<string> allowed = AllowedLevels(minLevel);
			lock (Gate)
			{
				return Log.Where((LogEntry e) => e.seq > since && allowed.Contains(e.level) && (filter.Length == 0 || e.text.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0 || e.source.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0)).Reverse().Take(limit)
					.Reverse()
					.ToList();
			}
		}

		public static List<MessageEntry> MessagesSince(long since, int limit)
		{
			lock (Gate)
			{
				return Messages.Where((MessageEntry m) => m.seq > since).Reverse().Take(limit)
					.Reverse()
					.ToList();
			}
		}

		private static HashSet<string> AllowedLevels(string minLevel)
		{
			string[] source = new string[6] { "Fatal", "Error", "Warning", "Message", "Info", "Debug" };
			return new HashSet<string>(source.Take((minLevel ?? "").ToLowerInvariant() switch
			{
				"error" => 1, 
				"warning" => 2, 
				"all" => 5, 
				"debug" => 5, 
				_ => 4, 
			} + 1));
		}

		private unsafe static void ShowMessagePostfix(MessageType type, string text)
		{
			try
			{
				string text2 = ((Localization.instance != null) ? Localization.instance.Localize(text) : text);
				lock (Gate)
				{
					Messages.AddLast(new MessageEntry
					{
						seq = ++_msgSeq,
						time = DateTime.Now.ToString("HH:mm:ss.fff"),
						type = ((object)(*(MessageType*)(&type))/*cast due to .constrained prefix*/).ToString(),
						text = text2
					});
					while (Messages.Count > 200)
					{
						Messages.RemoveFirst();
					}
				}
			}
			catch
			{
			}
		}
	}
	public static class ToolGuard
	{
		public static void RegisterChecked(IToolRegistry target, object instance)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			ToolRegistry inner = new ToolRegistry();
			inner.RegisterToolsFromInstance(instance);
			foreach (ToolInfo info in inner.GetTools())
			{
				string name = info.Name;
				target.RegisterTool(name, (Func<object, Task<object>>)delegate(object input)
				{
					string text = CheckArgs(info, input);
					return (text == null) ? inner.CallToolAsync(name, input) : Task.FromResult((object)new
					{
						success = false,
						error = text
					});
				}, info);
			}
		}

		public static string? CheckArgs(ToolInfo info, object? input)
		{
			JObject val;
			try
			{
				val = (JObject)((input == null) ? null : (((input is JObject) ? input : null) ?? ((input is string text) ? JObject.Parse(text) : JObject.FromObject(input))));
			}
			catch
			{
				return null;
			}
			List<ToolParameterInfo> known = info.Parameters;
			List<string> given = ((val != null) ? (from p in val.Properties()
				select p.Name).ToList() : null) ?? new List<string>();
			List<string> list = given.Where((string g) => !known.Any((ToolParameterInfo p) => string.Equals(p.Name, g, StringComparison.OrdinalIgnoreCase))).ToList();
			List<string> list2 = (from p in known
				where p.Required && !given.Any((string g) => string.Equals(p.Name, g, StringComparison.OrdinalIgnoreCase))
				select p.Name).ToList();
			if (list.Count == 0 && list2.Count == 0)
			{
				return null;
			}
			List<string> list3 = new List<string>();
			if (list.Count > 0)
			{
				list3.Add("unknown argument" + ((list.Count > 1) ? "s" : "") + " " + string.Join(", ", list.Select((string u) => "'" + u + "'")));
			}
			if (list2.Count > 0)
			{
				list3.Add("missing " + string.Join(", ", list2.Select((string m) => "'" + m + "'")));
			}
			return info.Name + ": " + string.Join("; ", list3) + ". It takes: " + Describe(known) + ".";
		}

		private static string Describe(List<ToolParameterInfo> parameters)
		{
			if (parameters.Count == 0)
			{
				return "no arguments";
			}
			return string.Join(", ", parameters.Select((ToolParameterInfo p) => (!p.Required) ? p.Name : (p.Name + " (required)")));
		}

		public static List<string> Suggest(IToolRegistry registry, string wanted, int max = 3)
		{
			wanted = wanted.Replace('.', '/').ToLowerInvariant();
			string area = (Enumerable.Contains(wanted, '/') ? wanted.Substring(0, wanted.IndexOf('/')) : "");
			string verb = wanted.Substring(wanted.IndexOf('/') + 1);
			return (from x in (from x in (from t in registry.GetTools()
						select t.Name).Select(delegate(string n)
					{
						string text = n.ToLowerInvariant();
						string text2 = text.Substring(0, Math.Max(0, text.IndexOf('/')));
						string nVerb = text.Substring(text.IndexOf('/') + 1);
						int num = Distance(verb, nVerb) + ((!(text2 == area)) ? 6 : 0);
						if (verb.Split(new char[1] { '_' }).Any((string w) => w.Length > 2 && nVerb.Contains(w)))
						{
							num -= 3;
						}
						return (n: n, score: num);
					})
					orderby x.score, x.n
					select x).Take(max)
				select x.n).ToList();
		}

		private static int Distance(string a, string b)
		{
			int[,] array = new int[a.Length + 1, b.Length + 1];
			for (int i = 0; i <= a.Length; i++)
			{
				array[i, 0] = i;
			}
			for (int j = 0; j <= b.Length; j++)
			{
				array[0, j] = j;
			}
			for (int k = 1; k <= a.Length; k++)
			{
				for (int l = 1; l <= b.Length; l++)
				{
					array[k, l] = Math.Min(Math.Min(array[k - 1, l] + 1, array[k, l - 1] + 1), array[k - 1, l - 1] + ((a[k - 1] != b[l - 1]) ? 1 : 0));
				}
			}
			return array[a.Length, b.Length];
		}
	}
}
namespace ValAgentBridge.Tools
{
	public class ControlTools
	{
		private const float HighUp = 800f;

		private const float RayStart = 1000f;

		private static readonly int SolidMask = LayerMask.GetMask(new string[5] { "Default", "static_solid", "Default_small", "piece", "terrain" });

		private static FieldRef<Character, float>? _maxAirAltitude;

		private static readonly object KeepClearGate = new object();

		private static Timer? _keepClear;

		private static float _keepClearRadius;

		private static double _keepClearEvery;

		private static bool _keepClearBosses;

		private static int _keepClearRemoved;

		private static int _keepClearBusy;

		public static bool KeepClearOn { get; private set; }

		public static bool KeepClearChosen { get; private set; }

		private static void Log(string text)
		{
			ValAgentBridgePlugin.ModLogger.LogInfo((object)text);
		}

		private static bool TryLandingHeight(float x, float z, out float y)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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)
			y = 0f;
			ZoneSystem instance = ZoneSystem.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			foreach (RaycastHit item in from h in Physics.RaycastAll(new Vector3(x, 1000f, z), Vector3.down, 1100f, SolidMask, (QueryTriggerInteraction)1)
				orderby ((RaycastHit)(ref h)).distance
				select h)
			{
				RaycastHit current = item;
				if (!((Object)(object)((RaycastHit)(ref current)).collider.attachedRigidbody != (Object)null) && !((Object)(object)((Component)((RaycastHit)(ref current)).collider).GetComponentInParent<TreeBase>() != (Object)null))
				{
					y = Mathf.Max(((RaycastHit)(ref current)).point.y, instance.m_waterLevel) + 0.5f;
					return true;
				}
			}
			return false;
		}

		[Tool("player/teleport", Description = "(cheat) Teleport the player to a world position. Without a height the player lands on the highest surface there: ground, a rock, a roof (not tree tops), or the water surface; give the height to land inside a building. Waits until the teleport has finished (far ones load the area first) and returns where the player ended up.")]
		public object Teleport([ToolParameter(Description = "X coordinate")] float x, [ToolParameter(Description = "Z coordinate")] float z, [ToolParameter(Description = "Height; leave out to land on top of whatever is there")] float y = float.NaN)
		{
			bool landLater = false;
			int abandoned = 0;
			string text;
			try
			{
				text = MainThreadDispatcher.Run(delegate
				{
					//IL_0030: Unknown result type (might be due to invalid IL or missing references)
					//IL_0035: Unknown result type (might be due to invalid IL or missing references)
					//IL_0088: Unknown result type (might be due to invalid IL or missing references)
					//IL_0093: Unknown result type (might be due to invalid IL or missing references)
					//IL_0099: Unknown result type (might be due to invalid IL or missing references)
					//IL_00af: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
					//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
					//IL_010a: Unknown result type (might be due to invalid IL or missing references)
					if (Interlocked.CompareExchange(ref abandoned, 0, 0) != 0)
					{
						return "abandoned";
					}
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						return "No local player (not in a world).";
					}
					Vector3 position = ((Component)localPlayer).transform.position;
					float y2 = y;
					if (float.IsNaN(y) && !TryLandingHeight(x, z, out y2))
					{
						y2 = 800f;
						landLater = true;
					}
					Vector3 val = default(Vector3);
					((Vector3)(ref val))..ctor(x, y2, z);
					bool flag = landLater || Vector3.Distance(new Vector3(position.x, 0f, position.z), new Vector3(x, 0f, z)) > 64f;
					if (!((Character)localPlayer).TeleportTo(val, ((Component)localPlayer).transform.rotation, flag))
					{
						return "The game refused (already teleporting, or within 2 s of the last teleport). Try again in a moment.";
					}
					Log(string.Format("player/teleport: ({0:F0}, {1:F0}, {2:F0}) -> ({3:F0}, {4}, {5:F0})", position.x, position.y, position.z, x, landLater ? "ground" : y2.ToString("F0"), z));
					return (string)null;
				}, 15000);
			}
			catch (TimeoutException)
			{
				Interlocked.Exchange(ref abandoned, 1);
				text = "The game's main thread did not answer in time (loading screen or paused?); the teleport was cancelled.";
			}
			catch (Exception ex2)
			{
				text = ex2.GetBaseException().Message;
			}
			if (text != null)
			{
				return new
				{
					success = false,
					error = text
				};
			}
			Stopwatch stopwatch = Stopwatch.StartNew();
			int landings = 0;
			while (stopwatch.Elapsed.TotalSeconds < 40.0)
			{
				Thread.Sleep(500);
				object obj;
				try
				{
					obj = MainThreadDispatcher.Run(delegate
					{
						//IL_0056: Unknown result type (might be due to invalid IL or missing references)
						//IL_0099: Unknown result type (might be due to invalid IL or missing references)
						//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
						//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
						Player localPlayer = Player.m_localPlayer;
						if ((Object)(object)localPlayer != (Object)null && ((Character)localPlayer).IsTeleporting())
						{
							return (object)null;
						}
						if ((Object)(object)localPlayer != (Object)null && landLater && landings < 3 && TryLandingHeight(x, z, out var y2) && ((Component)localPlayer).transform.position.y - y2 > 2f)
						{
							if (_maxAirAltitude == null)
							{
								_maxAirAltitude = AccessTools.FieldRefAccess<Character, float>("m_maxAirAltitude");
							}
							Vector3 position = default(Vector3);
							((Vector3)(ref position))..ctor(x, y2, z);
							((Component)localPlayer).transform.position = position;
							Rigidbody component = ((Component)localPlayer).GetComponent<Rigidbody>();
							if ((Object)(object)component != (Object)null)
							{
								component.position = position;
								component.linearVelocity = Vector3.zero;
							}
							_maxAirAltitude.Invoke((Character)(object)localPlayer) = y2;
							landings++;
							return (object)null;
						}
						return Pos(localPlayer) ?? "no player";
					}, 5000);
				}
				catch (TimeoutException)
				{
					continue;
				}
				catch (Exception ex4)
				{
					return new
					{
						success = false,
						error = "Teleported, but landing failed: " + ex4.GetBaseException().Message,
						position = (object)null
					};
				}
				if (obj != null)
				{
					return new
					{
						success = true,
						position = obj,
						seconds = Math.Round(stopwatch.Elapsed.TotalSeconds, 1)
					};
				}
			}
			return new
			{
				success = false,
				error = "Still teleporting after 40 s (area slow to load). Check world/status."
			};
		}

		[Tool("world/clear_hostiles", Description = "(cheat) Remove creatures hostile to the player within a radius, so a test isn't interrupted by attacks. Leaves the player untouched (no god mode). Never removes players or tamed animals; bosses only with includeBosses. Returns what was removed.")]
		public object ClearHostiles([ToolParameter(Description = "Radius in metres around the player (default 50, max 200)")] float radius = 50f, [ToolParameter(Description = "Also remove bosses (default false)")] bool includeBosses = false)
		{
			return ClearNow(radius, includeBosses);
		}

		public static object KeepClearState()
		{
			lock (KeepClearGate)
			{
				return KeepClearOn ? new
				{
					on = true,
					radius = _keepClearRadius,
					everySeconds = _keepClearEvery,
					includeBosses = _keepClearBosses,
					removedSoFar = _keepClearRemoved
				} : new
				{
					on = false,
					radius = 0f,
					everySeconds = 0.0,
					includeBosses = false,
					removedSoFar = _keepClearRemoved
				};
			}
		}

		[Tool("world/keep_clear", Description = "(cheat) Removes creatures hostile to the player every few seconds, between calls and test scripts, so one can't kill the character mid-test. Off by default. At the start of testing, offer it to the owner and turn it on only if they want it; leave it off when the test is about hostile creatures (spawning, combat, AI, raids) or measures performance. Same rules as world/clear_hostiles. Returns the state.")]
		public object KeepClear([ToolParameter(Description = "true = keep clearing, false = stop")] bool on, [ToolParameter(Description = "Radius in metres around the player (default 50, max 200)")] float radius = 50f, [ToolParameter(Description = "Seconds between clearings (default 5, 2 to 600)")] double every = 5.0, [ToolParameter(Description = "Also remove bosses (default false)")] bool includeBosses = false)
		{
			lock (KeepClearGate)
			{
				KeepClearChosen = true;
				Switch(on, radius, every, includeBosses);
			}
			return new
			{
				success = true,
				keepClear = KeepClearState()
			};
		}

		private static void Switch(bool on, float radius, double every, bool includeBosses)
		{
			_keepClear?.Dispose();
			_keepClear = null;
			KeepClearOn = on;
			if (on)
			{
				_keepClearRadius = Mathf.Clamp(radius, 1f, 200f);
				_keepClearEvery = Math.Max(2.0, Math.Min(600.0, every));
				_keepClearBosses = includeBosses;
				TimeSpan period = TimeSpan.FromSeconds(_keepClearEvery);
				_keepClear = new Timer(delegate
				{
					KeepClearTick();
				}, null, TimeSpan.Zero, period);
			}
			Log(on ? $"world/keep_clear: on, hostile creatures within {_keepClearRadius:F0} m are removed every {_keepClearEvery:F0} s" : "world/keep_clear: off");
		}

		private static void KeepClearTick()
		{
			if (Interlocked.Exchange(ref _keepClearBusy, 1) == 1)
			{
				return;
			}
			try
			{
				KeepClearOnce();
			}
			finally
			{
				Interlocked.Exchange(ref _keepClearBusy, 0);
			}
		}

		private static void KeepClearOnce()
		{
			float radius;
			bool bosses;
			lock (KeepClearGate)
			{
				if (!KeepClearOn)
				{
					return;
				}
				radius = _keepClearRadius;
				bosses = _keepClearBosses;
			}
			try
			{
				int num = MainThreadDispatcher.Run(() => (!((Object)(object)Player.m_localPlayer == (Object)null)) ? ClearOnMainThread(radius, bosses).total : 0, 5000);
				if (num > 0)
				{
					lock (KeepClearGate)
					{
						_keepClearRemoved += num;
						return;
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private static object ClearNow(float radius, bool includeBosses)
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
				{
					return new
					{
						success = false,
						error = "Not in a world."
					};
				}
				var (removed, kinds, bossesLeft) = ClearOnMainThread(radius, includeBosses);
				return new
				{
					success = true,
					removed = removed,
					kinds = kinds,
					bossesLeft = bossesLeft
				};
			});
		}

		private static (int total, Dictionary<string, int> kinds, int bossesLeft) ClearOnMainThread(float radius, bool includeBosses)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			int num = 0;
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return (total: 0, kinds: dictionary, bossesLeft: 0);
			}
			List<Character> list = new List<Character>();
			Character.GetCharactersInRange(((Component)localPlayer).transform.position, Mathf.Clamp(radius, 1f, 200f), list);
			foreach (Character item in list)
			{
				if (!((Object)(object)item == (Object)null) && !item.IsPlayer() && !item.IsTamed() && BaseAI.IsEnemy((Character)(object)localPlayer, item))
				{
					if (item.IsBoss() && !includeBosses)
					{
						num++;
						continue;
					}
					string prefabName = Utils.GetPrefabName(((Component)item).gameObject);
					dictionary[prefabName] = ((!dictionary.TryGetValue(prefabName, out var value)) ? 1 : (value + 1));
					ZNetScene.instance.Destroy(((Component)item).gameObject);
				}
			}
			int num2 = dictionary.Values.Sum();
			if (num2 > 0)
			{
				Log(string.Format("world/clear_hostiles: removed {0} within {1:F0} m ({2})", num2, radius, string.Join(", ", dictionary.Select((KeyValuePair<string, int> kv) => $"{kv.Value} {kv.Key}"))));
			}
			return (total: num2, kinds: dictionary, bossesLeft: num);
		}

		[Tool("player/set_protection", Description = "Keep the player safe while a test runs: god = takes no damage, ghost = creatures ignore the player. Switched directly, not through the console, so the character is not marked as having used cheats. Leave an argument out to keep it as it is; returns the state before and after. Not saved: both are off again after a restart.")]
		public object SetProtection([ToolParameter(Description = "No damage (true/false; leave out to keep)")] string god = "", [ToolParameter(Description = "Creatures ignore the player (true/false; leave out to keep)")] string ghost = "")
		{
			bool? wantGod = Flag(god);
			bool? wantGhost = Flag(ghost);
			if ((god.Length > 0 && !wantGod.HasValue) || (ghost.Length > 0 && !wantGhost.HasValue))
			{
				return new
				{
					success = false,
					error = "god and ghost take true or false."
				};
			}
			return MainThreadDispatcher.RunTool(delegate
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return new
					{
						success = false,
						error = "Not in a world."
					};
				}
				var before = new
				{
					god = ((Character)localPlayer).InGodMode(),
					ghost = ((Character)localPlayer).InGhostMode()
				};
				if (wantGod.HasValue)
				{
					localPlayer.SetGodMode(wantGod.Value);
				}
				if (wantGhost.HasValue)
				{
					localPlayer.SetGhostMode(wantGhost.Value);
				}
				var anon = new
				{
					god = ((Character)localPlayer).InGodMode(),
					ghost = ((Character)localPlayer).InGhostMode()
				};
				if (wantGod.HasValue || wantGhost.HasValue)
				{
					Log($"player/set_protection: god {anon.god}, ghost {anon.ghost}");
				}
				return new
				{
					success = true,
					before = before,
					after = anon
				};
			});
		}

		private static bool? Flag(string text)
		{
			switch (text.Trim().ToLowerInvariant())
			{
			case "on":
			case "1":
			case "yes":
			case "true":
				return true;
			case "no":
			case "0":
			case "off":
			case "false":
				return false;
			default:
				return null;
			}
		}

		[Tool("world/find_locations", Description = "Find generated places (trader, boss altars, dungeons, villages, ...) nearest the player. With no name: lists the place types in this world and how many of each. Names are prefab names, e.g. Vendor_BlackForest, Eikthyrnir, Crypt2, StartTemple; a part of the name matches.")]
		public object FindLocations([ToolParameter(Description = "Part of the place name (empty = list the types)")] string name = "", [ToolParameter(Description = "How many to return (default 5)")] int max = 5)
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				//IL_00c9: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)ZoneSystem.instance == (Object)null)
				{
					return new
					{
						success = false,
						error = "Not in a world."
					};
				}
				List<LocationInstance> list = ZoneSystem.instance.GetLocationList().ToList();
				if (string.IsNullOrWhiteSpace(name))
				{
					var types = (from g in list.GroupBy(NameOf)
						orderby g.Key
						select new
						{
							name = g.Key,
							count = g.Count()
						}).ToList();
					return new
					{
						success = true,
						total = list.Count,
						types = types
					};
				}
				Vector3 from = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
				var list2 = (from l in list
					where NameOf(l).IndexOf(name, StringComparison.OrdinalIgnoreCase) >= 0
					select new
					{
						l = l,
						dist = Vector2.Distance(new Vector2(l.m_position.x, l.m_position.z), new Vector2(@from.x, @from.z))
					} into m
					orderby m.dist
					select m).ToList();
				return (list2.Count == 0) ? ((object)new
				{
					success = false,
					error = "No place matching '" + name + "'. Call with no name to list the types."
				}) : ((object)new
				{
					success = true,
					found = list2.Count,
					nearest = (from m in list2.Take(Math.Max(1, max))
						select new
						{
							name = NameOf(m.l),
							position = Vec(m.l.m_position),
							distance = Math.Round(m.dist),
							biome = ((object)Unsafe.As<Biome, Biome>(ref m.l.m_location?.m_biome)/*cast due to .constrained prefix*/).ToString(),
							placed = m.l.m_placed
						}).ToList()
				});
			});
			static string NameOf(LocationInstance l)
			{
				//IL_0000: 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)
				return l.m_location?.m_prefabName ?? l.m_location?.m_name ?? "?";
			}
		}

		[Tool("world/spawn_creature", Description = "(cheat) Spawn creatures (prefab name, e.g. Greyling, Troll, Boar) in front of the player. Returns their instanceIds; remove them again with world/remove_objects.")]
		public object SpawnCreature([ToolParameter(Description = "Creature prefab name (znetscene/search_prefabs to look one up)")] string name, [ToolParameter(Description = "How many (default 1, max 20)")] int amount = 1, [ToolParameter(Description = "Star level: 1 = normal, 2 = one star, 3 = two stars")] int level = 1, [ToolParameter(Description = "Distance in front of the player in metres (default 5)")] float distance = 5f, [ToolParameter(Description = "Spawn tamed (default false)")] bool tamed = false)
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: 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_00c2: 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)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: 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_0115: 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_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: 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_0153: 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_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
				{
					return new
					{
						success = false,
						error = "Not in a world."
					};
				}
				GameObject prefab = ZNetScene.instance.GetPrefab(name);
				if ((Object)(object)prefab == (Object)null)
				{
					return new
					{
						success = false,
						error = "No prefab '" + name + "'. Use znetscene/search_prefabs."
					};
				}
				if ((Object)(object)prefab.GetComponent<Character>() == (Object)null)
				{
					return new
					{
						success = false,
						error = "'" + name + "' is not a creature. For items use player/give_item."
					};
				}
				amount = Mathf.Clamp(amount, 1, 20);
				Vector3 val = ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * distance;
				List<object> list = new List<object>();
				float num = default(float);
				for (int i = 0; i < amount; i++)
				{
					Vector3 val2 = ((amount == 1) ? Vector3.zero : (Quaternion.Euler(0f, 360f * (float)i / (float)amount, 0f) * Vector3.forward * 1.5f));
					Vector3 val3 = val + val2;
					if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetSolidHeight(val3, ref num, 1000))
					{
						val3.y = num + 0.2f;
					}
					GameObject val4 = Object.Instantiate<GameObject>(prefab, val3, Quaternion.LookRotation(-((Component)localPlayer).transform.forward));
					Character component = val4.GetComponent<Character>();
					if (level > 1)
					{
						component.SetLevel(Mathf.Clamp(level, 1, 10));
					}
					if (tamed)
					{
						component.SetTamed(true);
					}
					list.Add(new
					{
						instanceId = ((Object)val4).GetInstanceID(),
						position = Vec(val3)
					});
				}
				Log(string.Format("world/spawn_creature: {0} x {1} (level {2}{3})", amount, name, level, tamed ? ", tamed" : ""));
				return new
				{
					success = true,
					name = name,
					level = level,
					spawned = list
				};
			});
		}

		[Tool("world/remove_objects", Description = "(cheat) Remove objects from the world by instanceId (creatures spawned for a test, dropped items, ...). Never removes the player.")]
		public object RemoveObjects([ToolParameter(Description = "instanceIds as a JSON array, e.g. [123, 456]")] string ids)
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				List<int> list;
				try
				{
					list = JsonConvert.DeserializeObject<List<int>>(ids) ?? new List<int>();
				}
				catch (Exception ex)
				{
					return new
					{
						success = false,
						error = "ids is not a JSON array of numbers: " + ex.Message
					};
				}
				HashSet<int> hashSet = new HashSet<int>(list);
				int num = 0;
				ZNetView[] array = Object.FindObjectsByType<ZNetView>((FindObjectsSortMode)0);
				foreach (ZNetView val in array)
				{
					if (!((Object)(object)val == (Object)null) && hashSet.Contains(((Object)((Component)val).gameObject).GetInstanceID()) && !((Object)(object)((Component)val).GetComponent<Player>() != (Object)null))
					{
						ZNetScene.instance.Destroy(((Component)val).gameObject);
						num++;
					}
				}
				Log($"world/remove_objects: removed {num} of {list.Count}");
				return new
				{
					success = true,
					removed = num,
					notFound = list.Count - num
				};
			});
		}

		[Tool("env/status", Description = "Time of day (hour 0-24, day number), current weather, whether time or weather are pinned, and the weather names that can be set.")]
		public object EnvStatus()
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				EnvMan instance = EnvMan.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return new
					{
						success = false,
						error = "Not in a world."
					};
				}
				EnvSetup currentEnvironment = instance.GetCurrentEnvironment();
				return new
				{
					success = true,
					hour = Math.Round(instance.GetDayFraction() * 24f, 2),
					day = instance.GetDay(),
					night = EnvMan.IsNight(),
					weather = currentEnvironment?.m_name,
					timePinned = instance.m_debugTimeOfDay,
					weatherPinned = (string.IsNullOrEmpty(instance.m_debugEnv) ? null : instance.m_debugEnv),
					weathers = (from n in instance.m_environments.Select((EnvSetup e) => e.m_name).Distinct()
						orderby n
						select n).ToList()
				};
			});
		}

		[Tool("env/set_time", Description = "(cheat) Set the time of day. By default the clock jumps forward to that hour and keeps running (like sleeping). pin=true holds it there for repeatable tests (shown time only; pin=false with hour -1 releases it).")]
		public object SetTime([ToolParameter(Description = "Hour 0-24 (6 = sunrise, 12 = noon, 22 = night); -1 with pin=false just releases a pinned time")] float hour, [ToolParameter(Description = "Hold the time there (default false)")] bool pin = false)
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				EnvMan instance = EnvMan.instance;
				if ((Object)(object)instance == (Object)null || (Object)(object)ZNet.instance == (Object)null)
				{
					return new
					{
						success = false,
						error = "Not in a world."
					};
				}
				if (hour < 0f)
				{
					instance.m_debugTimeOfDay = false;
					Log("env/set_time: time released");
					return new
					{
						success = true,
						pinned = false,
						hour = Math.Round(instance.GetDayFraction() * 24f, 2)
					};
				}
				float num = Mathf.Repeat(hour, 24f) / 24f;
				if (pin)
				{
					instance.m_debugTimeOfDay = true;
					instance.m_debugTime = num;
				}
				else
				{
					instance.m_debugTimeOfDay = false;
					double num2 = instance.m_dayLengthSec;
					double timeSeconds = ZNet.instance.GetTimeSeconds();
					double num3 = (double)instance.GetDay(timeSeconds) * num2 + RawFraction(num) * num2;
					if (num3 <= timeSeconds)
					{
						num3 += num2;
					}
					ZNet.instance.SetNetTime(num3);
				}
				Log(string.Format("env/set_time: {0:F1}h{1}", hour, pin ? " (pinned)" : ""));
				return new
				{
					success = true,
					pinned = pin,
					hour = Math.Round(num * 24f, 2)
				};
			});
		}

		private static double RawFraction(float shown)
		{
			if (shown >= 0.25f && shown <= 0.75f)
			{
				return 0.15 + ((double)shown - 0.25) / 0.5 * 0.7;
			}
			if (shown < 0.25f)
			{
				return (double)shown / 0.25 * 0.15;
			}
			return 0.85 + ((double)shown - 0.75) / 0.25 * 0.15;
		}

		[Tool("env/set_weather", Description = "(cheat) Force a weather (name from env/status, e.g. Clear, Rain, ThunderStorm, Snow, Misty). Empty name goes back to normal weather.")]
		public object SetWeather([ToolParameter(Description = "Weather name; empty = normal weather again")] string name = "")
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				EnvMan instance = EnvMan.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return new
					{
						success = false,
						error = "Not in a world."
					};
				}
				if (name.Length > 0)
				{
					EnvSetup val = ((IEnumerable<EnvSetup>)instance.m_environments).FirstOrDefault((Func<EnvSetup, bool>)((EnvSetup e) => string.Equals(e.m_name, name, StringComparison.OrdinalIgnoreCase)));
					if (val == null)
					{
						return new
						{
							success = false,
							error = "No weather '" + name + "'. Have: " + string.Join(", ", instance.m_environments.Select((EnvSetup e) => e.m_name).Distinct())
						};
					}
					name = val.m_name;
				}
				instance.m_debugEnv = name;
				Log("env/set_weather: " + ((name.Length == 0) ? "normal" : name));
				return new
				{
					success = true,
					weather = ((name.Length == 0) ? "normal" : name)
				};
			});
		}

		[Tool("world/save", Description = "Save the world and characters now (like the 'save' console command). Returns once the save has been started; the game shows 'World saved' when done.")]
		public object Save()
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				if ((Object)(object)ZNet.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return new
					{
						success = false,
						error = "Not in a world."
					};
				}
				ZNet.instance.SaveWorldAndPlayerProfiles();
				Log("world/save");
				return new
				{
					success = true
				};
			});
		}

		[Tool("player/look_direction", Description = "Turn the player and camera to a compass heading and tilt, e.g. to aim a screenshot. Heading: 0 = north (+Z), 90 = east (+X). Tilt: 0 = level, positive = up, negative = down.")]
		public object LookDirection([ToolParameter(Description = "Heading in degrees (0 = north, 90 = east)")] float heading, [ToolParameter(Description = "Tilt in degrees (-80 to 80, default 0)")] float tilt = 0f)
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return new
					{
						success = false,
						error = "Not in a world."
					};
				}
				PlayerLook.Set(localPlayer, heading, tilt);
				return new
				{
					success = true,
					heading = heading,
					tilt = Mathf.Clamp(tilt, -80f, 80f)
				};
			});
		}

		private static object? Pos(Player? player)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null))
			{
				return Vec(((Component)player).transform.position);
			}
			return null;
		}

		private static object Vec(Vector3 v)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return new
			{
				x = Math.Round(v.x, 1),
				y = Math.Round(v.y, 1),
				z = Math.Round(v.z, 1)
			};
		}
	}
	public class EditTools
	{
		[Tool("debug/set_value", Description = "Change a live field or property by path (same paths as debug/inspect), e.g. 'Player.m_localPlayer.m_maxCarryWeight' = 600. Lasts until the game or mod changes it back or the game restarts.")]
		public object SetValue([ToolParameter(Description = "Dotted path to the field or property")] string path, [ToolParameter(Description = "New value as text: number, true/false, enum name, 'x,y,z' for a Vector3, JSON for anything else")] string value)
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				string error;
				Inspector.PathEnd pathEnd = Inspector.ResolvePath(path, out error);
				if (pathEnd == null)
				{
					return new
					{
						success = false,
						error = error
					};
				}
				if (!Inspector.Write(pathEnd, value, out object before, out object after, out error))
				{
					return new
					{
						success = false,
						error = error
					};
				}
				ValAgentBridgePlugin.ModLogger.LogInfo((object)$"debug/set_value: {path}: {before} -> {after}");
				return new
				{
					success = true,
					path = path,
					before = Inspector.Describe(before, 1),
					after = Inspector.Describe(after, 1)
				};
			});
		}

		[Tool("debug/call_method", Description = "Run a method on a type (static) or on the object at a path, e.g. target 'Player.m_localPlayer', method 'GetHealth', args '[]'. A Vector3 argument can be [x, y, z] or \"x,y,z\". Returns what it returned.")]
		public object CallMethod([ToolParameter(Description = "A type (for static methods) or a path to an object")] string target, [ToolParameter(Description = "Method name")] string method, [ToolParameter(Description = "Arguments as a JSON array, e.g. '[5, \"Wood\"]' (default none)")] string args = "[]", [ToolParameter(Description = "Levels of fields to show in the result (default 1)")] int depth = 1)
		{
			return MainThreadDispatcher.RunTool(delegate
			{
				JArray argList;
				try
				{
					argList = JArray.Parse(string.IsNullOrWhiteSpace(args) ? "[]" : args);
				}
				catch (Exception ex)
				{
					return new
					{
						success = false,
						error = "args is not a JSON array: " + ex.Message
					};
				}
				string error;
				Inspector.PathEnd pathEnd = Inspector.ResolvePath(target, out error);
				if (pathEnd == null)
				{
					return new
					{
						success = false,
						error = error
					};
				}
				object instance = null;
				Type type = pathEnd.OwnerType;
				if (!pathEnd.IsTypeOnly)
				{
					if (!Inspector.Read(pathEnd, out instance, out error))
					{
						return new
						{
							success = false,
							error = error
						};
					}
					if (instance != null)
					{
						object obj = instance;
						Object val = (Object)((obj is Object) ? obj : null);
						if (val == null || !(val == (Object)null))
						{
							type = instance.GetType();
							goto IL_00e6;
						}
					}
					return new
					{
						success = false,
						error = "'" + target + "' is null"
					};
				}
				goto IL_00e6;
				IL_00e6:
				List<MethodInfo> list = (from m in type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
					where m.Name == method && m.GetParameters().Length == ((JContainer)argList).Count && !m.ContainsGenericParameters
					where instance != null || m.IsStatic
					select m).ToList();
				if (list.Count == 0)
				{
					List<string> list2 = (from m in type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
						where m.Name == method
						select m.Name + "(" + string.Join(", ", from p in m.GetParameters()
							select p.ParameterType.Name + " " + p.Name) + ")").Distinct().ToList();
					return new
					{
						success = false,
						error = ((list2.Count == 0) ? (type.Name + " has no method '" + method + "'") : string.Format("No overload takes {0} argument(s). Have: {1}", ((JContainer)argList).Count, string.Join("; ", list2)))
					};
				}
				foreach (MethodInfo item in list)
				{
					object[] parameters;
					try
					{
						parameters = item.GetParameters().Select((ParameterInfo p, int i) => ConvertArg(argList[i], p.ParameterType)).ToArray();
					}
					catch
					{
						continue;
					}
					try
					{
						object value = item.Invoke(item.IsStatic ? null : instance, parameters);
						ValAgentBridgePlugin.ModLogger.LogInfo((object)("debug/call_method: " + type.Name + "." + item.Name + "(" + args + ")"));
						return new
						{
							success = true,
							method = type.Name + "." + item.Name,
							returned = ((item.ReturnType == typeof(void)) ? null : Inspector.Describe(value, Mathf.Clamp(depth, 0, 4)))
						};
					}
					catch (Exception ex2)
					{
						Exception baseException = ex2.GetBaseException();
						return new
						{
							success = false,
							error = type.Name + "." + item.Name + " threw " + baseException.GetType().Name + ": " + baseException.Message
						};
					}
				}
				return new
				{
					success = false,
					error = "The arguments don't fit any overload's parameter types."
				};
			});
		}

		private static object? ConvertArg(JToken token, Type type)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			if ((int)token.Type == 10)
			{
				return null;
			}
			if ((int)token.Type == 8 && type != typeof(string))
			{
				return Inspector.ConvertText(Extensions.Value<string>((IEnumerable<JToken>)token), type);
			}
			JArray val = (JArray)(object)((token is JArray) ? token : null);
			if (val != null && (type == typeof(Vector3) || type == typeof(Vector2)))
			{
				return Inspector.ConvertText(string.Join(",", ((IEnumerable<JToken>)val).Select((JToken n) => ((object)n).ToString())), type);
			}
			return token.ToObject(type);
		}
	}
	public class InputTools
	{
		private sealed class Simulated
		{
			public int down;

			public int up;
		}

		private static readonly Dictionary<KeyCode, Simulated> Keys = new Dictionary<KeyCode, Simulated>();

		private static bool _patched;

		private static string? _patchProblem;

		[Tool("input/press_key", Description = "Press a key (with optional modifiers) for a moment, as if typed: F11, Escape, Tab, Alpha1 / 1, LeftShift, ... Reaches the game's controls and mod hotkeys set up through BepInEx (most mods); not mods that read UnityEngine.Input directly. Returns once the key is released.")]
		public object PressKey([ToolParameter(Description = "Key name (Unity KeyCode, e.g. F11, Escape, Return, A, Alpha1 or 1)")] string key, [ToolParameter(Description = "Modifiers held with it, comma separated: ctrl, shift, alt (or KeyCode names)")] string modifiers = "", [ToolParameter(Description = "Frames to hold the key (default 2)")] int holdFrames = 2)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected I4, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (!TryKey(key, out var key2))
			{
				return new
				{
					success = false,
					error = "Unknown key '" + key + "'. Use Unity KeyCode names, e.g. F11, Escape, Return, A, Alpha1."
				};
			}
			List<KeyCode> mods = new List<KeyCode>();
			string[] array = modifiers.Split(new char[3] { ',', '+', ' ' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				if (!TryKey(text, out var key3))
				{
					return new
					{
						success = false,
						error = "Unknown modifier '" + text + "'. Use ctrl, shift, alt or KeyCode names."
					};
				}
				mods.Add(key3);
			}
			List<KeyCode> all = mods.Concat((IEnumerable<KeyCode>)(object)new KeyCode[1] { (KeyCode)(int)key2 }).ToList();
			holdFrames = Mathf.Clamp(holdFrames, 1, 600);
			int num;
			bool gameControls;
			try
			{
				(num, gameControls) = MainThreadDispatcher.Run(delegate
				{
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_002b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: 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)
					EnsurePatched();
					int num2 = Time.frameCount + 1;
					int num3 = num2 + holdFrames;
					foreach (KeyCode item in all)
					{
						Keys[item] = new Simulated
						{
							down = (mods.Contains(item) ? (num2 - 1) : num2),
							up = num3
						};
					}
					bool flag = Keyboard.current != null;
					if (flag)
					{
						((MonoBehaviour)MainThreadDispatcher.Instance).StartCoroutine(PressInputSystem(all, num3));
					}
					return (up: num3, kb: flag);
				}, 5000);
			}
			catch (Exception ex)
			{
				return new
				{
					success = false,
					error = ex.GetBaseException().Message
				};
			}
			DateTime dateTime = DateTime.UtcNow.AddSeconds(30.0);
			while (DateTime.UtcNow < dateTime)
			{
				Thread.Sleep(20);
				try
				{
					if (MainThreadDispatcher.Run(() => Time.frameCount, 2000) > num)
					{
						break;
					}
				}
				catch (TimeoutException)
				{
				}
			}
			try
			{
				MainThreadDispatcher.Run(delegate
				{
					//IL_0010: Unknown result type (might be due