using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using PolyhydraGames.Valheim.Plugin.Commands;
using PolyhydraGames.Valheim.Plugin.Extensions;
using PolyhydraGames.Valheim.Plugin.Models;
using Splatform;
using UnityEngine;
using UnityEngine.Networking;
using ValheimRcon;
using ValheimRcon.Commands;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("PolyhydraGames.Valheim.Plugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+329e48f7eebbe7e69b8df0f0bcb4fcad6b6cbfe7")]
[assembly: AssemblyProduct("PolyhydraGames.Valheim.Plugin")]
[assembly: AssemblyTitle("PolyhydraGames.Valheim.Plugin")]
[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;
		}
	}
	public class IsExternalInit
	{
	}
}
namespace PolyhydraGames.Valheim.Plugin
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.polyhydragames.rcon", "Polyhydra Games Mods", "1.0.0")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony _harmony = new Harmony("com.polyhydragames.rcon");

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

		public const string Name = "Polyhydra Games Mods";

		public const string Version = "1.0.0";

		private void Awake()
		{
			_harmony.PatchAll();
			try
			{
				RconCommandsUtil.RegisterAllCommands(Assembly.GetExecutingAssembly());
				Logger.LogInfo((object)"[PolyValheimRcon] Loaded");
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("[PolyValheimRcon] Loading failed, hopefully this isn't the server!\n" + ex.Message));
			}
		}
	}
}
namespace PolyhydraGames.Valheim.Plugin.Whisper
{
	[HarmonyPatch(typeof(Game))]
	public static class WhisperRpc
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Register()
		{
			Logger.LogInfo((object)"Registered ShakeRpc");
			ZRoutedRpc.instance.Register<string, string>("Whisper", (Action<long, string, string>)Whisper);
		}

		private static void Whisper(long sender, string name, string message)
		{
			Logger.LogInfo((object)("Received Whisper, name: " + name + " message: " + message));
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)GameCamera.instance == (Object)null)
			{
				return;
			}
			try
			{
				((Terminal)Chat.instance).AddString(name, message, (Type)1, false);
				Helpers.ShowPopup((MessageType)1, name + ": " + message);
				Logger.LogInfo((object)"Whisper shake triggered with amount ");
			}
			catch (Exception ex)
			{
				Logger.LogInfo((object)("Screen shake failed. " + ex.Message));
			}
		}
	}
	internal class Whisper : PolyRconCommand
	{
		public override string Command => "whisper";

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

		public override string Method => "Whisper";

		private string ProcessCommand(PlayerWrapperType player, CommandArgs args)
		{
			string @string = args.GetString(1);
			string remainingString = args.GetRemainingString(2);
			InvokeRouted(player, @string, remainingString);
			return "Applied Whisper to " + player.Name;
		}

		protected override string OnHandle(PlayerWrapperType player, CommandArgs args)
		{
			return (args.Arguments.Count < 3) ? "Usage: whisper <player> <name> <message> " : ProcessCommand(player, args);
		}
	}
	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;
	}
}
namespace PolyhydraGames.Valheim.Plugin.Smite
{
	[HarmonyPatch(typeof(Game))]
	public static class SmiteRPC
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void RegisterRpc()
		{
			Logger.LogInfo((object)"Registered SmiteRPC");
			ZRoutedRpc.instance.Register("Smite", (Action<long>)SmiteAction);
		}

		private static void SmiteAction(long _)
		{
			//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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo((object)"Received request to Smite");
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null)
			{
				Logger.LogWarning((object)"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((object)("Smite spawned prefab " + text));
			}
			else
			{
				Logger.LogWarning((object)("Smite failed: " + text2));
			}
		}

		private static (bool ok, string used, string reason) TrySpawnFirstNetworked(ZNetScene zns, Vector3 pos, Quaternion rot, string[] names)
		{
			//IL_003d: 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)
			foreach (string text in names)
			{
				GameObject prefab = zns.GetPrefab(text);
				if ((Object)(object)prefab == (Object)null)
				{
					continue;
				}
				ZNetView component = prefab.GetComponent<ZNetView>();
				if (!((Object)(object)component == (Object)null))
				{
					GameObject val = Object.Instantiate<GameObject>(prefab, pos, rot);
					TimedDestruction component2 = val.GetComponent<TimedDestruction>();
					if ((Object)(object)component2 == (Object)null)
					{
						Object.Destroy((Object)(object)val, 5f);
					}
					return (true, text, "");
				}
			}
			return (false, "", "no networked prefabs among: " + string.Join(", ", names));
		}
	}
	internal class Smite : PolyRconCommand
	{
		public override string Command => "smite";

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

		public override string Method => "Smite";

		protected override string OnHandle(PlayerWrapperType player, CommandArgs args)
		{
			if (args.Arguments.Count < 2)
			{
				return "Usage: smite <player> <powerName> ";
			}
			string @string = args.GetString(1);
			InvokeRouted(player, @string);
			return "Smote '" + @string + "'";
		}
	}
	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;
	}
}
namespace PolyhydraGames.Valheim.Plugin.Shake
{
	[HarmonyPatch(typeof(Game))]
	public static class ShakeRpc
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Register()
		{
			Logger.LogInfo((object)"Registered ShakeRpc");
			ZRoutedRpc.instance.Register<string>("Shake", (Action<long, string>)Shake);
		}

		private static void Shake(long sender, string shake)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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)
			Logger.LogInfo((object)("Received Screen Shake, amount: " + shake));
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)GameCamera.instance == (Object)null)
			{
				return;
			}
			try
			{
				float num = 10f;
				float num2 = float.Parse(shake);
				Vector3 position = Player.m_localPlayer.GetPosition();
				GameCamera.instance.AddShake(position, num, num2, false);
				Logger.LogInfo((object)$"Screen shake triggered with amount {num2}");
			}
			catch (Exception ex)
			{
				Logger.LogInfo((object)("Screen shake failed. " + ex.Message));
			}
		}
	}
	internal class Shake : PolyRconCommand
	{
		public override string Command => "shake";

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

		public override string Method => "Shake";

		private string ProcessCommand(PlayerWrapperType player, CommandArgs args)
		{
			string @string = args.GetString(1);
			InvokeRouted(player, @string);
			return "Applied shake " + @string + " to " + player.Name;
		}

		protected override string OnHandle(PlayerWrapperType player, CommandArgs args)
		{
			return (args.Arguments.Count < 2) ? "Usage: shake <player> <amount> " : ProcessCommand(player, args);
		}
	}
	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;
	}
}
namespace PolyhydraGames.Valheim.Plugin.Models
{
	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;

			public AudioHelper <>4__this;

			private AudioType <audioType>5__1;

			private UnityWebRequest <www>5__2;

			private AudioClip <clip>5__3;

			private GameObject <audioObject>5__4;

			private AudioSource <audioSource>5__5;

			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;
				<clip>5__3 = null;
				<audioObject>5__4 = null;
				<audioSource>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Invalid comparison between Unknown and I4
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Expected O, but got Unknown
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<audioType>5__1 = (AudioType)(url.Contains(".mp3") ? 13 : 20);
						<www>5__2 = UnityWebRequestMultimedia.GetAudioClip(url, <audioType>5__1);
						<>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
						{
							<clip>5__3 = DownloadHandlerAudioClip.GetContent(<www>5__2);
							<audioObject>5__4 = new GameObject("TempAudio");
							<audioObject>5__4.transform.position = position;
							<audioSource>5__5 = <audioObject>5__4.AddComponent<AudioSource>();
							<audioSource>5__5.clip = <clip>5__3;
							<audioSource>5__5.spatialBlend = 1f;
							<audioSource>5__5.Play();
							Object.Destroy((Object)(object)<audioObject>5__4, <clip>5__3.length);
							<clip>5__3 = null;
							<audioObject>5__4 = null;
							<audioSource>5__5 = null;
						}
						<>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_0015: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayAudioFromUrl>d__0(0)
			{
				<>4__this = this,
				url = url,
				position = position
			};
		}
	}
	public class CoroutineRunner : MonoBehaviour
	{
		private static CoroutineRunner _instance;

		public static CoroutineRunner Instance
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("CoroutineRunner");
					Object.DontDestroyOnLoad((Object)(object)val);
					_instance = val.AddComponent<CoroutineRunner>();
				}
				return _instance;
			}
		}

		public void Run(IEnumerator routine)
		{
			((MonoBehaviour)this).StartCoroutine(routine);
		}
	}
	public record PlayerWrapperType(ZNetPeer Peer, ZDO Zdo)
	{
		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 string Info => PlayerUtils.GetPlayerInfo(Peer);

		public Vector3 RefPosition => Peer.GetRefPos();

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

		public ZDOID ZdoUid => Zdo.m_uid;

		public Vector3 WorldPosition => Zdo.GetPosition();

		public Quaternion Rotation => Zdo.GetRotation();

		public long UnderlyingUid => Zdo.GetLong(ZDOVars.s_playerID, 0L);

		public long Owner => Zdo.GetOwner();

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

		public override string ToString()
		{
			//IL_0018: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			RuntimeHelpers.EnsureSufficientExecutionStack();
			builder.Append("Peer = ");
			builder.Append(Peer);
			builder.Append(", Zdo = ");
			builder.Append(Zdo);
			builder.Append(", RPC = ");
			builder.Append(RPC);
			builder.Append(", ZDOID = ");
			builder.Append(ZDOID.ToString());
			builder.Append(", Name = ");
			builder.Append((object?)Name);
			builder.Append(", PlayerId = ");
			ZDOID val = PlayerId;
			builder.Append(((object)(ZDOID)(ref val)).ToString());
			builder.Append(", Info = ");
			builder.Append((object?)Info);
			builder.Append(", RefPosition = ");
			Vector3 val2 = RefPosition;
			builder.Append(((object)(Vector3)(ref val2)).ToString());
			builder.Append(", SocketEndpoint = ");
			builder.Append((object?)SocketEndpoint);
			builder.Append(", ZdoUid = ");
			val = ZdoUid;
			builder.Append(((object)(ZDOID)(ref val)).ToString());
			builder.Append(", WorldPosition = ");
			val2 = WorldPosition;
			builder.Append(((object)(Vector3)(ref val2)).ToString());
			builder.Append(", Rotation = ");
			Quaternion rotation = Rotation;
			builder.Append(((object)(Quaternion)(ref rotation)).ToString());
			builder.Append(", UnderlyingUid = ");
			builder.Append(UnderlyingUid.ToString());
			builder.Append(", Owner = ");
			builder.Append(Owner.ToString());
			return true;
		}
	}
}
namespace PolyhydraGames.Valheim.Plugin.Extensions
{
	public static class Helpers
	{
		public static void ShowPopup(MessageType msgType, string message)
		{
			MessageHud.instance.ShowMessage((MessageType)1, message, 0, (Sprite)null, false);
		}

		[CanBeNull]
		public static StatusEffect GetEffect(string statusName)
		{
			int stableHashCode = statusName.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(statusName, StringComparison.OrdinalIgnoreCase)));
				if ((Object)(object)val == (Object)null)
				{
					string text = "No effect found for " + statusName + "Effects: " + string.Join(", ", ObjectDB.instance.m_StatusEffects.Select((StatusEffect x) => ((Object)x).name));
					Logger.LogWarning((object)text);
				}
			}
			return val;
		}

		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)
		{
			string value;
			return RpcCommandMap.Names.TryGetValue(command, out value) ? value : "RPC_Unknown";
		}

		public static string GetRemainingString(this CommandArgs args, int index)
		{
			return string.Join(" ", args.Arguments.Skip(index));
		}

		public static string GetPlayerInfo()
		{
			string[] value = (from x in Player.GetAllPlayers()
				select x.GetPlayerID() + " - " + x.GetPlayerName()).ToArray();
			return string.Join("\n", value);
		}

		public static void ListPrefabs()
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				ZLog.Log((object)"ZNetScene not ready yet.");
				return;
			}
			List<string> prefabNames = ZNetScene.instance.GetPrefabNames();
			foreach (string item in prefabNames)
			{
				ZLog.Log((object)("Prefab: " + item));
			}
			ZLog.Log((object)$"Total prefabs: {prefabNames.Count}");
		}

		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();
			foreach (string item in list)
			{
				ZLog.Log((object)("Environment: " + item));
			}
			ZLog.Log((object)$"Total environments: {list.Count}");
			return list;
		}
	}
	public static class PlayerWrapper
	{
		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 PlayerWrapperType Create(ZNetPeer peer)
		{
			return new PlayerWrapperType(peer, PlayerUtils.GetZDO(peer));
		}

		public static void InvokeRoutedRpcOnWorld(this PlayerWrapperType player, RpcCommand rpc, params object[] args)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(player.Owner, rpc.GetRpcCommandName(), args);
		}

		public static void InvokeRoutedRpc(this PlayerWrapperType player, ZDOID target, RpcCommand rpc, params object[] args)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			ZRoutedRpc.instance.InvokeRoutedRPC(player.Owner, target, rpc.GetRpcCommandName(), args);
		}

		public static void InvokeRoutedRpcOnSelf(this PlayerWrapperType player, RpcCommand rpc, params object[] args)
		{
			//IL_0003: 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 enum RpcCommand
	{
		SetGuardianPower,
		UseGuardianPower,
		PeerInfo,
		NetTime,
		ServerHandshake,
		ClientHandshake,
		ServerSyncedPlayerData,
		Disconnect,
		Error,
		Kick,
		Kicked,
		Ban,
		Unban,
		AdminList,
		Save,
		SavePlayerProfile,
		PlayerList,
		PrintBanned,
		RemoteCommand,
		RemotePrint,
		SpawnObject,
		DestroyZDO,
		RequestZDO,
		ZDOData,
		RoutedRPC,
		SetTrigger,
		Heal,
		Damage,
		Stagger,
		UseStamina,
		OnDeath,
		OnTargeted,
		FlashShield,
		AddStatusEffect,
		Controls,
		ReleaseControl,
		RequestControl,
		RequestRespons,
		ChatMessage,
		TeleportPlayer,
		Say,
		DropItem,
		DropItemByName,
		RequestOwn,
		SetPose,
		SetVisualItem,
		OpenRespons,
		RequestStack,
		StackResponse,
		RequestOpen,
		RequestTakeAll,
		TakeAllRespons,
		AddFuel,
		AddItem,
		RemoveDoneItem,
		SetSlotVisual,
		AddFuelAmount,
		SetFuelAmount,
		ToggleOn,
		Pickup,
		RequestPickup,
		UseDoor,
		Repair,
		Remove,
		HealthChanged,
		UpdateMaterial,
		SetAreaHealth,
		SetEvent,
		BossSpawnInitiated,
		RemoveBossSpawnInventoryItems,
		SpawnBoss,
		SetTamed,
		ResetCloth,
		FreezeFrame,
		OnHit,
		Attach,
		TeleportTo,
		StaggerCreature,
		OnEat,
		TryEat,
		EatConfirmation,
		Nibble,
		Step,
		Wakeup,
		Grow,
		Shake,
		Command,
		UnSummon,
		SetName,
		Forward,
		Backward,
		Rudder,
		Stop,
		AddSaddle,
		RemoveSaddle,
		SetSaddle,
		RequestControlShip,
		ReleaseControlShip,
		SetGlobalKey,
		RemoveGlobalKey,
		GlobalKeys,
		LocationIcons,
		AddNoise
	}
	public static class RpcCommandMap
	{
		public static readonly Dictionary<RpcCommand, string> Names = new Dictionary<RpcCommand, string>
		{
			{
				RpcCommand.SetGuardianPower,
				"RPC_SetGuardianPower"
			},
			{
				RpcCommand.UseGuardianPower,
				"RPC_UseGuardianPower"
			},
			{
				RpcCommand.PeerInfo,
				"RPC_PeerInfo"
			},
			{
				RpcCommand.NetTime,
				"RPC_NetTime"
			},
			{
				RpcCommand.ServerHandshake,
				"RPC_ServerHandshake"
			},
			{
				RpcCommand.ClientHandshake,
				"RPC_ClientHandshake"
			},
			{
				RpcCommand.ServerSyncedPlayerData,
				"RPC_ServerSyncedPlayerData"
			},
			{
				RpcCommand.Disconnect,
				"RPC_Disconnect"
			},
			{
				RpcCommand.Error,
				"RPC_Error"
			},
			{
				RpcCommand.Kick,
				"RPC_Kick"
			},
			{
				RpcCommand.Kicked,
				"RPC_Kicked"
			},
			{
				RpcCommand.Ban,
				"RPC_Ban"
			},
			{
				RpcCommand.Unban,
				"RPC_Unban"
			},
			{
				RpcCommand.AdminList,
				"RPC_AdminList"
			},
			{
				RpcCommand.Save,
				"RPC_Save"
			},
			{
				RpcCommand.SavePlayerProfile,
				"RPC_SavePlayerProfile"
			},
			{
				RpcCommand.PlayerList,
				"RPC_PlayerList"
			},
			{
				RpcCommand.PrintBanned,
				"RPC_PrintBanned"
			},
			{
				RpcCommand.RemoteCommand,
				"RPC_RemoteCommand"
			},
			{
				RpcCommand.RemotePrint,
				"RPC_RemotePrint"
			},
			{
				RpcCommand.SpawnObject,
				"RPC_SpawnObject"
			},
			{
				RpcCommand.DestroyZDO,
				"RPC_DestroyZDO"
			},
			{
				RpcCommand.RequestZDO,
				"RPC_RequestZDO"
			},
			{
				RpcCommand.ZDOData,
				"RPC_ZDOData"
			},
			{
				RpcCommand.RoutedRPC,
				"RPC_RoutedRPC"
			},
			{
				RpcCommand.SetTrigger,
				"RPC_SetTrigger"
			},
			{
				RpcCommand.Heal,
				"RPC_Heal"
			},
			{
				RpcCommand.Damage,
				"RPC_Damage"
			},
			{
				RpcCommand.Stagger,
				"RPC_Stagger"
			},
			{
				RpcCommand.UseStamina,
				"RPC_UseStamina"
			},
			{
				RpcCommand.OnDeath,
				"RPC_OnDeath"
			},
			{
				RpcCommand.OnTargeted,
				"RPC_OnTargeted"
			},
			{
				RpcCommand.FlashShield,
				"RPC_FlashShield"
			},
			{
				RpcCommand.AddStatusEffect,
				"RPC_AddStatusEffect"
			},
			{
				RpcCommand.Controls,
				"RPC_Controls"
			},
			{
				RpcCommand.ReleaseControl,
				"RPC_ReleaseControl"
			},
			{
				RpcCommand.RequestControl,
				"RPC_RequestControl"
			},
			{
				RpcCommand.RequestRespons,
				"RPC_RequestRespons"
			},
			{
				RpcCommand.ChatMessage,
				"RPC_ChatMessage"
			},
			{
				RpcCommand.TeleportPlayer,
				"RPC_TeleportPlayer"
			},
			{
				RpcCommand.Say,
				"RPC_Say"
			},
			{
				RpcCommand.DropItem,
				"RPC_DropItem"
			},
			{
				RpcCommand.DropItemByName,
				"RPC_DropItemByName"
			},
			{
				RpcCommand.RequestOwn,
				"RPC_RequestOwn"
			},
			{
				RpcCommand.SetPose,
				"RPC_SetPose"
			},
			{
				RpcCommand.SetVisualItem,
				"RPC_SetVisualItem"
			},
			{
				RpcCommand.OpenRespons,
				"RPC_OpenRespons"
			},
			{
				RpcCommand.RequestStack,
				"RPC_RequestStack"
			},
			{
				RpcCommand.StackResponse,
				"RPC_StackResponse"
			},
			{
				RpcCommand.RequestOpen,
				"RPC_RequestOpen"
			},
			{
				RpcCommand.RequestTakeAll,
				"RPC_RequestTakeAll"
			},
			{
				RpcCommand.TakeAllRespons,
				"RPC_TakeAllRespons"
			},
			{
				RpcCommand.AddFuel,
				"RPC_AddFuel"
			},
			{
				RpcCommand.AddItem,
				"RPC_AddItem"
			},
			{
				RpcCommand.RemoveDoneItem,
				"RPC_RemoveDoneItem"
			},
			{
				RpcCommand.SetSlotVisual,
				"RPC_SetSlotVisual"
			},
			{
				RpcCommand.AddFuelAmount,
				"RPC_AddFuelAmount"
			},
			{
				RpcCommand.SetFuelAmount,
				"RPC_SetFuelAmount"
			},
			{
				RpcCommand.ToggleOn,
				"RPC_ToggleOn"
			},
			{
				RpcCommand.Pickup,
				"RPC_Pickup"
			},
			{
				RpcCommand.RequestPickup,
				"RPC_RequestPickup"
			},
			{
				RpcCommand.UseDoor,
				"RPC_UseDoor"
			},
			{
				RpcCommand.Repair,
				"RPC_Repair"
			},
			{
				RpcCommand.Remove,
				"RPC_Remove"
			},
			{
				RpcCommand.HealthChanged,
				"RPC_HealthChanged"
			},
			{
				RpcCommand.UpdateMaterial,
				"RPC_UpdateMaterial"
			},
			{
				RpcCommand.SetAreaHealth,
				"RPC_SetAreaHealth"
			},
			{
				RpcCommand.SetEvent,
				"RPC_SetEvent"
			},
			{
				RpcCommand.BossSpawnInitiated,
				"RPC_BossSpawnInitiated"
			},
			{
				RpcCommand.RemoveBossSpawnInventoryItems,
				"RPC_RemoveBossSpawnInventoryItems"
			},
			{
				RpcCommand.SpawnBoss,
				"RPC_SpawnBoss"
			},
			{
				RpcCommand.SetTamed,
				"RPC_SetTamed"
			},
			{
				RpcCommand.ResetCloth,
				"RPC_ResetCloth"
			},
			{
				RpcCommand.FreezeFrame,
				"RPC_FreezeFrame"
			},
			{
				RpcCommand.OnHit,
				"RPC_OnHit"
			},
			{
				RpcCommand.Attach,
				"RPC_Attach"
			},
			{
				RpcCommand.TeleportTo,
				"RPC_TeleportTo"
			},
			{
				RpcCommand.StaggerCreature,
				"RPC_Stagger"
			},
			{
				RpcCommand.OnEat,
				"RPC_OnEat"
			},
			{
				RpcCommand.TryEat,
				"RPC_TryEat"
			},
			{
				RpcCommand.EatConfirmation,
				"RPC_EatConfirmation"
			},
			{
				RpcCommand.Nibble,
				"RPC_Nibble"
			},
			{
				RpcCommand.Step,
				"RPC_Step"
			},
			{
				RpcCommand.Wakeup,
				"RPC_Wakeup"
			},
			{
				RpcCommand.Grow,
				"RPC_Grow"
			},
			{
				RpcCommand.Shake,
				"RPC_Shake"
			},
			{
				RpcCommand.Command,
				"RPC_Command"
			},
			{
				RpcCommand.UnSummon,
				"RPC_UnSummon"
			},
			{
				RpcCommand.SetName,
				"RPC_SetName"
			},
			{
				RpcCommand.Forward,
				"RPC_Forward"
			},
			{
				RpcCommand.Backward,
				"RPC_Backward"
			},
			{
				RpcCommand.Rudder,
				"RPC_Rudder"
			},
			{
				RpcCommand.Stop,
				"RPC_Stop"
			},
			{
				RpcCommand.AddSaddle,
				"RPC_AddSaddle"
			},
			{
				RpcCommand.RemoveSaddle,
				"RPC_RemoveSaddle"
			},
			{
				RpcCommand.SetSaddle,
				"RPC_SetSaddle"
			},
			{
				RpcCommand.RequestControlShip,
				"RPC_RequestControl"
			},
			{
				RpcCommand.ReleaseControlShip,
				"RPC_ReleaseControl"
			},
			{
				RpcCommand.SetGlobalKey,
				"RPC_SetGlobalKey"
			},
			{
				RpcCommand.RemoveGlobalKey,
				"RPC_RemoveGlobalKey"
			},
			{
				RpcCommand.GlobalKeys,
				"RPC_GlobalKeys"
			},
			{
				RpcCommand.LocationIcons,
				"RPC_LocationIcons"
			},
			{
				RpcCommand.AddNoise,
				"RPC_AddNoise"
			}
		};
	}
	public static class Strings
	{
		public static string[] Effects => new string[146]
		{
			"AdrenalineRush", "AdrenalineRush2", "AdrenalineRush3", "AdrenalineRush4", "BeltStrength", "Burning", "CampFire", "Cold", "CorpseRun", "Demister",
			"Encumbered", "Freezing", "Frost", "GoblinShaman_shield", "GP_Bonemass", "GP_Eikthyr", "GP_Fader", "GP_Moder", "GP_Queen", "GP_TheElder",
			"GP_Yagluth", "Harpooned", "Immobilized", "ImmobilizedAshlands", "ImmobilizedLong", "Lightning", "Poison", "Potion_barleywine", "Potion_BugRepellent", "Potion_bzerker",
			"Potion_eitr_lingering", "Potion_eitr_minor", "Potion_frostresist", "Potion_hasty", "Potion_health_lingering", "Potion_health_major", "Potion_health_medium", "Potion_health_minor", "Potion_LightFoot", "Potion_poisonresist",
			"Potion_stamina_lingering", "Potion_stamina_medium", "Potion_stamina_minor", "Potion_strength", "Potion_swimmer", "Potion_tamer", "Potion_tasty", "Potion_TrollPheromones", "Puke", "Rested",
			"Resting", "SE_Dvergr_buff", "SE_Dvergr_heal", "SE_Greydwarf_shaman_heal", "SetEffect_AshlandsMediumArmor", "SetEffect_BerserkerArmor", "SetEffect_BerserkerUndeadArmor", "SetEffect_FenringArmor", "SetEffect_FishingHat", "SetEffect_HarvesterArmor",
			"SetEffect_MageArmor", "SetEffect_RootArmor", "SetEffect_TrollArmor", "SetEffect_WolfArmor", "Shelter", "Slimed", "SlowFall", "Smoked", "SoftDeath", "Spirit",
			"Staff_shield", "Tared", "TrinketBlackDamageHealth", "TrinketBlackStamina", "TrinketBronzeHealth", "TrinketBronzeStamina", "TrinketCarapaceEitr", "TrinketChitinSwim", "TrinketFlametalEitr", "TrinketFlametalStaminaHealth",
			"TrinketIronHealth", "TrinketIronStamina", "TrinketScaleStaminaDamage", "TrinketSilverDamage", "TrinketSilverResist", "Warm", "Wet", "WindRun", "Wishbone", "Potion__minor_stamina_lingering_TW",
			"Potion__medium_stamina_lingering_TW", "Potion_lightningresist_TW", "Effect_CapeRotten_TW", "SE_Decapitator5_TW", "SE_Vampirism_TW", "SE_Decapitator4_TW", "SE_Smasher_TW", "SE_Crusher_TW", "PinnedModer", "SE_Piercer_TW",
			"Piercing", "Warfare_LightningBurstStacking", "SE_Executioner_15_TW", "SE_Meteor_TW", "SE_Rip_TW", "SE_Bleeding_TW", "SE_Adrenaline_TW", "SE_Hunger_TW", "SE_Shredder_TW", "SE_Bash_3_TW",
			"SE_Bash_2_TW", "SE_Bash_4_TW", "SE_Bash_5_TW", "SE_Impale_TW", "PreventPulling", "Warfare_Adrenaline", "Warfare_Bleeding", "Warfare_Bleeding_Stacking", "Warfare_BleedingSecondaryAttack", "Warfare_Bludgeoner",
			"Warfare_Bludgeoner_ShreadResistance", "Warfare_BurningSecondaryAttack", "Warfare_Decapitator", "Warfare_Decapitator_ShreadResistance", "Warfare_EikthyrCrossbow", "Warfare_Ghost", "Warfare_HacknSlash", "Warfare_HacknSlash_ShreadResistance", "Warfare_Haste", "Warfare_Haste_Stacking",
			"Warfare_Impale", "Warfare_Juggernaut", "Warfare_Juggernaut_ShreadResistance", "Warfare_PiercingGreatbowMistlands", "Warfare_PiercingGreatbowPlains", "Warfare_Pinned", "Warfare_PinnedFrozen", "Warfare_Protector", "Warfare_Protector_Stacking", "Warfare_Shatter",
			"Warfare_Smasher", "Warfare_Smasher_ShreadResistance", "Warfare_SmashnBash", "Warfare_SmashnBash_ShreadResistance", "Warfare_Vampirism", "Paralyze"
		};
	}
	public static class StringUtils
	{
		public static int GetStableHashCode(this string str)
		{
			int num = 5381;
			foreach (char c in str)
			{
				num = (num * 33) ^ c;
			}
			return num;
		}
	}
}
namespace PolyhydraGames.Valheim.Plugin.Commands
{
	internal class GetEvent : RconCommand
	{
		public override string Command => "getevent";

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

		protected override string OnHandle(CommandArgs args)
		{
			RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
			RandomEvent currentRandomEvent = RandEventSystem.instance.GetCurrentRandomEvent();
			if (activeEvent == null && currentRandomEvent == null)
			{
				return "No active raid.";
			}
			return "Active: " + (activeEvent?.m_name ?? "none") + " | Random: " + (currentRandomEvent?.m_name ?? "none");
		}
	}
	internal class Impersonate : RconCommand
	{
		private static readonly Dictionary<string, UserInfo> ImpersonatedUsers = new Dictionary<string, UserInfo>();

		private static ulong NextId = 1uL;

		public override string Command => "impersonate";

		public override 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);
		}

		protected override string OnHandle(CommandArgs args)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (args.Arguments.Count < 2)
			{
				return "Usage: impersonate <name> <message>";
			}
			string text = "";
			string text2 = "";
			try
			{
				text = args.GetString(0);
				text2 = string.Join(" ", args.Arguments.Skip(1));
				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,
					GetUserInfo(text),
					text2
				});
				return "Impersonated: " + text + " - " + text2;
			}
			catch (Exception ex)
			{
				return ex.Message + " FAILED  !!! Impersonated: " + text + " - " + text2;
			}
		}
	}
	internal class ListEvents : RconCommand
	{
		public override string Command => "listevents";

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

		protected override string OnHandle(CommandArgs args)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Available events:");
			foreach (RandomEvent @event in RandEventSystem.instance.m_events)
			{
				stringBuilder.AppendLine($"- {@event.m_name} (enabled={@event.m_enabled})");
			}
			return stringBuilder.ToString();
		}
	}
	public abstract class PolyRconCommand : RconCommand
	{
		public static readonly UserInfo ServerUserInfo = new UserInfo
		{
			Name = string.Empty,
			UserId = new PlatformUserID("Bot", 0uL, false)
		};

		public abstract string Method { get; }

		protected override string OnHandle(CommandArgs args)
		{
			string @string = args.GetString(0);
			ZNetPeer val = ZNet.instance.GetPeerByHostName(@string) ?? ZNet.instance.GetPeerByPlayerName(@string);
			if (val == null)
			{
				return "Cannot find user " + @string;
			}
			ZDO zDO = PlayerUtils.GetZDO(val);
			return (zDO == null) ? ("Cannot handle command for player " + PlayerUtils.GetPlayerInfo(val) + ". ZDO not found") : OnHandle(PlayerWrapper.Create(val), args);
		}

		protected abstract string OnHandle(PlayerWrapperType player, CommandArgs args);

		protected void InvokeRouted(PlayerWrapperType player, params object[] items)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(player.ZDOID, Method, items);
		}
	}
	internal class RaidCommand : PolyRconCommand
	{
		public override string Command => "raid";

		public override string Description => "Start a raid. Usage: raid <eventName> [player]";

		public override string Method { get; } = "";


		protected override string OnHandle(PlayerWrapperType player, CommandArgs args)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (args.Arguments.Count < 1)
			{
				return "Usage: raid [playerId] <eventName>";
			}
			string @string = args.GetString(1);
			Vector3 refPosition = player.RefPosition;
			if (!RandEventSystem.instance.HaveEvent(@string))
			{
				return "No such event: " + @string;
			}
			RandEventSystem.instance.SetRandomEventByName(@string, refPosition);
			return "Raid started: " + @string + " " + ((refPosition != Vector3.zero) ? "at player" : "globally");
		}
	}
	internal class StartRandomRaid : RconCommand
	{
		public override string Command => "startraid";

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

		protected override string OnHandle(CommandArgs args)
		{
			RandEventSystem.instance.ConsoleStartRandomEvent();
			return "Random raid triggered.";
		}
	}
	internal class StopRaid : RconCommand
	{
		public override string Command => "stopraid";

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

		protected override string OnHandle(CommandArgs args)
		{
			RandEventSystem.instance.ConsoleResetRandomEvent();
			return "Raid/event stopped.";
		}
	}
}
namespace PolyhydraGames.Valheim.Plugin.Broke_Commands
{
	internal class Explode : PolyRconCommand
	{
		public override string Command => "explode";

		public override string Description => "Explode a player. Usage: explode <player>";

		public override string Method { get; } = "";


		protected override string OnHandle(PlayerWrapperType player, CommandArgs args)
		{
			//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)
			if (args.Arguments.Count < 1)
			{
				return "Usage: explode <player>";
			}
			Object.Instantiate<GameObject>(ZNetScene.instance.GetPrefab("vfx_explosion"), player.RefPosition, Quaternion.identity);
			return "Boom! Exploded " + player.Name + ".";
		}
	}
	internal class ResetWind : RconCommand
	{
		public override string Command => "resetwind";

		public override string Description => "Reset wind to normal.";

		protected override string OnHandle(CommandArgs args)
		{
			EnvMan instance = EnvMan.instance;
			if (instance != null)
			{
				instance.ResetDebugWind();
			}
			return "Wind reset.";
		}
	}
	internal class SetTime : RconCommand
	{
		public override string Command => "settime";

		public override string Description => "Set time of day fraction (0=midnight, 0.5=noon).";

		protected override string OnHandle(CommandArgs args)
		{
			if (args.Arguments.Count < 1)
			{
				return "Usage: settime <0.0-1.0>";
			}
			if (!float.TryParse(args.GetString(0), out var result))
			{
				return "Invalid number";
			}
			EnvMan.instance.m_debugTimeOfDay = true;
			EnvMan.instance.m_debugTime = Mathf.Clamp01(result);
			return $"Time set to {result}";
		}
	}
	internal class SetWeather : RconCommand
	{
		public override string Command => "setweather";

		public override string Description => "Forces the environment/weather. Usage: setweather <name>";

		private string Usage()
		{
			string text = string.Join(", ", Helpers.GetEnvironmentNames());
			return "Usage: setweather <envName> (" + text + ")";
		}

		protected override string OnHandle(CommandArgs args)
		{
			if ((Object)(object)EnvMan.instance == (Object)null)
			{
				return "EnvMan not initialized";
			}
			if (args.Arguments.Count < 1)
			{
				return Usage();
			}
			string envName = args.GetString(0);
			List<string> environmentNames = Helpers.GetEnvironmentNames();
			if (environmentNames.All((string x) => x != envName))
			{
				return Usage();
			}
			EnvMan.instance.SetForceEnvironment(envName);
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "RPC_SetEnvironment", new object[2] { envName, 0f });
			return "Forced environment set to " + envName;
		}
	}
	internal class SetWind : RconCommand
	{
		public override string Command => "setwind";

		public override string Description => "Set wind. Usage: setwind <angle> <intensity>";

		protected override string OnHandle(CommandArgs args)
		{
			if (args.Arguments.Count < 2)
			{
				return "Usage: setwind <angle> <intensity>";
			}
			if (!float.TryParse(args.GetString(0), out var result) || !float.TryParse(args.GetString(1), out var result2))
			{
				return "Invalid numbers";
			}
			EnvMan instance = EnvMan.instance;
			if (instance != null)
			{
				instance.SetDebugWind(result, result2);
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "RPC_SetDebugWind", new object[2] { result, result2 });
			return $"Wind forced: {result}°, {result2}";
		}
	}
	internal class SkipMorning : RconCommand
	{
		public override string Command => "skipmorning";

		public override string Description => "Skips to next morning.";

		protected override string OnHandle(CommandArgs args)
		{
			EnvMan instance = EnvMan.instance;
			if (instance != null)
			{
				instance.SkipToMorning();
			}
			return "Skipped to morning.";
		}
	}
	internal class Stagger : PolyRconCommand
	{
		public override string Command => "stagger";

		public override string Description => "stagger the player. Usage: stagger <player>";

		public override string Method => RpcCommand.Stagger.GetRpcCommandName();

		protected override string OnHandle(PlayerWrapperType player, CommandArgs args)
		{
			//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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (args.Arguments.Count < 2)
			{
				return ((RconCommand)this).Description;
			}
			object[] array = new object[1];
			Vector3 refPosition = player.RefPosition;
			refPosition.x = player.RefPosition.x + 1f;
			array[0] = refPosition;
			InvokeRouted(player, array);
			return "Staggered " + player.Name;
		}
	}
}
namespace PolyhydraGames.Valheim.Plugin.AddNoise
{
	[HarmonyPatch(typeof(Game))]
	public static class AddNoiseBootStrap
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Register()
		{
			Logger.LogInfo((object)"Registered AddNoiseBootStrap");
			ZRoutedRpc.instance.Register<string, Vector3>("AddNoise", (Action<long, string, Vector3>)PlayNoise);
		}

		private static void PlayNoise(long sender, string effectName, Vector3 _)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = Player.m_localPlayer.GetPosition();
			if (effectName.Contains("https:"))
			{
				Logger.LogInfo((object)("Received URL request to playNoise " + effectName));
				try
				{
					AudioHelper audioHelper = new AudioHelper();
					((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(audioHelper.PlayAudioFromUrl(effectName, position));
					return;
				}
				catch (Exception ex)
				{
					Logger.LogError((object)ex.Message);
					return;
				}
			}
			Logger.LogInfo((object)("Received URL request to playNoise " + effectName));
			GameObject prefab = PrefabManager.Instance.GetPrefab(effectName);
			if ((Object)(object)prefab != (Object)null)
			{
				Object.Instantiate<GameObject>(prefab, position, Quaternion.identity);
				Logger.LogWarning((object)$"Played {effectName} at {position}");
			}
			else
			{
				Logger.LogWarning((object)("Effect prefab " + effectName + " not found!"));
			}
		}
	}
	internal class AddNoise : PolyRconCommand
	{
		public override string Command => "addnoise";

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

		public override string Method => "AddNoise";

		protected override string OnHandle(PlayerWrapperType player, CommandArgs args)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (args.Arguments.Count < 2)
			{
				return "Usage: addnoise <player> <noiseName> <position>";
			}
			string @string = args.GetString(1);
			Vector3 vector = CommandArgsExtensions.GetVector3(args, 2);
			ZRoutedRpc.instance.InvokeRoutedRPC(player.ZDOID, "AddNoise", new object[2] { @string, vector });
			return "Played noise '" + @string + "' at " + player.Name;
		}
	}
	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.Plugin.AddEffect
{
	[HarmonyPatch(typeof(Game))]
	public static class AddEffectBootStrap
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void Register()
		{
			Logger.LogInfo((object)"Registered AddEffectBootStrap");
			ZRoutedRpc.instance.Register<string>("ApplyStatusEffect", (Action<long, string>)OnApplyStatusEffect);
		}

		private static void OnApplyStatusEffect(long sender, string effectName)
		{
			Logger.LogInfo((object)("Client received request to apply " + effectName));
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				StatusEffect effect = Helpers.GetEffect(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((object)("StatusEffect " + effectName + " not found in ObjectDB"));
				}
			}
		}
	}
	internal class AddEffect : PolyRconCommand
	{
		public override string Command => "addeffect";

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

		public override string Method => "ApplyStatusEffect";

		private string ProcessCommand(PlayerWrapperType player, CommandArgs args)
		{
			string @string = args.GetString(1);
			InvokeRouted(player, @string);
			return "Applied status '" + @string + "' to " + player.Name;
		}

		protected override string OnHandle(PlayerWrapperType player, CommandArgs args)
		{
			if (args.Arguments.Count < 2)
			{
				return "Usage: addstatus <player> <statusName>";
			}
			return ProcessCommand(player, args);
		}
	}
	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;
	}
}