using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using BepInEx;
using HarmonyLib;
using Jotunn;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using PolyhydraGames.Valheim.Core;
using PolyhydraGames.Valheim.Core.Fascade;
using PolyhydraGames.Valheim.Core.Models;
using PolyhydraGames.Valheim.Core.Requests;
using PolyhydraGames.Valheim.Core.Transport;
using PolyhydraGames.Valheim.RestServer.Commands.Abstract;
using PolyhydraGames.Valheim.RestServer.Converters;
using PolyhydraGames.Valheim.RestServer.Extensions;
using PolyhydraGames.Valheim.RestServer.Models;
using PolyhydraGames.Valheim.RestServer.WebServer;
using Splatform;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Profiling;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("PolyhydraGames.RestServer.UnitTests")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("PolyhydraGames.Valheim.RestServer")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+0874a7b6c77e2dd14375be432ef2cffeecd67492")]
[assembly: AssemblyProduct("PolyhydraGames.Valheim.RestServer")]
[assembly: AssemblyTitle("PolyhydraGames.Valheim.RestServer")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer
{
	public class AudioHelper : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <PlayAudioFromUrl>d__0 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string url;

			public Vector3 position;

			private UnityWebRequest <www>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<www>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Invalid comparison between Unknown and I4
				//IL_0034: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						AudioType val2 = (AudioType)(url.Contains(".mp3") ? 13 : 20);
						<www>5__2 = UnityWebRequestMultimedia.GetAudioClip(url, val2);
						<>1__state = -3;
						<>2__current = <www>5__2.SendWebRequest();
						<>1__state = 1;
						return true;
					}
					case 1:
						<>1__state = -3;
						if ((int)<www>5__2.result != 1)
						{
							Debug.LogWarning((object)("Failed to download audio: " + <www>5__2.error));
						}
						else
						{
							AudioClip content = DownloadHandlerAudioClip.GetContent(<www>5__2);
							GameObject val = new GameObject("TempAudio");
							val.transform.position = position;
							AudioSource obj = val.AddComponent<AudioSource>();
							obj.clip = content;
							obj.spatialBlend = 1f;
							obj.Play();
							Object.Destroy((Object)val, content.length);
						}
						<>m__Finally1();
						<www>5__2 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<www>5__2 != null)
				{
					((IDisposable)<www>5__2).Dispose();
				}
			}

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

		[IteratorStateMachine(typeof(<PlayAudioFromUrl>d__0))]
		public IEnumerator PlayAudioFromUrl(string url, Vector3 position)
		{
			//IL_000e: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayAudioFromUrl>d__0(0)
			{
				url = url,
				position = position
			};
		}
	}
	public class CoroutineRunner : MonoBehaviour
	{
		private static CoroutineRunner _instance;

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

		public void Run(IEnumerator routine)
		{
			((MonoBehaviour)this).StartCoroutine(routine);
		}
	}
	public class IsExternalInit
	{
	}
	public class JotunnLogger : IPolyLogger
	{
		public void LogInfo(string message)
		{
			Logger.LogInfo((object)("[PolyValheimRest]" + message));
		}

		public void LogWarning(string message)
		{
			Logger.LogWarning((object)("[PolyValheimRest]" + message));
		}

		public void LogError(string exMessage)
		{
			Logger.LogWarning((object)("[PolyValheimRest]" + exMessage));
		}
	}
	public record PlayerWrapperType(ZNetPeer Peer)
	{
		public ZRpc RPC => Peer.m_rpc;

		public long ZDOID => Peer.m_uid;

		public string Name => Peer.m_playerName;

		public ZDOID PlayerId => Peer.m_characterID;

		public Vector3 RefPosition => Peer.GetRefPos();

		public string SocketEndpoint
		{
			get
			{
				ISocket socket = Peer.m_socket;
				if (socket == null)
				{
					return null;
				}
				return socket.GetEndPointString();
			}
		}

		public ZDO? GetZDO => ZDOMan.instance.GetZDO(Peer.m_characterID);

		public ZDOID? ZdoUid => GetZDO?.m_uid;

		public Vector3? WorldPosition
		{
			get
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				ZDO? getZDO = GetZDO;
				if (getZDO == null)
				{
					return null;
				}
				return getZDO.GetPosition();
			}
		}

		public Quaternion? Rotation
		{
			get
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				ZDO? getZDO = GetZDO;
				if (getZDO == null)
				{
					return null;
				}
				return getZDO.GetRotation();
			}
		}

		public long? UnderlyingUid
		{
			get
			{
				ZDO? getZDO = GetZDO;
				if (getZDO == null)
				{
					return null;
				}
				return getZDO.GetLong(ZDOVars.s_playerID, 0L);
			}
		}

		public long? Owner
		{
			get
			{
				ZDO? getZDO = GetZDO;
				if (getZDO == null)
				{
					return null;
				}
				return getZDO.GetOwner();
			}
		}

		public void PeerInvoke(string method, params object[] args)
		{
			RPC.Invoke(method, args);
		}

		public override string ToString()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return $"{Name} [{ZDOID}] at {RefPosition}";
		}

		[CompilerGenerated]
		protected virtual bool PrintMembers(StringBuilder builder)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			RuntimeHelpers.EnsureSufficientExecutionStack();
			builder.Append("Peer = ");
			builder.Append(Peer);
			builder.Append(", RPC = ");
			builder.Append(RPC);
			builder.Append(", ZDOID = ");
			builder.Append(ZDOID.ToString());
			builder.Append(", Name = ");
			builder.Append((object?)Name);
			builder.Append(", PlayerId = ");
			ZDOID playerId = PlayerId;
			builder.Append(((object)(ZDOID)(ref playerId)).ToString());
			builder.Append(", RefPosition = ");
			Vector3 refPosition = RefPosition;
			builder.Append(((object)(Vector3)(ref refPosition)).ToString());
			builder.Append(", SocketEndpoint = ");
			builder.Append((object?)SocketEndpoint);
			builder.Append(", GetZDO = ");
			builder.Append(GetZDO);
			builder.Append(", ZdoUid = ");
			builder.Append(ZdoUid.ToString());
			builder.Append(", WorldPosition = ");
			builder.Append(WorldPosition.ToString());
			builder.Append(", Rotation = ");
			builder.Append(Rotation.ToString());
			builder.Append(", UnderlyingUid = ");
			builder.Append(UnderlyingUid.ToString());
			builder.Append(", Owner = ");
			builder.Append(Owner.ToString());
			return true;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.polyhydragames.rest", "Polyhydra Games Rest Server", "1.0.1")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony _harmony = new Harmony("com.polyhydragames.rest");

		public const string Guid = "com.polyhydragames.rest";

		public const string Name = "Polyhydra Games Rest Server";

		public const string Version = "1.0.1";

		public const string LogHeader = "[PolyValheimRest]";

		private void Awake()
		{
			Logger.SetLogger((IPolyLogger)(object)new JotunnLogger());
			_harmony.PatchAll();
			RegisterHttpCalls();
			try
			{
				RegistrationHelpers.RegisterAllCommands(Assembly.GetAssembly(typeof(Plugin)));
				Audit();
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("[PolyValheimRcon] Loading failed, hopefully this isn't the server!\n" + ex.Message));
			}
		}

		private void Audit()
		{
			try
			{
				DatabaseHelpers.ListPrefabs();
				DatabaseHelpers.GetEnvironmentNames();
				DatabaseHelpers.GetStatusEffects();
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)ex.Message);
			}
		}

		private void RegisterHttpCalls()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			GameObject val = new GameObject("HttpCommandServer");
			Object.DontDestroyOnLoad((Object)val);
			val.AddComponent<HttpCommandServer>();
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.WebServer
{
	public class ActionManager
	{
		private static ActionManager _instance;

		public Dictionary<string, IRestAction> Actions { get; } = new Dictionary<string, IRestAction>();


		public static ActionManager Instance => _instance ?? (_instance = new ActionManager());

		public string Audit()
		{
			string text = string.Join(" ", Actions.Keys);
			Logger.LogInfo("Actions:" + text);
			return text;
		}

		public PostResponse ProcessCommand(CommandRequestType request)
		{
			IRestAction action = GetAction(request.Command);
			if (action == null)
			{
				return Response.Fail("Command " + request.Command + " was not found. Legal options are: " + string.Join(" ", Actions.Keys));
			}
			return action.OnHandle(request);
		}

		public IRestAction? GetAction(string commandName)
		{
			if (!Actions.ContainsKey(commandName))
			{
				return null;
			}
			return Actions[commandName];
		}

		public bool AddAction(IRestAction action)
		{
			if (Actions.ContainsKey(action.Method))
			{
				return false;
			}
			Actions[action.Method] = action;
			return true;
		}

		private ActionManager()
		{
		}

		public void RegisterCommand(Type type)
		{
			try
			{
				IRestAction action = Activator.CreateInstance(type) as IRestAction;
				AddAction(action);
				Logger.LogWarning("RegisteredCommand: " + type.Name);
			}
			catch (Exception ex)
			{
				Logger.LogWarning("RegisterCommand failed!" + ex.Message + type.Name);
			}
		}
	}
	public static class ActionProcessor
	{
	}
	public class HttpCommandServer : MonoBehaviour
	{
		private HttpListener _listener;

		private Thread _listenerThread;

		private void Start()
		{
			_listener = new HttpListener();
			_listener.Prefixes.Add("http://*:8080/");
			_listener.Start();
			_listenerThread = new Thread(ListenLoop);
			_listenerThread.Start();
			Logger.LogInfo("[MyMod] HTTP command server started on port 8080");
		}

		private void OnDestroy()
		{
			_listener.Stop();
			_listener.Close();
			_listenerThread.Abort();
		}

		private void ListenLoop()
		{
			while (_listener.IsListening)
			{
				try
				{
					HttpListenerContext context = _listener.GetContext();
					string s = HandleRequest(context.Request);
					byte[] bytes = Encoding.UTF8.GetBytes(s);
					context.Response.ContentType = "application/json";
					context.Response.OutputStream.Write(bytes, 0, bytes.Length);
					context.Response.Close();
				}
				catch (Exception ex)
				{
					Debug.LogError((object)("[MyMod] HTTP listener error: " + ex));
				}
			}
		}

		private string HandleRequest(HttpListenerRequest request)
		{
			if (request.HttpMethod != "POST")
			{
				return "{\"status\":\"unknown command\"}";
			}
			using StreamReader streamReader = new StreamReader(request.InputStream, request.ContentEncoding);
			string command = request.GetCommand();
			string text = streamReader.ReadToEnd();
			CommandRequestType request2 = CommandRequest.Create(command, text);
			return ActionManager.Instance.ProcessCommand(request2).ToJson();
		}
	}
	public static class Response
	{
		public static PostResponse Fail(this CommandRequestType request, string errorMessage)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			return new PostResponse
			{
				Success = false,
				Message = errorMessage,
				Command = request.Command
			};
		}

		public static PostResponse Fail(this Exception ex, string errorMessage)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			return new PostResponse
			{
				Success = false,
				Message = ex.Message + " /  " + errorMessage
			};
		}

		public static PostResponse Fail(string errorMessage, string command = "")
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			return new PostResponse
			{
				Success = false,
				Message = errorMessage,
				Command = command
			};
		}

		public static PostResponse Pass(string message, string command)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			return new PostResponse
			{
				Success = true,
				Message = message,
				Command = command
			};
		}

		public static PostResponse Pass(this CommandRequestType command, string message)
		{
			return Pass(message, command.Command);
		}

		public static PostResponse Pass<T>(this T data, string command)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0035: Expected O, but got Unknown
			return new PostResponse
			{
				Success = true,
				Command = command,
				Data = JsonHelpers.ToJson<T>(data),
				DataType = typeof(T).Name
			};
		}
	}
	public static class ResponseHelpers
	{
		private static JsonSerializer? _serializer;

		private static JsonSerializer GetSerializer => _serializer ?? JsonSerializer.Create();

		public static string GetCommand(this string value)
		{
			return value.Split(new char[1] { '/' }, StringSplitOptions.RemoveEmptyEntries).LastOrDefault() ?? string.Empty;
		}

		public static string GetCommand(this HttpListenerRequest request)
		{
			return request.Url.AbsolutePath.GetCommand();
		}

		public static string ToJson(this PostResponse response)
		{
			return JsonConvert.SerializeObject((object)response);
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Models
{
	public interface IRestAction<T> : IRestAction
	{
		string OnHandle(T request);
	}
	public readonly struct ObjectId
	{
		public readonly uint Id;

		public readonly long UserId;

		public ObjectId(uint id, long userId)
		{
			Id = id;
			UserId = userId;
		}
	}
	public interface IRestAction
	{
		string Method { get; }

		string Description { get; }

		PostResponse OnHandle(CommandRequestType request);
	}
	public abstract class RestRequest : IRestAction
	{
		public abstract string Method { get; }

		public abstract string Description { get; }

		public abstract PostResponse OnHandle(CommandRequestType request);
	}
	internal static class ServerConsole
	{
		public static string Execute(string command)
		{
			try
			{
				if ((Object)(object)Console.instance != (Object)null)
				{
					((Terminal)Console.instance).TryRunCommand(command, false, false);
					return "ok: " + command;
				}
				return "dispatched: " + command;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)$"[Rest] console error running '{command}': {ex}");
				return "error: " + ex.Message;
			}
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Extensions
{
	public static class DatabaseHelpers
	{
		public static StatusEffect? GetEffect(string statusName)
		{
			string statusName2 = statusName;
			int stableHashCode = statusName2.GetStableHashCode();
			StatusEffect val = ObjectDB.instance.GetStatusEffect(stableHashCode);
			if ((Object)(object)val == (Object)null)
			{
				val = ((IEnumerable<StatusEffect>)ObjectDB.instance.m_StatusEffects).FirstOrDefault((Func<StatusEffect, bool>)((StatusEffect se) => ((Object)se).name.Equals(statusName2, StringComparison.OrdinalIgnoreCase)));
				if ((Object)(object)val == (Object)null)
				{
					Logger.LogWarning((object)("No effect found for " + statusName2 + "Effects: " + string.Join(", ", ObjectDB.instance.m_StatusEffects.Select((StatusEffect x) => ((Object)x).name))));
				}
			}
			return val;
		}

		public static List<string> GetItems()
		{
			return (from x in ObjectDB.instance.m_items
				orderby x
				select ((Object)x).name).ToList();
		}

		public static List<string> GetStatusEffects()
		{
			return (from x in ObjectDB.instance.m_StatusEffects
				orderby x
				select ((Object)x).name).ToList();
		}

		public static List<string> GetPrefabNames()
		{
			return ZNetScene.instance.GetPrefabNames();
		}

		public static List<string> GetAllPlayerNames()
		{
			return (from x in Player.GetAllPlayers()
				select x.GetPlayerName()).ToList();
		}

		public static string FormatStatusEffects()
		{
			LoggingHelpers.PrintItems(GetStatusEffects(), "StatusEffects");
			return "";
		}

		public static void ListPrefabs()
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				ZLog.Log((object)"ZNetScene not ready yet.");
			}
			else
			{
				LoggingHelpers.PrintItems(GetPrefabNames(), "Prefab");
			}
		}

		public static List<string> GetEnvironmentNames()
		{
			List<string> result = null;
			if ((Object)(object)EnvMan.instance == (Object)null)
			{
				ZLog.Log((object)"ZNetScene not ready yet.");
				return result;
			}
			List<string> list = EnvMan.instance.m_environments.Select((EnvSetup e) => e.m_name).ToList();
			LoggingHelpers.PrintItems(list, "Environment");
			return list;
		}
	}
	public static class LoggingHelpers
	{
		public static void PrintItems(IList<string> items, string name)
		{
			string.Join(", ", items.Select((string x) => "\"" + x + "\""));
			ZLog.Log((object)$"name ({items.Count}): result");
			ZLog.Log((object)("Total " + name + "s: "));
		}
	}
	public static class MoreExtensions
	{
		public static Vector3? GetVector3(this string[] items)
		{
			if (items.Length < 3)
			{
				return null;
			}
			try
			{
				return items.Select(float.Parse).GetVector3();
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static Vector3? GetVector3(this IEnumerable<float> items)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			float[] array = items.ToArray();
			if (array.Length < 3)
			{
				return null;
			}
			try
			{
				return new Vector3(array[0], array[1], array[2]);
			}
			catch (Exception)
			{
				return null;
			}
		}
	}
	public static class PlayerWrapper
	{
		public static Vector3Dto ToFacade(this Vector3 vector3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			return new Vector3Dto(vector3.x, vector3.y, vector3.z, (int?)null, (int?)null);
		}

		public static Quaterion ToFacade(this Quaternion vector3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			return new Quaterion(vector3.x, vector3.y, vector3.z, vector3.w);
		}

		public static Vector2iDto ToFacade(this Vector2i vector3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new Vector2iDto(vector3.x, vector3.y);
		}

		public static Vector3 GetPosition(this Player player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)player).transform.position;
		}

		public static bool InvokeRoutedRpcOnWorld(this PlayerWrapperType player, RpcCommand rpc, params object[] args)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!player.Owner.HasValue)
			{
				return false;
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(player.Owner.Value, rpc.GetRpcCommandName(), args);
			return true;
		}

		public static bool InvokeRoutedRpc(this PlayerWrapperType player, ZDOID target, RpcCommand rpc, params object[] args)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!player.Owner.HasValue)
			{
				return false;
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(player.Owner.Value, target, rpc.GetRpcCommandName(), args);
			return true;
		}

		public static void InvokeRoutedRpcOnSelf(this PlayerWrapperType player, RpcCommand rpc, params object[] args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			player.InvokeRoutedRpc(player.PlayerId, rpc, args);
		}

		public static ZDO GetZDO(this PlayerWrapperType player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ZDOMan.instance.GetZDO(player.PlayerId);
		}

		public static string GetSteamId(this PlayerWrapperType player)
		{
			return player.RPC.GetSocket().GetHostName();
		}

		public static PlayerWrapperType Create(ZNetPeer peer)
		{
			return new PlayerWrapperType(peer);
		}
	}
	public static class PrefabUtils
	{
		public static GameObject? FindPrefab(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return null;
			}
			return ZNetScene.instance.GetPrefab(name);
		}
	}
	public static class RegistrationHelpers
	{
		public static void RegisterAllCommands(Assembly assembly)
		{
			if (ActionManager.Instance == null)
			{
				Logger.LogError("RconProxy not initialized");
				return;
			}
			Logger.LogInfo("Registering rcon commands...");
			Type commandInterfaceType = typeof(IRestAction);
			IEnumerable<Type> enumerable = from t in assembly.GetTypes()
				where t != null
				where !t.IsAbstract && t.IsClass
				where t.GetInterfaces().Contains(commandInterfaceType)
				select t;
			Logger.LogInfo("");
			foreach (Type item in enumerable)
			{
				Logger.LogInfo("[PolyRest] REGISTERING type");
				ActionManager.Instance.RegisterCommand(item);
				Logger.LogInfo("[PolyRest] DONE REGISTERING type");
			}
			ActionManager.Instance.Audit();
			throw new Exception();
		}
	}
	public static class StringUtils
	{
		public static GlobalKeys? GetGlobalKey(this CommandRequestType request, int index)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<GlobalKeys>(CommandRequest.Messages(request)[index], out GlobalKeys result))
			{
				return result;
			}
			return null;
		}

		public static bool IsDedicatedServer()
		{
			bool result = Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsDedicated();
			Logger.LogInfo((object)("[IsDedicated] " + result));
			return result;
		}

		public static string GetRpcCommandName(this RpcCommand command)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (!RpcCommandMap.Names.TryGetValue(command, out var value))
			{
				return "RPC_Unknown";
			}
			return value;
		}

		public static int GetStableHashCode(this string str)
		{
			int num = 5381;
			foreach (char c in str)
			{
				num = (num * 33) ^ c;
			}
			return num;
		}
	}
	public static class UIHelpers
	{
		public static void ShowPopup(MessageType msgType, string message)
		{
			MessageHud.instance.ShowMessage((MessageType)1, message, 0, (Sprite)null, false);
		}
	}
	public static class ZNetPeerExtensions
	{
		public static ZDO? GetZDO(this ZNetPeer peer)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ZDOMan.instance.GetZDO(peer.m_characterID);
		}

		public static string GetSteamId(this ZNetPeer peer)
		{
			return peer.m_rpc.GetSocket().GetHostName();
		}
	}
	public static class WorldHelpers
	{
		public static string GetPlayerInfo()
		{
			string[] value = (from x in Player.GetAllPlayers()
				select x.GetPlayerID() + " - " + x.GetPlayerName()).ToArray();
			return string.Join("\n", value);
		}
	}
	public static class ZdoUtils
	{
		public static string GetPrefabName(this ZDO zdo)
		{
			int prefab = zdo.GetPrefab();
			GameObject prefab2 = ZNetScene.instance.GetPrefab(prefab);
			return ((prefab2 != null) ? ((Object)prefab2).name : null) ?? $"Unknown({prefab})";
		}

		public static ZdoSummary? GetSummary(this ZDO zdo)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			return new ZdoSummary(zdo.GetPrefabName(), zdo.GetPosition().ToFacade(), zdo.GetRotation().ToFacade(), zdo.GetBool(ZDOVars.s_tamed, false), zdo.GetString("tag", ""));
		}
	}
	public static class ZHelpers
	{
		public static PlayerResponse Create(this ZNetPeer player)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			return new PlayerResponse(player.GetSteamId(), player.m_playerName, player.GetRefPos().ToFacade(), ZoneSystem.GetZone(player.GetRefPos()).ToFacade());
		}
	}
	public static class ZPackageExtensions
	{
		public static void WriteObject<T>(this ZPackage pkg, T obj)
		{
			string text = JsonConvert.SerializeObject((object)obj);
			pkg.Write(text);
		}

		public static ZPackage ToZPackage<T>(this T obj)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			string text = JsonConvert.SerializeObject((object)obj);
			ZPackage val = new ZPackage();
			val.Write(text);
			return val;
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Converters
{
	public static class DtoConverters
	{
		public static Type ToLocal(this Type val)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return (Type)val;
		}

		public static Vector3 ToLocal(this Vector3Dto? val)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (val == (Vector3Dto)null)
			{
				return default(Vector3);
			}
			return new Vector3(val.X, val.Y, val.Z);
		}

		public static Quaternion ToQuaternion(this Vector3Dto val)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion(val.X, val.Y, val.Z, 0f);
		}

		public static Vector2i ToLocal(this Vector2iDto val)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2i(val.X, val.Y);
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands
{
	public sealed class CustomCommand : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "command";

		public override string Description => "Execute a custom server command";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			return Response.Pass(ServerConsole.Execute(args.Raw), Method);
		}
	}
	internal class FindPlayer : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "findPlayer";

		public override string Description => "Find a player and show their details. Usage: findPlayer <playername or steamid>";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			//IL_0050: 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)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			string @string = CommandRequest.GetString(args, 0);
			ZNetPeer val = ZNet.instance.GetPeerByPlayerName(@string) ?? ZNet.instance.GetPeerByHostName(@string);
			if (val == null)
			{
				return Fail("Player {user} not found");
			}
			ZDO zDO = val.GetZDO();
			bool flag = zDO == null;
			return Response.Pass<PlayerInfoResponse>(new PlayerInfoResponse(@string, val.GetSteamId(), val.m_playerName, flag, flag ? null : val.GetRefPos().ToFacade(), flag ? null : ZoneSystem.GetZone(val.GetRefPos()).ToFacade(), flag ? null : new float?(zDO.GetFloat(ZDOVars.s_health, 0f)), flag ? null : new float?(zDO.GetFloat(ZDOVars.s_maxHealth, 0f))), Method);
		}
	}
	internal class GetServerStats : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "serverstats";

		public override string Description => "Prints server statistics including player count, FPS, memory usage, and world information.";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			try
			{
				string obj = ZNet.World?.m_name ?? "INVALID WORLD";
				ZNet instance = ZNet.instance;
				int num = ((instance != null) ? instance.GetPeers().Count : (-1));
				float num2 = 1f / Time.deltaTime;
				ZDOMan instance2 = ZDOMan.instance;
				int num3 = ((instance2 != null) ? instance2.NrOfObjects() : (-1));
				EnvMan instance3 = EnvMan.instance;
				int num4;
				if (instance3 == null)
				{
					num4 = -1;
				}
				else
				{
					ZNet instance4 = ZNet.instance;
					num4 = instance3.GetDay((instance4 != null) ? instance4.GetTimeSeconds() : 0.0);
				}
				int num5 = num4;
				int num6 = ToMegabytes(Profiler.GetMonoUsedSizeLong());
				int num7 = ToMegabytes(Profiler.GetMonoHeapSizeLong());
				return Response.Pass<ServerStats>(new ServerStats(obj, num, Math.Round(num2, 1), (long)num6, (long)num7, num5, num3, 0), Method);
			}
			catch (Exception ex)
			{
				Logger.LogError(ex, "Get Server Stats failed");
				return ex.Fail(Method);
			}
		}

		private int ToMegabytes(long bytes)
		{
			return Mathf.FloorToInt((float)bytes / 1048576f);
		}
	}
	public sealed class InfoCommand : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "info";

		public override string Description => "Print system info / memory.";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			return Pass(ServerConsole.Execute("info"));
		}
	}
	internal class InvokeConsoleCommand : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "consoleCommand";

		public override string Description => "Executes a console command on the server.";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			((Terminal)Console.instance).TryRunCommand(args.Command + " " + args.Raw, false, true);
			return Pass("Command '" + args.Command + "' executed.");
		}
	}
	internal class Ping : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "ping";

		public override string Description => "Sends a ping message to all players at the specified coordinates. ";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			string vector = CommandRequest.GetVector3(args, 0);
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ChatMessage", new object[4] { vector, 3, "", "" });
			return Pass("Ping sent to " + vector);
		}
	}
	internal class StopRaid : IRestAction
	{
		public string Method => "stopraid";

		public string Description => "Stop the current raid/event.";

		public PostResponse OnHandle(CommandRequestType args)
		{
			RandEventSystem.instance.ConsoleResetRandomEvent();
			return Response.Pass("Raid/event stopped.", Method);
		}
	}
	internal class SayChat : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "say";

		public override string Description => "Sends a message to the chat as a shout.";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			string raw = args.Raw;
			Vector3 val = default(Vector3);
			if (!ZoneSystem.instance.GetLocationIcon(Game.instance.m_StartLocation, ref val))
			{
				((Vector3)(ref val))..ctor(0f, 30f, 0f);
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ChatMessage", new object[4] { val, 2, "Server:", raw });
			return Pass("Sent to chat - " + raw);
		}
	}
	internal static class ServerConsole
	{
		public static string Execute(string command)
		{
			try
			{
				if ((Object)(object)Console.instance != (Object)null)
				{
					((Terminal)Console.instance).TryRunCommand(command, false, false);
					return "ok: " + command;
				}
				return "dispatched: " + command;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)$"[Rest] console error running '{command}': {ex}");
				return "error: " + ex.Message;
			}
		}
	}
	internal class ServerTimeCommand : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "time";

		public override string Description => "Get the current server time and day.";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			double timeSeconds = ZNet.instance.GetTimeSeconds();
			return Response.Pass<TimeResponse>(new TimeResponse(EnvMan.instance.GetDay(), timeSeconds), Method);
		}
	}
	public class ShoutAction : IRestAction
	{
		public Func<CommandRequestType, PostResponse> OnRequest { get; init; }

		public string Method => "shout";

		public string Description => "Shouts to everyone";

		public PostResponse OnHandle(CommandRequestType request)
		{
			return OnRequest(request);
		}
	}
	internal class ShowMessage : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "showMessage";

		public override string Description => "Displays a message in the center of the screen for all players. Usage: showMessage <message>";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ShowMessage", new object[2] { 2, args.Raw });
			return Pass("Message sent - " + args.Raw);
		}
	}
	internal class SpawnNPC : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "spawnnpc";

		public override string Description => "Creates the specified number of objects at the given position. ";

		protected override PostResponse OnHandleInternal(CommandRequestType request)
		{
			SpawnArgs val = CommandRequest.Get<SpawnArgs>(request);
			if (val == (SpawnArgs)null)
			{
				return Fail("result was null when received raw: " + request.Raw);
			}
			if (string.IsNullOrEmpty(val.PrefabName))
			{
				return Fail("PrefanName was null or empty");
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(val.PrefabName);
			if ((Object)(object)prefab == (Object)null)
			{
				return Fail("Prefab " + val.PrefabName + " not found");
			}
			List<ZDO> zdos = SpawnPrefabs(prefab, val);
			return BuildResultMessage(zdos);
		}

		private static List<ZDO> SpawnPrefabs(GameObject prefab, SpawnArgs args)
		{
			//IL_001b: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			List<ZDO> list = new List<ZDO>(args.Count);
			try
			{
				for (int i = 0; i < args.Count; i++)
				{
					ZNetView.StartGhostInit();
					Vector3 spawnPosition = GetSpawnPosition(args.Position.ToLocal(), args.Radius);
					Quaternion val = args.Rotation.ToQuaternion();
					GameObject obj = Object.Instantiate<GameObject>(prefab, spawnPosition, val);
					ApplySpawnProperties(obj, args);
					ZDO zDO = obj.GetComponent<ZNetView>().GetZDO();
					list.Add(zDO);
					ZNetView.FinishGhostInit();
					Object.Destroy((Object)(object)obj);
				}
			}
			catch (Exception ex)
			{
				Logger.LogError(ex, "");
			}
			return list;
		}

		private static Vector3 GetSpawnPosition(Vector3 center, float? radius)
		{
			//IL_0017: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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)
			if (!radius.HasValue || radius.Value <= 0f)
			{
				return center;
			}
			float valueOrDefault = radius.GetValueOrDefault();
			Vector3 val = Random.onUnitSphere * valueOrDefault;
			val.y = 0f;
			return center + val;
		}

		private static void ApplySpawnProperties(GameObject obj, SpawnArgs args)
		{
			Character val = default(Character);
			if (obj.TryGetComponent<Character>(ref val))
			{
				val.SetLevel(args.Level);
			}
			ItemDrop val2 = default(ItemDrop);
			if (obj.TryGetComponent<ItemDrop>(ref val2))
			{
				val2.SetQuality(args.Level);
			}
			ZDO zDO = obj.GetComponent<ZNetView>().GetZDO();
			if (args.Tamed)
			{
				zDO.Set(ZDOVars.s_tamed, true);
			}
		}

		private PostResponse BuildResultMessage(IEnumerable<ZDO> zdos)
		{
			List<ZdoSummary> list = (from x in zdos
				select x.GetSummary() into x
				where x != (ZdoSummary)null
				select x).ToList();
			PostResponse obj = list.Pass(Method);
			obj.Message = $"Count: {list.Count()}";
			return obj;
		}
	}
	internal class TeleportPlayer : PlayerRestRequest<TeleportRequest>
	{
		public override string Command => "RPC_TeleportTo";

		public override string Method => "teleport";

		public override string Description => "Teleports the player to a specified position.";

		protected override PostResponse OnHandle(PlayerWrapperType player, TeleportRequest args)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			InvokeRoutedAtTarget(player, args.Position.ToLocal(), Quaternion.identity, true);
			return Response.Pass($"Player {player.Name} teleported to {args.Position.ToLocal()}", Method);
		}
	}
	internal class WorldSave : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "save";

		public override string Description => "Save the current world state.";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			ZNet.instance.Save(false, false, false);
			return Response.Pass("World save started", Method);
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Whisper
{
	public static class Metadata
	{
		public const string TestString = "whisper 76561197962914477 Dan Howdy ho";

		public const string RCPCall = "Whisper";

		public const string Command = "whisper";

		public const string Description = "Whisper a player.";

		public const string Usage = "Usage: whisper <player> <name> <message> ";

		public const int MinimumParameters = 3;
	}
	internal class Whisper : PlayerRestRequest<MessageRequest>
	{
		public override string Command => "Whisper";

		public override string Method => "whisper";

		public override string Description => "Whisper a player.";

		private PostResponse ProcessCommand(PlayerWrapperType player, MessageRequest args)
		{
			InvokeJsonRouted<MessageRequest>(player, args);
			return Response.Pass("Applied Whisper to " + player.Name, Method);
		}

		protected override PostResponse OnHandle(PlayerWrapperType player, MessageRequest args)
		{
			return ProcessCommand(player, args);
		}
	}
	[HarmonyPatch(typeof(Game))]
	public static class WhisperRpc
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Register()
		{
			ZRoutedRpc.instance.Register<string>("Whisper", (Action<long, string>)Whisper);
		}

		private static void Whisper(long sender, string args)
		{
			MessageRequest obj = JsonHelpers.FromJson<MessageRequest>(args);
			string message = obj.Message;
			string senderName = obj.SenderName;
			Logger.LogInfo("Received Whisper, name: " + senderName + " message: " + message);
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)GameCamera.instance == (Object)null)
			{
				return;
			}
			try
			{
				((Terminal)Chat.instance).AddString(senderName, message, (Type)1, false);
				UIHelpers.ShowPopup((MessageType)1, senderName + ": " + message);
				Logger.LogInfo("Whisper shake triggered with amount ");
			}
			catch (Exception ex)
			{
				Logger.LogInfo("Screen shake failed. " + ex.Message);
			}
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.SetWeather
{
	public static class Metadata
	{
		public const string RCPCall = "SetWeather";

		public const string Command = "setweather";

		public const string Description = "set weather a   player.";
	}
	internal class SetWeather : PlayerRestRequest<PlayerRequest>
	{
		public override string Command => "SetWeather";

		public override string Method => "setweather";

		public override string Description => "set weather a   player.";

		protected override PostResponse OnHandle(PlayerWrapperType player, PlayerRequest args)
		{
			InvokeJsonRouted<PlayerRequest>(player, args);
			return Response.Pass("Weather set '" + args.TargetPlayer + "'", Method);
		}
	}
	[HarmonyPatch(typeof(Game))]
	public static class SetWeatherRPC
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void RegisterRpc()
		{
			Logger.LogInfo("Registered RCPCall");
			ZRoutedRpc.instance.Register("SetWeather", (Action<long>)SmiteAction);
		}

		private static void SmiteAction(long _)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo("Received request to SetWeather");
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null)
			{
				Logger.LogWarning("No ZNetScene available yet!");
				return;
			}
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			string[] names = new string[3] { "lightningAOE", "vfx_lightning_hit", "fx_thunder" };
			var (flag, text, text2) = TrySpawnFirstNetworked(instance, position, Quaternion.identity, names);
			if (flag)
			{
				Logger.LogInfo("Smite spawned prefab " + text);
			}
			else
			{
				Logger.LogWarning("Smite failed: " + text2);
			}
		}

		private static (bool ok, string used, string reason) TrySpawnFirstNetworked(ZNetScene zns, Vector3 pos, Quaternion rot, string[] names)
		{
			//IL_002a: 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)
			foreach (string text in names)
			{
				GameObject prefab = zns.GetPrefab(text);
				if (!((Object)(object)prefab == (Object)null) && !((Object)(object)prefab.GetComponent<ZNetView>() == (Object)null))
				{
					GameObject val = Object.Instantiate<GameObject>(prefab, pos, rot);
					if ((Object)(object)val.GetComponent<TimedDestruction>() == (Object)null)
					{
						Object.Destroy((Object)(object)val, 5f);
					}
					return (true, text, "");
				}
			}
			return (false, "", "no networked prefabs among: " + string.Join(", ", names));
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Raids
{
	internal class StartRaidCommand : RestRequest<RaidRequest>
	{
		public override string Method => "startraid";

		public override string Description => "Start a raid at player location.";

		public override PostResponse OnHandle(RaidRequest args)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!RandEventSystem.instance.HaveEvent(args.Name))
			{
				return Response.Fail("No such event: " + args.Name);
			}
			Vector3 val = args.Position.ToLocal();
			RandEventSystem.instance.SetRandomEventByName(args.Name, val);
			return args.Pass<RaidRequest>("Raid started: " + args.Name + " " + ((val != Vector3.zero) ? "at player" : "globally"));
		}
	}
	internal class StartRandomRaid : IRestAction
	{
		public string Method => "randomraid";

		public string Description => "Start a random raid from eligible events.";

		public PostResponse OnHandle(CommandRequestType args)
		{
			RandEventSystem.instance.ConsoleStartRandomEvent();
			return Response.Pass("Random raid triggered.", Method);
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Players
{
	internal class Damage : PlayerRestRequest<PlayerAmountRequest>
	{
		public override string Command => "RPC_Damage";

		public override string Method => "damage";

		public override string Description => "Damage a player by a specified amount.";

		protected override PostResponse OnHandle(PlayerWrapperType player, PlayerAmountRequest args)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			ZNetPeer peer = player.Peer;
			HitData val = new HitData
			{
				m_blockable = false,
				m_dodgeable = false,
				m_ignorePVP = true,
				m_hitType = (HitType)0,
				m_damage = new DamageTypes
				{
					m_damage = args.Amount
				}
			};
			InvokeRoutedAtTarget(player, val);
			return Response.Pass($"{peer.m_playerName} damaged to {val.m_damage.m_damage}hp", Method);
		}
	}
	internal class SpawnItem : PlayerRestRequest<GiveRequest>
	{
		public override string Command { get; }

		public override string Method => "spawnobject";

		public override string Description => "Spawns an item on the player.";

		protected override PostResponse OnHandle(PlayerWrapperType player, GiveRequest args)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			int num = 0;
			try
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(args.ItemName);
				if ((Object)(object)itemPrefab == (Object)null)
				{
					return Response.Fail("Cannot find prefab " + args.ItemName);
				}
				if (args.Count > Constants.GiveItem_MaxCount)
				{
					return Response.Fail($"Count Max: {Constants.GiveItem_MaxCount}  Request:{args.Count}");
				}
				ZNetView.StartGhostInit();
				ZNetPeer peer = player.Peer;
				ItemData obj = itemPrefab.GetComponent<ItemDrop>().m_itemData.Clone();
				num = 1;
				obj.m_dropPrefab = itemPrefab;
				obj.m_quality = args.Quality;
				ItemDrop obj2 = ItemDrop.DropItem(obj, args.Count, peer.GetRefPos(), Quaternion.identity);
				num = 2;
				ZNetView.FinishGhostInit();
				num = 3;
				Object.Destroy((Object)(object)((Component)obj2).gameObject);
				num = 4;
				return Response.Pass<GiveResponse>(new GiveResponse(args.ItemName, args.Count, peer.m_playerName, peer.GetRefPos().ToFacade()), Method);
			}
			catch (Exception ex)
			{
				return ex.Fail($"GiveItem: OnHandle failed? {num}");
			}
		}
	}
	internal class Heal : PlayerRestRequest<PlayerAmountRequest>
	{
		public override string Command => "RPC_Heal";

		public override string Method => "heal";

		public override string Description => "Heals the player's to a specified value. Usage: heal <steamid> <value>";

		protected override PostResponse OnHandle(PlayerWrapperType player, PlayerAmountRequest args)
		{
			InvokeRoutedAtTarget(player, args.Amount, true);
			return Response.Pass($"{player.Peer.m_playerName} healed to {args.Amount} hp", Method);
		}
	}
	internal class Kick : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "kick";

		public override string Description => "Kicks a player from the server. Usage: kick <playername or steamid>";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			string @string = CommandRequest.GetString(args, 0);
			ZNet.instance.Kick(@string);
			return Pass("Kicked " + @string);
		}
	}
	internal class ShowPlayers : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "players";

		public override string Description => "Show all online players with their positions and zones";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			return (from x in ZNet.instance.GetPeers()
				select x.Create()).Pass(Method);
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Players.Smite
{
	public static class Metadata
	{
		public const string RCPCall = "Smite";

		public const string Command = "smite";

		public const string Description = "smite a   player.";

		public const string Usage = "Usage: smite <player> <powerName> ";

		public const int MinimumParameters = 2;
	}
	internal class Smite : PlayerRestRequest<PlayerRequest>
	{
		public override string Command { get; }

		public override string Method => "smite";

		public override string Description => "smite a   player.";

		protected override PostResponse OnHandle(PlayerWrapperType player, PlayerRequest args)
		{
			InvokeJsonRouted<PlayerRequest>(player, args);
			return Response.Pass("Smote '" + player.Name + "'", Method);
		}
	}
	[HarmonyPatch(typeof(Game))]
	public static class SmiteRPC
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void RegisterRpc()
		{
			Logger.LogInfo("Registered SmiteRPC");
			ZRoutedRpc.instance.Register("Smite", (Action<long>)SmiteAction);
		}

		private static void SmiteAction(long _)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo("Received request to Smite");
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null)
			{
				Logger.LogWarning("No ZNetScene available yet!");
				return;
			}
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			string[] names = new string[3] { "lightningAOE", "vfx_lightning_hit", "fx_thunder" };
			var (flag, text, text2) = TrySpawnFirstNetworked(instance, position, Quaternion.identity, names);
			if (flag)
			{
				Logger.LogInfo("Smite spawned prefab " + text);
			}
			else
			{
				Logger.LogWarning("Smite failed: " + text2);
			}
		}

		private static (bool ok, string used, string reason) TrySpawnFirstNetworked(ZNetScene zns, Vector3 pos, Quaternion rot, string[] names)
		{
			//IL_002a: 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)
			foreach (string text in names)
			{
				GameObject prefab = zns.GetPrefab(text);
				if (!((Object)(object)prefab == (Object)null) && !((Object)(object)prefab.GetComponent<ZNetView>() == (Object)null))
				{
					GameObject val = Object.Instantiate<GameObject>(prefab, pos, rot);
					if ((Object)(object)val.GetComponent<TimedDestruction>() == (Object)null)
					{
						Object.Destroy((Object)(object)val, 5f);
					}
					return (true, text, "");
				}
			}
			return (false, "", "no networked prefabs among: " + string.Join(", ", names));
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Players.Shake
{
	public static class Metadata
	{
		public const string TestString = "shake 76561197962914477 5";

		public const string RCPCall = "Shake";

		public const string Command = "shake";

		public const string Description = "Shake a player.";

		public const string Usage = "Usage: shake <player> <amount> ";

		public const int MinimumParameters = 2;
	}
	internal class Shake : PlayerRestRequest<ShakeRequest>
	{
		public override string Command => "Shake";

		public override string Method => "shake";

		public override string Description => "Shake a player.";

		protected override PostResponse OnHandle(PlayerWrapperType player, ShakeRequest args)
		{
			InvokeJsonRouted<ShakeRequest>(player, args);
			return Response.Pass($"Applied shake {args.Intensity} to {player.Name}", Method);
		}
	}
	[HarmonyPatch(typeof(Game))]
	public static class ShakeRpc
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Register()
		{
			ZRoutedRpc.instance.Register<string>("Shake", (Action<long, string>)OnCalled);
		}

		private static void OnCalled(long sender, string args)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			ShakeRequest val = JsonHelpers.FromJson<ShakeRequest>(args);
			Logger.LogInfo($"Received Screen Shake, amount: {val}");
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)GameCamera.instance == (Object)null)
			{
				return;
			}
			try
			{
				float num = 10f;
				Vector3 position = Player.m_localPlayer.GetPosition();
				GameCamera.instance.AddShake(position, num, val.Intensity, false);
				Logger.LogInfo($"Screen shake triggered with amount {val}");
			}
			catch (Exception ex)
			{
				Logger.LogInfo("Screen shake failed. " + ex.Message);
			}
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Players.AddNoise
{
	internal class AddNoise : PlayerRestRequest<AddNoiseRequest>
	{
		public override string Command => "AddNoise";

		public override string Method => "addnoise";

		public override string Description => "Plays a noise in the vicinity of the player.";

		protected override PostResponse OnHandle(PlayerWrapperType player, AddNoiseRequest args)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo($"[Server] Received request to play audio at {player.Name} - {args.Noise} - {player.RefPosition}");
			if (args.Position.X == 0f && args.Position.Y == 0f && args.Position.Z == 0f)
			{
				AddNoiseRequest obj = args.<Clone>$();
				obj.set_Position(player.RefPosition.ToFacade());
				args = obj;
			}
			InvokeJsonRouted<AddNoiseRequest>(player, args);
			return Response.Pass("Played noise '" + args.Noise + "' at " + player.Name, Method);
		}
	}
	[HarmonyPatch(typeof(Game))]
	public static class AddNoiseBootStrap
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Register()
		{
			Logger.LogInfo("Registered AddNoiseBootStrap");
			ZRoutedRpc.instance.Register<string>("AddNoise", (Action<long, string>)PlayNoise);
		}

		private static void PlayNoise(long sender, string package)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			AddNoiseRequest val = JsonHelpers.FromJson<AddNoiseRequest>(package);
			Logger.LogInfo($"[Player] Received request to play audio at {val.TargetPlayer} - {val.Noise} - {val.Position}");
			string noise = val.Noise;
			Vector3 position = Player.m_localPlayer.GetPosition();
			if (noise.Contains("https:"))
			{
				Logger.LogInfo("Received URL request to playNoise " + noise);
				try
				{
					AudioHelper audioHelper = new AudioHelper();
					((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(audioHelper.PlayAudioFromUrl(noise, position));
					return;
				}
				catch (Exception ex)
				{
					Logger.LogError(ex.Message);
					return;
				}
			}
			Logger.LogInfo("Received URL request to playNoise " + noise);
			GameObject prefab = PrefabManager.Instance.GetPrefab(noise);
			if ((Object)(object)prefab != (Object)null)
			{
				Object.Instantiate<GameObject>(prefab, position, Quaternion.identity);
				Logger.LogWarning($"Played {noise} at {position}");
			}
			else
			{
				Logger.LogWarning("Effect prefab " + noise + " not found!");
			}
		}
	}
	public static class Metadata
	{
		public const string TestString = "addnoise 76561197962914477 https://cdn.polyhydragames.com/audio/no.mp3 10 10 1";

		public const string RCPCall = "AddNoise";

		public const string Command = "addnoise";

		public const string Description = "Plays a noise in the vicinity of the player.";

		public const string Usage = "Usage: addnoise <player> <noiseName> <position>";

		public const int MinimumParameters = 2;
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Players.AddEffect
{
	internal class AddEffect : PlayerRestRequest<AddEffectRequest>
	{
		public override string Command => "ApplyStatusEffect";

		public override string Method => "addeffect";

		public override string Description => "Adds a status to the player. Usage: addstatus <player> <statusName>";

		protected override PostResponse OnHandle(PlayerWrapperType player, AddEffectRequest args)
		{
			if (string.IsNullOrEmpty(args.EffectName))
			{
				Response.Fail(string.Join(", ", DatabaseHelpers.GetStatusEffects()), Method);
			}
			InvokeJsonRouted<AddEffectRequest>(player, args);
			return Response.Pass("Applied status '" + player.Name + "' to " + player.Name, Method);
		}
	}
	[HarmonyPatch(typeof(Game))]
	public static class AddEffectBootStrap
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void Register()
		{
			ZRoutedRpc.instance.Register<string>("ApplyStatusEffect", (Action<long, string>)OnApplyStatusEffect);
		}

		private static void OnApplyStatusEffect(long sender, string args)
		{
			AddEffectRequest val = JsonHelpers.FromJson<AddEffectRequest>(args);
			Logger.LogInfo("Client received request to apply " + val.EffectName);
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				StatusEffect effect = DatabaseHelpers.GetEffect(val.EffectName);
				if ((Object)(object)effect != (Object)null)
				{
					((Character)localPlayer).GetSEMan().AddStatusEffect(effect, true, 0, 0f);
					((Terminal)Chat.instance).AddString("[Odin] You are blessed with " + effect.m_name + "!");
				}
				else
				{
					Logger.LogWarning("StatusEffect " + val.EffectName + " not found in ObjectDB");
				}
			}
		}
	}
	public static class Metadata
	{
		public const string Test = "addeffect 76561197962914477 SE_Rested";

		public const string RCPCall = "ApplyStatusEffect";

		public const string Command = "addeffect";

		public const string Description = "Adds a status to the player. Usage: addstatus <player> <statusName>";

		public const string Usage = "Usage: addstatus <player> <statusName>";

		public const int MinimumParameters = 2;
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.GlobalKeys
{
	internal class AddGlobalKeyCommand : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "addglobalkey";

		public override string Description => "Adds a global key to the server. ";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			//IL_0014: 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)
			if (Enum.TryParse<GlobalKeys>(args.Raw, out GlobalKeys result))
			{
				ZoneSystem.instance.SetGlobalKey(result);
				return Response.Pass($"Added global key: {result}", Method);
			}
			return Response.Fail("Unable to parse " + args.Raw);
		}
	}
	internal class GetGlobalKeysCommand : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "globalkeys";

		public override string Description => "Gets all global keys and their values.";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			return ZoneSystem.instance.m_globalKeysValues.Select((KeyValuePair<string, string> x) => Converters.CreateGlobalKey(x)).Pass(Method);
		}
	}
	internal class RemoveGlobalKeyCommand : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "removeglobalkey";

		public override string Description => "Removes a global key from the server. Usage: removeGlobalKey <key>";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			GlobalKeys? globalKey = args.GetGlobalKey(0);
			if (!globalKey.HasValue)
			{
				return Response.Fail("No key found with value " + CommandRequest.GetString(args, 0));
			}
			ZoneSystem.instance.RemoveGlobalKey(globalKey.Value);
			return Response.Pass($"Global key '{globalKey}' removed successfully.", Method);
		}
	}
	public class ResetKeysAction : IRestAction
	{
		public Func<CommandRequestType, PostResponse> OnRequest { get; init; }

		public string Method => "resetglobalkeys";

		public string Description => "Delete old boss kill data";

		public PostResponse OnHandle(CommandRequestType request)
		{
			ZoneSystem.instance.ResetGlobalKeys();
			return Response.Pass("Global keys reset via REST", Method);
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Events
{
	internal class GetEvent : IRestAction
	{
		public string Method => "getevent";

		public string Description => "Get current active/random raid event.";

		public PostResponse OnHandle(CommandRequestType args)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
			RandomEvent currentRandomEvent = RandEventSystem.instance.GetCurrentRandomEvent();
			if (activeEvent == null && currentRandomEvent == null)
			{
				return args.Fail("No active raid.");
			}
			return Response.Pass<EventResponse>(new EventResponse(activeEvent?.m_name ?? "none", currentRandomEvent?.m_name ?? "none"), "getevent");
		}
	}
	internal class ListEvents : IRestAction
	{
		public string Method => "listevents";

		public string Description => "List all available random events.";

		public PostResponse OnHandle(CommandRequestType args)
		{
			return ((IEnumerable<RandomEvent>)RandEventSystem.instance.m_events).Select((Func<RandomEvent, EnabledState>)((RandomEvent x) => new EnabledState(x.m_name, x.m_enabled))).Pass(Method);
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Communication
{
	internal class Impersonate : IRestAction
	{
		private static readonly Dictionary<string, UserInfo> ImpersonatedUsers = new Dictionary<string, UserInfo>();

		private static ulong NextId = 1uL;

		public string Method => "impersonate";

		public string Description => "Sends a message to the chat as a shout. Usage: impersonate <name> <message>";

		public UserInfo CreateUser(string name)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			return new UserInfo
			{
				Name = name,
				UserId = new PlatformUserID("Bot", NextId++, false)
			};
		}

		private UserInfo GetUserInfo(string name)
		{
			if (ImpersonatedUsers.ContainsKey(name))
			{
				return ImpersonatedUsers[name];
			}
			return CreateUser(name);
		}

		public PostResponse OnHandle(CommandRequestType args)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			MessageRequest val = JsonHelpers.FromJson<MessageRequest>(args.Raw);
			try
			{
				Vector3 val2 = default(Vector3);
				if (!ZoneSystem.instance.GetLocationIcon(Game.instance.m_StartLocation, ref val2))
				{
					((Vector3)(ref val2))..ctor(0f, 30f, 0f);
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "Whisper", new object[4]
				{
					val2,
					2,
					GetUserInfo(val.SenderName),
					val.Message
				});
				return args.Pass("Impersonated: " + val.SenderName + " - " + val.Message);
			}
			catch (Exception ex)
			{
				return ex.Fail(" FAILED  !!! Impersonated: " + val.SenderName + " - " + val.Message);
			}
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Bans
{
	public sealed class Ban : PlayerRestRequest<PlayerRequest>
	{
		public override string Command { get; }

		public override string Method => "ban";

		public override string Description => "Ban a player by name/host/id.";

		protected override PostResponse OnHandle(PlayerWrapperType player, PlayerRequest args)
		{
			string targetPlayer = args.TargetPlayer;
			ZNet.instance.Ban(targetPlayer);
			return Response.Pass("Banned " + targetPlayer, Method);
		}
	}
	internal class PrintBanlist : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "banlist";

		public override string Description => "Prints the list of banned players";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			return ZNet.instance.Banned.Pass(Method);
		}
	}
	internal class Unban : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "unban";

		public override string Description => "Unban a user from the server. Usage: unban <playername or steamid>";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			string @string = CommandRequest.GetString(args, 0);
			ZNet.instance.Unban(@string);
			return Response.Pass(@string + " unbanned", Method);
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Admins
{
	internal class AddAdmin : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "addadmin";

		public override string Description => "Adds a player to the admin list. Usage: addAdmin <steamId>";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			ZNet.instance.GetAdminList().Add(args.Raw);
			return Pass(args.Raw + " is admin now");
		}
	}
	internal class GetAdmins : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "adminlist";

		public override string Description => "Prints the list of admins on the server.";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			return ZNet.instance.GetAdminList().Pass(Method);
		}
	}
	internal class RemoveAdmin : PolyhydraGames.Valheim.RestServer.Commands.Abstract.RestRequest
	{
		public override string Method => "removeadmin";

		public override string Description => "Removes a player from the admin list.";

		protected override PostResponse OnHandleInternal(CommandRequestType args)
		{
			string @string = CommandRequest.GetString(args, 0);
			ZNet.instance.GetAdminList().Remove(@string);
			return Response.Pass(@string + " removed from admins", Method);
		}
	}
}
namespace PolyhydraGames.Valheim.RestServer.Commands.Abstract
{
	public abstract class PlayerRestRequest<T> : IRestAction where T : IPlayerRequest
	{
		public static readonly UserInfo ServerUserInfo = new UserInfo
		{
			Name = string.Empty,
			UserId = new PlatformUserID("Bot", 0uL, false)
		};

		public abstract string Command { get; }

		public abstract string Method { get; }

		public abstract string Description { get; }

		public PostResponse OnHandle(CommandRequestType args)
		{
			T val = CommandRequest.Get<T>(args);
			ZNetPeer peer = GetPeer(val);
			return OnHandle(PlayerWrapper.Create(peer), val);
		}

		private ZNetPeer? GetPeer(T request)
		{
			string targetPlayer = ((IPlayerRequest)request).TargetPlayer;
			ZNetPeer val = ZNet.instance.GetPeerByHostName(targetPlayer) ?? ZNet.instance.GetPeerByPlayerName(targetPlayer);
			if (val == null)
			{
				return null;
			}
			return val;
		}

		protected abstract PostResponse OnHandle(PlayerWrapperType player, T args);

		protected void InvokeJsonRouted<T>(PlayerWrapperType player, T request)
		{
			string text = JsonHelpers.ToJson<T>(request);
			ZRoutedRpc.instance.InvokeRoutedRPC(player.ZDOID, Command, new object[1] { text });
		}

		protected void InvokeRouted(PlayerWrapperType player, params object[] args)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(player.ZDOID, Command, args);
		}

		protected bool InvokeRoutedAtTarget(PlayerWrapperType player, params object[] args)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (player.GetZDO == null)
			{
				return false;
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(player.Owner.Value, player.ZdoUid.Value, Command, args);
			return true;
		}

		protected void InvokeZPackageRouted(PlayerWrapperType player, HitData hitData)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			hitData.Serialize(ref val);
			ZRoutedRpc.instance.InvokeRoutedRPC(player.ZDOID, Command, new object[1] { val });
		}
	}
	public abstract class RestRequest : IRestAction
	{
		public abstract string Method { get; }

		public abstract string Description { get; }

		public PostResponse OnHandle(CommandRequestType request)
		{
			Logger.LogInfo(((object)request).ToString());
			return OnHandleInternal(request);
		}

		protected abstract PostResponse OnHandleInternal(CommandRequestType args);

		protected PostResponse Pass(string value)
		{
			return Response.Pass(value, Method);
		}

		protected PostResponse Fail(string error)
		{
			return Response.Fail(error);
		}
	}
	public abstract class RestRequest<T> : IRestAction
	{
		public abstract string Method { get; }

		public abstract string Description { get; }

		public abstract PostResponse OnHandle(T request);

		public PostResponse OnHandle(CommandRequestType request)
		{
			Logger.LogInfo("Method: " + request.Command + " Received: " + request.Raw);
			T request2 = CommandRequest.Get<T>(request);
			return OnHandle(request2);
		}
	}
}