using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("ForgeKit")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+294094e110e9aca56665cc10cce0047db95418d1")]
[assembly: AssemblyProduct("ForgeKit")]
[assembly: AssemblyTitle("ForgeKit")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
namespace ForgeKit;

public sealed class CommandChannel
{
	private readonly string _path;

	private readonly ManualLogSource _log;

	private readonly CommandRegistry _registry;

	private readonly float _pollSeconds;

	private readonly bool _allLines;

	private float _check;

	private long _stamp;

	public string Path => _path;

	public CommandChannel(string fileName, ManualLogSource log, CommandRegistry registry, float pollSeconds = 0.5f, bool allLines = true, bool primeStamp = false)
	{
		_path = System.IO.Path.Combine(Paths.ConfigPath, fileName);
		_log = log;
		_registry = registry;
		_pollSeconds = pollSeconds;
		_allLines = allLines;
		if (primeStamp)
		{
			_stamp = (File.Exists(_path) ? File.GetLastWriteTimeUtc(_path).Ticks : 0);
		}
	}

	public void Tick()
	{
		if (!(Time.unscaledTime - _check <= _pollSeconds))
		{
			_check = Time.unscaledTime;
			Poll();
		}
	}

	private void Poll()
	{
		try
		{
			if (!File.Exists(_path))
			{
				return;
			}
			long ticks = File.GetLastWriteTimeUtc(_path).Ticks;
			if (ticks == _stamp)
			{
				return;
			}
			_stamp = ticks;
			if (_allLines)
			{
				string[] array = File.ReadAllLines(_path);
				foreach (string text in array)
				{
					string text2 = text.Trim();
					if (text2.Length != 0 && !text2.StartsWith("#"))
					{
						Run(text2);
					}
				}
				return;
			}
			string text3 = null;
			string[] array2 = File.ReadAllLines(_path);
			foreach (string text4 in array2)
			{
				if (!string.IsNullOrWhiteSpace(text4))
				{
					text3 = text4;
					break;
				}
			}
			if (!string.IsNullOrWhiteSpace(text3))
			{
				Run(text3.Trim());
			}
		}
		catch (Exception ex)
		{
			_log.LogWarning((object)("[CMD] poll error: " + ex.Message));
		}
	}

	public void Run(string cmd)
	{
		_log.LogMessage((object)("[CMD] run: " + cmd));
		string[] array = cmd.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
		string verb = ((array.Length != 0) ? array[0] : "");
		if (_registry.TryGet(verb, out var run))
		{
			run(array);
		}
		else
		{
			_registry.PrintHelp(verb);
		}
	}
}
public sealed class CommandRegistry
{
	private readonly ManualLogSource _log;

	private readonly Dictionary<string, Action<string[]>> _run = new Dictionary<string, Action<string[]>>(StringComparer.OrdinalIgnoreCase);

	private readonly List<KeyValuePair<string, string>> _help = new List<KeyValuePair<string, string>>();

	public CommandRegistry(ManualLogSource log)
	{
		_log = log;
	}

	public void Register(string verb, string help, Action<string[]> run)
	{
		Register(new string[1] { verb }, help, run);
	}

	public void Register(string[] verbs, string help, Action<string[]> run)
	{
		foreach (string v in verbs)
		{
			_run[v] = delegate(string[] args)
			{
				try
				{
					run(args);
				}
				catch (Exception arg)
				{
					_log.LogError((object)$"[CMD] '{v}' failed: {arg}");
				}
			};
		}
		_help.Add(new KeyValuePair<string, string>(string.Join("/", verbs), help));
	}

	public bool TryGet(string verb, out Action<string[]> run)
	{
		return _run.TryGetValue(verb, out run);
	}

	public void PrintHelp(string verb)
	{
		if (string.IsNullOrEmpty(verb) || string.Equals(verb, "help", StringComparison.OrdinalIgnoreCase))
		{
			_log.LogMessage((object)$"[CMD] {_help.Count} registered verbs:");
		}
		else
		{
			_log.LogWarning((object)$"[CMD] unknown verb '{verb}' — {_help.Count} registered verbs:");
		}
		foreach (KeyValuePair<string, string> item in _help)
		{
			_log.LogMessage((object)("[CMD]   " + item.Key + " — " + item.Value));
		}
	}
}
public static class EmbeddedRes
{
	public static string Text(Assembly asm, string suffix, string logTag, ManualLogSource log = null)
	{
		string text = Array.Find(asm.GetManifestResourceNames(), (string n) => n.EndsWith(suffix, StringComparison.OrdinalIgnoreCase));
		if (text == null)
		{
			ManualLogSource obj = log ?? Plugin.Log;
			if (obj != null)
			{
				obj.LogWarning((object)(logTag + " embedded " + suffix + " not found."));
			}
			return "";
		}
		using Stream stream = asm.GetManifestResourceStream(text);
		using StreamReader streamReader = new StreamReader(stream);
		return streamReader.ReadToEnd();
	}

	public static Texture2D Texture(Assembly asm, string suffix, string logTag, ManualLogSource log = null)
	{
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Expected O, but got Unknown
		ManualLogSource val = log ?? Plugin.Log;
		try
		{
			string text = Array.Find(asm.GetManifestResourceNames(), (string n) => n.EndsWith(suffix, StringComparison.OrdinalIgnoreCase));
			if (text == null)
			{
				if (val != null)
				{
					val.LogWarning((object)(logTag + " embedded icon '" + suffix + "' missing from the DLL — keeping the donor icon."));
				}
				return null;
			}
			byte[] array;
			using (Stream stream = asm.GetManifestResourceStream(text))
			{
				using MemoryStream memoryStream = new MemoryStream();
				stream.CopyTo(memoryStream);
				array = memoryStream.ToArray();
			}
			Texture2D val2 = new Texture2D(2, 2, (TextureFormat)4, false);
			if (!ImageConversion.LoadImage(val2, array))
			{
				if (val != null)
				{
					val.LogWarning((object)(logTag + " icon '" + suffix + "' failed to decode."));
				}
				return null;
			}
			((Object)val2).hideFlags = (HideFlags)61;
			return val2;
		}
		catch (Exception ex)
		{
			if (val != null)
			{
				val.LogWarning((object)(logTag + " icon '" + suffix + "' load failed: " + ex.Message));
			}
			return null;
		}
	}
}
public static class Keybinds
{
	private struct Bound
	{
		public string Mod;

		public string Action;

		public string ConfigHint;

		public KeyboardShortcut Combo;
	}

	private static readonly Dictionary<string, Bound> _claims = new Dictionary<string, Bound>();

	private static ManualLogSource L => Notify.Log ?? Plugin.Log;

	private static bool SameCombo(KeyboardShortcut a, KeyboardShortcut b)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: 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)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		if (((KeyboardShortcut)(ref a)).MainKey != ((KeyboardShortcut)(ref b)).MainKey)
		{
			return false;
		}
		List<KeyCode> list = new List<KeyCode>(((KeyboardShortcut)(ref a)).Modifiers);
		List<KeyCode> list2 = new List<KeyCode>(((KeyboardShortcut)(ref b)).Modifiers);
		if (list.Count != list2.Count)
		{
			return false;
		}
		foreach (KeyCode item in list)
		{
			if (!list2.Contains(item))
			{
				return false;
			}
		}
		return true;
	}

	private static string ComboText(KeyboardShortcut c)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: 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_0047: Unknown result type (might be due to invalid IL or missing references)
		StringBuilder stringBuilder = new StringBuilder();
		foreach (KeyCode modifier in ((KeyboardShortcut)(ref c)).Modifiers)
		{
			stringBuilder.Append(modifier).Append('+');
		}
		return stringBuilder.Append(((KeyboardShortcut)(ref c)).MainKey).ToString();
	}

	public static void Claim(string mod, string action, ConfigEntry<KeyboardShortcut> entry)
	{
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		if (entry != null)
		{
			string hint = "[" + ((ConfigEntryBase)entry).Definition.Section + "] " + ((ConfigEntryBase)entry).Definition.Key;
			Claim(mod, action, entry.Value, hint);
			entry.SettingChanged += delegate
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				Claim(mod, action, entry.Value, hint);
			};
		}
	}

	public static void Claim(string mod, string action, KeyCode key, string configHint)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		Keybinds.Claim(mod, action, new KeyboardShortcut(key, Array.Empty<KeyCode>()), configHint);
	}

	public static void Claim(string mod, string action, KeyboardShortcut combo, string configHint)
	{
		//IL_0002: 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_0038: 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_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		if ((int)((KeyboardShortcut)(ref combo)).MainKey == 0)
		{
			return;
		}
		string text = mod + "|" + action;
		_claims[text] = new Bound
		{
			Mod = mod,
			Action = action,
			Combo = combo,
			ConfigHint = configHint
		};
		List<Bound> list = Others(combo, text);
		if (list.Count == 0)
		{
			return;
		}
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.Append("[KEYBIND] CONFLICT on " + ComboText(combo) + ": ");
		stringBuilder.Append(Describe(_claims[text]));
		foreach (Bound item in list)
		{
			stringBuilder.Append(" AND ").Append(Describe(item));
		}
		stringBuilder.Append(". One keypress fires ALL of them — that is a real gameplay bug, not just noise ");
		stringBuilder.Append("(Bug 26: opening the spawn menu silently cast Hunt as One). Rebind one of them: ");
		stringBuilder.Append(RebindAdvice(combo, text, list));
		L.LogWarning((object)stringBuilder.ToString());
	}

	public static string Report()
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		if (_claims.Count == 0)
		{
			return "[KEYBIND] no keys claimed.";
		}
		SortedDictionary<string, List<Bound>> sortedDictionary = new SortedDictionary<string, List<Bound>>(StringComparer.Ordinal);
		foreach (Bound value2 in _claims.Values)
		{
			string key = ComboText(value2.Combo);
			if (!sortedDictionary.TryGetValue(key, out var value))
			{
				value = (sortedDictionary[key] = new List<Bound>());
			}
			value.Add(value2);
		}
		StringBuilder stringBuilder = new StringBuilder("[KEYBIND] claimed keys:");
		int num = 0;
		foreach (KeyValuePair<string, List<Bound>> item in sortedDictionary)
		{
			bool flag = item.Value.Count > 1;
			if (flag)
			{
				num++;
			}
			stringBuilder.Append(string.Format("\n  {0,-12}{1}", item.Key, flag ? "*** CONFLICT *** " : ""));
			for (int i = 0; i < item.Value.Count; i++)
			{
				stringBuilder.Append((i == 0) ? "" : " AND ").Append(Describe(item.Value[i]));
			}
		}
		stringBuilder.Append($"\n  {num} conflict(s) across {sortedDictionary.Count} key(s).");
		return stringBuilder.ToString();
	}

	public static bool HasConflicts()
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		foreach (KeyValuePair<string, Bound> claim in _claims)
		{
			if (Others(claim.Value.Combo, claim.Key).Count > 0)
			{
				return true;
			}
		}
		return false;
	}

	private static List<Bound> Others(KeyboardShortcut combo, string selfId)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		List<Bound> list = new List<Bound>();
		foreach (KeyValuePair<string, Bound> claim in _claims)
		{
			if (claim.Key != selfId && SameCombo(claim.Value.Combo, combo))
			{
				list.Add(claim.Value);
			}
		}
		return list;
	}

	private static string Describe(Bound c)
	{
		return c.Mod + " '" + c.Action + "'" + ((c.ConfigHint == null) ? " (HARDCODED — cannot be rebound)" : (" (" + c.ConfigHint + ")"));
	}

	private static string RebindAdvice(KeyboardShortcut combo, string selfId, List<Bound> others)
	{
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		List<Bound> list = new List<Bound>();
		Bound item = _claims[selfId];
		if (item.ConfigHint != null)
		{
			list.Add(item);
		}
		foreach (Bound other in others)
		{
			if (other.ConfigHint != null)
			{
				list.Add(other);
			}
		}
		if (list.Count == 0)
		{
			return "BOTH are hardcoded — this needs a code fix, there is nothing the player can do about " + ComboText(combo) + ".";
		}
		StringBuilder stringBuilder = new StringBuilder();
		for (int i = 0; i < list.Count; i++)
		{
			stringBuilder.Append((i == 0) ? "" : " or ").Append(list[i].Mod + "'s " + list[i].ConfigHint);
		}
		return stringBuilder.ToString() + ".";
	}
}
public static class Lifecycle
{
	private static readonly Dictionary<object, int> _generations = new Dictionary<object, int>();

	public static bool IsSanePosition(Vector3 p)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		if (p.y > -3000f)
		{
			return ((Vector3)(ref p)).sqrMagnitude < 100000000f;
		}
		return false;
	}

	public static int InvalidateWaits(object waitKey)
	{
		if (waitKey == null)
		{
			return 0;
		}
		_generations.TryGetValue(waitKey, out var value);
		value++;
		_generations[waitKey] = value;
		return value;
	}

	private static bool IsStale(object waitKey, int myGen)
	{
		if (waitKey != null && _generations.TryGetValue(waitKey, out var value))
		{
			return value != myGen;
		}
		return false;
	}

	public static IEnumerator WhenPlayerReady(Func<Character> getPlayer, Action<Character> onReady, Action<string> onTimeout = null, float timeoutSeconds = 30f, object waitKey = null)
	{
		int myGen = ((waitKey != null) ? InvalidateWaits(waitKey) : 0);
		float t0 = Time.unscaledTime;
		Character player = null;
		while (Time.unscaledTime - t0 < timeoutSeconds)
		{
			if (IsStale(waitKey, myGen))
			{
				LogSuperseded(waitKey);
				yield break;
			}
			player = getPlayer();
			if ((Object)(object)player != (Object)null && IsSanePosition(((Component)player).transform.position))
			{
				break;
			}
			player = null;
			yield return (object)new WaitForSeconds(0.5f);
		}
		if (IsStale(waitKey, myGen))
		{
			LogSuperseded(waitKey);
		}
		else if ((Object)(object)player == (Object)null)
		{
			onTimeout?.Invoke($"player not ready within {timeoutSeconds:F0}s");
		}
		else
		{
			onReady(player);
		}
	}

	private static void LogSuperseded(object waitKey)
	{
		ManualLogSource obj = Notify.Log ?? Plugin.Log;
		if (obj != null)
		{
			obj.LogMessage((object)$"[LIFECYCLE] superseded a stale WhenPlayerReady wait (key={waitKey}).");
		}
	}
}
public static class Notify
{
	public static ManualLogSource Log;

	private static ManualLogSource L => Log ?? Plugin.Log;

	public static void Player(Character character, string message)
	{
		L.LogMessage((object)("[NOTIFY] " + message));
		if ((Object)(object)character != (Object)null && (Object)(object)character.CharacterUI != (Object)null)
		{
			character.CharacterUI.ShowInfoNotification(message);
		}
		else
		{
			L.LogWarning((object)"[NOTIFY] no CharacterUI to show the toast on (logged only).");
		}
	}
}
[BepInPlugin("cobalt.forgekit", "ForgeKit", "0.1.0")]
public class Plugin : BaseUnityPlugin
{
	public const string GUID = "cobalt.forgekit";

	public const string NAME = "ForgeKit";

	public const string VERSION = "0.1.0";

	internal static ManualLogSource Log;

	internal void Awake()
	{
		Log = ((BaseUnityPlugin)this).Logger;
		Log.LogMessage((object)"ForgeKit 0.1.0 loaded.");
	}
}
public sealed class SelfTestHarness
{
	private readonly ManualLogSource _log;

	private int _pass;

	private int _fail;

	public SelfTestHarness(ManualLogSource log)
	{
		_log = log;
	}

	public void Begin(string tag)
	{
		_pass = (_fail = 0);
		_log.LogMessage((object)("[SELFTEST] BEGIN (" + tag + ")"));
	}

	public void Check(string name, bool ok)
	{
		if (ok)
		{
			_pass++;
			_log.LogMessage((object)("[SELFTEST] PASS: " + name));
		}
		else
		{
			_fail++;
			_log.LogError((object)("[SELFTEST] FAIL: " + name));
		}
	}

	public void Exception(Exception e)
	{
		_fail++;
		_log.LogError((object)("[SELFTEST] EXCEPTION: " + e));
	}

	public void Done()
	{
		_log.LogMessage((object)$"[SELFTEST] DONE pass={_pass} fail={_fail}");
	}
}
public class TableLoader<T>
{
	private readonly Assembly _embeddedSource;

	private readonly ManualLogSource _log;

	private readonly string _fileName;

	private readonly string _logTag;

	private readonly string _singular;

	private readonly string _plural;

	private readonly string _mergeNote;

	private readonly string _reloadSuffix;

	private readonly Func<string, Action<string>, Dictionary<string, T>> _parse;

	private readonly Func<Dictionary<string, T>, Dictionary<string, T>, Dictionary<string, T>> _merge;

	private readonly Func<Dictionary<string, T>, Action<string>, Dictionary<string, T>> _postLoad;

	private readonly Func<Dictionary<string, T>, string> _builtInSuffix;

	private Dictionary<string, T> _table;

	private ManualLogSource Log => _log ?? Plugin.Log;

	public Dictionary<string, T> Table
	{
		get
		{
			if (_table == null)
			{
				_table = Load();
			}
			return _table;
		}
	}

	public TableLoader(Assembly embeddedSource, ManualLogSource log, string fileName, string logTag, string singularNoun, string pluralNoun, Func<string, Action<string>, Dictionary<string, T>> parse, Func<Dictionary<string, T>, Dictionary<string, T>, Dictionary<string, T>> merge, string mergeNote = "replaces per-species", Func<Dictionary<string, T>, Action<string>, Dictionary<string, T>> postLoad = null, Func<Dictionary<string, T>, string> builtInSuffix = null, string reloadSuffix = "")
	{
		_embeddedSource = embeddedSource;
		_log = log;
		_fileName = fileName;
		_logTag = logTag;
		_singular = singularNoun;
		_plural = pluralNoun;
		_parse = parse;
		_merge = merge;
		_mergeNote = mergeNote;
		_postLoad = postLoad;
		_builtInSuffix = builtInSuffix;
		_reloadSuffix = reloadSuffix;
	}

	public Dictionary<string, T> Reload()
	{
		_table = Load();
		Log.LogMessage((object)$"{_logTag} reloaded {_fileName} ({_table.Count} {Noun(_table.Count)}).{_reloadSuffix}");
		return _table;
	}

	private string Noun(int n)
	{
		if (n != 1)
		{
			return _plural;
		}
		return _singular;
	}

	private Dictionary<string, T> Load()
	{
		Action<string> arg = delegate(string m)
		{
			Log.LogWarning((object)(_logTag + " " + _fileName + ": " + m));
		};
		Dictionary<string, T> dictionary = _parse(EmbeddedRes.Text(_embeddedSource, _fileName, _logTag, _log), arg);
		Log.LogMessage((object)string.Format("{0} loaded {1} built-in {2}{3}.", _logTag, dictionary.Count, Noun(dictionary.Count), _builtInSuffix?.Invoke(dictionary) ?? ""));
		try
		{
			string path = Path.Combine(Paths.ConfigPath, _fileName);
			if (File.Exists(path))
			{
				Dictionary<string, T> dictionary2 = _parse(File.ReadAllText(path), arg);
				dictionary = _merge(dictionary, dictionary2);
				Log.LogMessage((object)$"{_logTag} merged {dictionary2.Count} {Noun(dictionary2.Count)} from config override ({_mergeNote}).");
			}
		}
		catch (Exception ex)
		{
			Log.LogWarning((object)(_logTag + " " + _fileName + " override load failed: " + ex.Message));
		}
		if (_postLoad != null)
		{
			dictionary = _postLoad(dictionary, arg);
		}
		return dictionary;
	}
}
public sealed class VerbContext
{
	public Character Player;

	public string[] Parts;

	public string Verb
	{
		get
		{
			if (Parts == null || Parts.Length == 0)
			{
				return "";
			}
			return Parts[0];
		}
	}

	public string Arg(int i)
	{
		if (Parts == null || i < 0 || i >= Parts.Length)
		{
			return null;
		}
		return Parts[i];
	}

	public string Tail(int from = 1)
	{
		if (Parts == null || Parts.Length <= from)
		{
			return null;
		}
		return string.Join(" ", Parts, from, Parts.Length - from);
	}
}
public sealed class VerbHost
{
	private readonly CommandRegistry _commands;

	private readonly ManualLogSource _log;

	private readonly Func<Character> _player;

	public VerbHost(CommandRegistry commands, ManualLogSource log, Func<Character> player)
	{
		_commands = commands;
		_log = log;
		_player = player;
	}

	public void Register(string verb, string help, Action<VerbContext> body, string tag = "[CMD]", bool needsPlayer = true, bool warnOnNoPlayer = true, bool masterOnly = false, string noPlayerMsg = null)
	{
		Register(new string[1] { verb }, help, body, tag, needsPlayer, warnOnNoPlayer, masterOnly, noPlayerMsg);
	}

	public void Register(string[] verbs, string help, Action<VerbContext> body, string tag = "[CMD]", bool needsPlayer = true, bool warnOnNoPlayer = true, bool masterOnly = false, string noPlayerMsg = null)
	{
		_commands.Register(verbs, help, delegate(string[] parts)
		{
			Character val = _player();
			if ((Object)(object)val == (Object)null && needsPlayer)
			{
				string text = noPlayerMsg ?? (tag + " no local player.");
				if (warnOnNoPlayer)
				{
					_log.LogWarning((object)text);
				}
				else
				{
					_log.LogMessage((object)text);
				}
			}
			else
			{
				if (!masterOnly || !PhotonNetwork.isNonMasterClientInRoom)
				{
					VerbContext verbContext = new VerbContext
					{
						Player = val,
						Parts = parts
					};
					try
					{
						body(verbContext);
						return;
					}
					catch (Exception arg)
					{
						_log.LogError((object)$"{tag} '{verbContext.Verb}' failed: {arg}");
						return;
					}
				}
				_log.LogWarning((object)(tag + " non-master client in room — master-only; skipped."));
			}
		});
	}
}